1 #include "error.h"

     2 #include "log.h"

     3 

     4 const struct error_type* error_lookup_code (const struct error_list *list, err_t code)

     5 {

     6     const struct error_type *type;

     7 

     8     // find matching code

     9     for (type = list->list; type->code; type++) {

    10         if (type->code == code)

    11             // found

    12             return type;

    13     }

    14     

    15     // not found

    16     return NULL;

    17 }

    18 

    19 const struct error_type* error_lookup (const error_t *err)

    20 {

    21     struct error_item *item;

    22     struct error_type *type = NULL, *list;

    23 

    24     // traverse stack

    25     for (item = err->cur; item && item >= err->stack; item--) {

    26         if (!list)

    27             // initial type

    28             list = item->list;

    29 

    30         // verify list/type

    31         if (!list)

    32             log_warn("Uknown type");

    33 

    34         else if (!(type = error_lookup_code(list, item->code)))

    35             log_warn("Uknown code %#04x for list %s", item->code, list->name);

    36 

    37         else

    38             // expected list for next item

    39             list = type->sublist;

    40     }

    41 

    42     // return what we found

    43     return type;

    44 }

    45 

    46 const char* error_name (const error_t *err)

    47 {

    48     struct error_type *type;

    49     

    50     // just do a lookup

    51     if ((type = error_lookup(err)))

    52         return "[unknown]";

    53 

    54     else

    55         return type->name;

    56 }

    57 

    58 const char* error_msg (const error_t *err)

    59 {

    60     // XXX: bad to have a single buffer

    61     static char buf[ERROR_MSG_MAX];

    62 

    63     char *buf_ptr = buf; 

    64     size_t buf_size = sizeof(buf);

    65 

    66     struct error_item *item;

    67     struct error_type *type;

    68 

    69     // traverse stack

    70     for (item = err->cur; item && item >= err->stack; item--) {

    71         if (!list)

    72             // initial lookup table

    73             list = item->list;

    74 

    75         // verify list/type

    76         if (!list) {

    77             // no type info at all

    78             buf_ptr += str_advance(&buf_size, NULL, str_append_fmt(buf_ptr, buf_size, "[%#04x]", item->code));

    79 

    80         } else if (!(type = error_lookup_code(list, item->code))) {

    81             // couldn't find code in list

    82             buf_ptr += str_advance(&buf_size, NULL, str_append_fmt(buf_ptr, buf_size, "[%s:%#02x]", list->name, item->code));

    83 

    84         } else {

    85             // found code's type

    86             // delimit using colons, except at the end

    87             buf_ptr += str_advance(&buf_size, NULL, str_append(buf_ptr, buf_size, "[%s] %s%s", 

    88                 list->name, type->name, item == err->stack ? "" : ": "

    89             ));

    90 

    91             // expected list for next item

    92             list = type->sublist;

    93         }

    94     }

    95     

    96     // add info for extra

    97     if (err->extra_type != type->extra_type) {

    98         // type mismatch

    99         buf_ptr += str_advance(&buf_size, NULL, str_append_fmt(buf_ptr, buf_size, ": [error_extra type mismatch: %s <=> %s",

   100             err->extra_type ? err->extra_type->name : NULL,

   101             item->extra_type ? item->extra_type->name : NULL

   102         ));

   103 

   104     } else if (err->extra_type) {

   105         // add extra info

   106         buf_ptr += str_advance(&buf_size, NULL, str_append_fmt(buf_ptr, buf_size, ": %s", 

   107             err->extra_type->msg_func(item->extra_type, &item->extra_value)

   108         ));

   109 

   110     }

   111     

   112     // ok, return message

   113     return buf;

   114 }

   115 

   116 bool error_cmp_eq (const error_t *a, const error_t *b)

   117 {

   118     // XXX: implement

   119     return true;

   120 }

   121 

   122 /**

   123  * Advance error stack to next position, and return pointer.

   124  *

   125  * Returns NULL if the stack runs out of space.

   126  */

   127 struct error_item* error_next (error_t *err)

   128 {

   129     if (!err->cur)

   130         // initial position

   131         return (err->cur = err->stack);

   132 

   133     else if (err->cur < err->stack + ERR_DEPTH_MAX)

   134         return (err->cur++);

   135 

   136     else

   137         return NULL;

   138 }

   139 

   140 void error_set (error_t *err, const struct error_list *list, err_t code)

   141 {

   142     struct error_item *item;

   143 

   144     // empty

   145     error_reset(err);

   146 

   147     // next

   148     if (!(item = error_next(err)))

   149         return;

   150 

   151     // store

   152     item->code = code;

   153     item->list = list;

   154 }

   155 

   156 void error_set_extra (error_t *err, const struct error_list *list, err_t code, const struct error_extra_type *type, union error_extra extra)

   157 {

   158     struct error_item *item;

   159 

   160     // empty

   161     error_reset(err);

   162 

   163     // next

   164     if (!(item = error_next(err)))

   165         return;

   166 

   167     // store

   168     item->code = code;

   169     item->list = list;

   170     err->extra_type = type;

   171     err->extra_value = extra;

   172 }

   173 

   174 void error_push (error_t *err, const struct error_list *list, err_t code)

   175 {

   176     struct error_item *item;

   177 

   178     // next

   179     if (!(item = error_next(err)))

   180         return;

   181 

   182     // store

   183     item->code = code;

   184     item->list = list;

   185 }

   186 

   187 void error_copy (error_t *dst, const error_t *src)

   188 {

   189     struct error_item *item;

   190 

   191     // reset

   192     error_reset(dst);

   193 

   194     // copy each item

   195     for (item = src->stack; src->cur && item <= src->cur; item++)

   196         // push it on separately

   197         error_push(dst, item->list, item->code);

   198 

   199     // store extra

   200     dst->extra_type = src->extra_type;

   201     dst->extra_value = src->extra_value;

   202 }

   203 

   204 /*

   205  * Weird trickery to call log_msg_va2 with the fmt's in the right order (prefix).

   206  *

   207  * XXX: log should provide similar functionality

   208  */

   209 void _error_abort_ (const char *fmt2, va_list fmtargs2, const char *fmt1, ...)

   210 {

   211     va_list vargs;

   212 

   213     va_start(vargs, fmt1);

   214     _log_msg_va2(LOG_FATAL, "error_abort", fmt1, vargs, fmt2, fmtargs2);

   215     va_end(vargs);

   216 }

   217 

   218 void _error_abort (const char *file, const char *line, const char *func, const char *fmt, ...)

   219 {

   220     va_list vargs;

   221 

   222     va_start(vargs, fmt);

   223     _error_abort_(fmt, vargs, "%s:%d[%s]", file, line, func);

   224     va_end(vargs);

   225 }

   226