| |
| #include "utils.h" |
| |
| #include <stdarg.h> |
| #include <ctype.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| #include <stdarg.h> |
| #include <regex.h> |
| |
| |
| //######################################################## |
| // This function prints a message to both stderr and |
| // to the file ".fatal_error". |
| // |
| // If ERR_NUM != 0 then exit is called with the value ERR_NUM. |
| //######################################################## |
| extern void |
| _fatal_error_aux(const char *file, const s32bit line, const s32bit err_num, |
| const char *format, ... ) |
| { |
| va_list ap; |
| static FILE* err_file = NULL; |
| char *msg_type = (err_num == 0) ? "WARNING: " : "ERROR: "; |
| |
| // only need to open this if not already open. |
| if(err_file == NULL) err_file = fopen(".fatal_error", "w"); |
| if(err_file == NULL) fprintf(stderr, "Couldn't open \".fatal_error\".\n"); |
| |
| if(err_num == 0) { |
| // Check size of file, we don't want to end up filling up the whole disk. |
| s32bit size = ftell(err_file); |
| if(size == -1) |
| fatal_error(1, "size == -1.\n"); |
| |
| else if(size > (2<<24) + 2000 ){ |
| return; |
| } |
| |
| else if(size > (2<<24)){ |
| fprintf(stderr, "Log file getting too large.\n"); |
| fprintf(err_file, "Log file getting too large.\n"); |
| } |
| } |
| |
| // start writing the real message. |
| fprintf(stderr, msg_type); |
| fprintf(err_file, msg_type); |
| |
| va_start (ap, format); |
| vfprintf (stderr, format, ap); |
| vfprintf (err_file, format, ap); |
| va_end (ap); |
| |
| fprintf(stderr, "> File: %s, Line: %d.\n", file, line); |
| fprintf(err_file, "> File: %s, Line: %d.\n", file, line); |
| |
| fflush(stderr); |
| fflush(err_file); |
| |
| if (err_num != 0) exit(err_num); |
| } |
| |
| |
| //######################################################## |
| // These are dynamic sprintf function, they malloc space as needed. |
| //######################################################## |
| |
| //======================================================== |
| // This function stores the string created from FORMAT and the |
| // following args to the string STR, starting at position OFFSET. |
| //======================================================== |
| extern s32bit |
| Asprintf(char **str, s32bit *len, s32bit offset, const char *format, ... ) |
| { |
| va_list ap; |
| s32bit nchars; |
| |
| va_start (ap, format); |
| |
| // if no space allocated yet, allocate some. |
| if(*len == 0){ *len = 128; *str = malloc(*len); } |
| |
| while (1) { |
| // attempt printing in the allocated space |
| nchars = vsnprintf (*str + offset, *len - offset, format, ap); |
| |
| if (nchars < *len - offset) break; |
| |
| // if not enough space allocate some more. |
| *len += 128; |
| *str = realloc(*str, *len); |
| } |
| |
| va_end (ap); |
| return nchars; |
| } |
| |
| //======================================================== |
| // This function stores the string created from FORMAT and the |
| // following args to the end of the string STR. |
| //======================================================== |
| #if 0 |
| extern s32bit |
| asprintf_my(char **str, s32bit offset, const char *format, ... ) |
| { |
| va_list ap; |
| s32bit nchars, len = ALLOCED(*str,char); |
| |
| va_start (ap, format); |
| |
| // if no space allocated yet, allocate some. |
| if(len == 0){ len = 128; *str = malloc(len); } |
| |
| while (1) { |
| // attempt printing in the allocated space |
| nchars = vsnprintf (*str + offset, len - offset, format, ap); |
| |
| if (nchars < len - offset) break; |
| |
| // if not enough space allocate some more. |
| len += 128; |
| *str = realloc(*str, len); |
| } |
| |
| va_end (ap); |
| return nchars; |
| } |
| #endif |
| |
| |
| //######################################################## |
| // Return a string with the printed value of a 64 bit number. |
| //######################################################## |
| extern const char* |
| u64bit_to_string(u64bit val) |
| { |
| static char big_num[80]; // plenty large |
| s32bit vals[10]; // plenty large |
| s32bit i = 0, offset; |
| |
| do { |
| vals[i] = val % 1000; |
| val = val / 1000; |
| i++; |
| } while(val != 0); |
| |
| offset = sprintf(big_num, "%d", vals[--i]); |
| |
| while(i != 0) |
| offset += sprintf(big_num + offset, ",%03d", vals[--i]); |
| |
| return big_num; |
| } |
| |
| |
| //######################################################## |
| // I'm not sure why I have this function. |
| // I suppose it may come in useful for performance analysis. |
| //######################################################## |
| extern void |
| null_command() {} |
| |