| #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() {} | |