files.c - bp

(205 lines)
   1 //
   2 // files.c - Implementation of some file loading functionality.
   3 //
   4 
   5 #include <err.h>
   6 #include <fcntl.h>
   7 #include <limits.h>
   8 #include <stdarg.h>
   9 #include <string.h>
  10 #include <sys/mman.h>
  11 #include <sys/stat.h>
  12 
  13 #include "files.h"
  14 #include "utils.h"
  15 
  16 //
  17 // In the file object, populate the `lines` array with pointers to the
  18 // beginning of each line.
  19 //
  20 __attribute__((nonnull)) static void populate_lines(file_t *f) {
  21     // Calculate line numbers:
  22     size_t linecap = 10;
  23     f->lines = new (const char *[linecap]);
  24     f->nlines = 0;
  25     char *p = f->start;
  26     for (size_t n = 0; p && p <= f->end; ++n) {
  27         ++f->nlines;
  28         if (n >= linecap) f->lines = grow(f->lines, linecap *= 2);
  29         f->lines[n] = p;
  30         char *nl = memchr(p, '\n', (size_t)(f->end - p));
  31         if (nl && nl < f->end) p = nl + 1;
  32         else break;
  33     }
  34 }
  35 
  36 //
  37 // Read an entire file into memory, using a printf-style formatting string to
  38 // construct the filename.
  39 //
  40 public
  41 file_t *load_filef(file_t **files, const char *fmt, ...) {
  42     char filename[PATH_MAX + 1] = {'\0'};
  43     va_list args;
  44     va_start(args, fmt);
  45     if (vsnprintf(filename, PATH_MAX, fmt, args) > (int)PATH_MAX) errx(EXIT_FAILURE, "File name is too large");
  46     va_end(args);
  47     return load_file(files, filename);
  48 }
  49 
  50 //
  51 // Read an entire file into memory.
  52 //
  53 public
  54 file_t *load_file(file_t **files, const char *filename) {
  55     int fd = filename[0] == '\0' ? STDIN_FILENO : open(filename, O_RDONLY);
  56     if (fd < 0) {
  57         // Check for <file>:<line>
  58         if (strrchr(filename, ':')) {
  59             char tmp[PATH_MAX] = {0};
  60             strlcpy(tmp, filename, sizeof(tmp));
  61             char *colon = strrchr(tmp, ':');
  62             *colon = '\0';
  63             file_t *f = load_file(files, tmp);
  64             if (!f) return f;
  65             long line = strtol(colon + 1, &colon, 10);
  66             f->start = (char *)get_line(f, (size_t)line);
  67             f->end = (char *)get_line(f, (size_t)line + 1);
  68             return f;
  69         }
  70         return NULL;
  71     }
  72 
  73     filename = checked_strdup(filename);
  74     for (const char *slashes = strstr(filename, "//"); slashes; slashes = strstr(slashes, "//"))
  75         memmove((char *)slashes, slashes + 1, strlen(slashes + 1) + 1);
  76     file_t *f = new (file_t);
  77     f->filename = filename;
  78 
  79     struct stat sb;
  80     if (fstat(fd, &sb) == -1) goto read_file;
  81 
  82     f->mmapped = mmap(NULL, (size_t)sb.st_size + 1, PROT_READ, MAP_PRIVATE, fd, 0);
  83     if (f->mmapped == MAP_FAILED) {
  84         f->mmapped = NULL;
  85         goto read_file;
  86     }
  87     f->start = f->mmapped;
  88     f->end = &f->mmapped[sb.st_size];
  89     goto finished_loading;
  90 
  91 read_file: {
  92     size_t capacity = 1000, length = 0;
  93     f->allocated = new (char[capacity]);
  94     ssize_t just_read;
  95     while ((just_read = read(fd, &f->allocated[length], (capacity - 1) - length)) > 0) {
  96         length += (size_t)just_read;
  97         if (length >= capacity - 1) f->allocated = grow(f->allocated, capacity *= 2);
  98     }
  99     f->allocated[length] = '\0';
 100     f->start = f->allocated;
 101     f->end = &f->allocated[length];
 102 }
 103 
 104 finished_loading:
 105     if (fd != STDIN_FILENO) require(close(fd), "Failed to close file");
 106 
 107     populate_lines(f);
 108     if (files != NULL) {
 109         f->next = *files;
 110         *files = f;
 111     }
 112     return f;
 113 }
 114 
 115 //
 116 // Set a file struct to represent a region of a different file.
 117 //
 118 public
 119 void slice_file(file_t *slice, file_t *src, const char *start, const char *end) {
 120     memset(slice, 0, sizeof(file_t));
 121     slice->filename = src->filename;
 122     slice->lines = src->lines;
 123     slice->nlines = src->nlines;
 124     slice->start = (char *)start;
 125     slice->end = (char *)end;
 126 }
 127 
 128 //
 129 // Create a virtual file from a string.
 130 //
 131 public
 132 file_t *spoof_file(file_t **files, const char *filename, const char *text, ssize_t _len) {
 133     if (filename == NULL) filename = "";
 134     file_t *f = new (file_t);
 135     size_t len = _len == -1 ? strlen(text) : (size_t)_len;
 136     f->filename = checked_strdup(filename);
 137     f->allocated = new (char[len + 1]);
 138     memcpy(f->allocated, text, len);
 139     f->start = &f->allocated[0];
 140     f->end = &f->allocated[len];
 141     populate_lines(f);
 142     if (files != NULL) {
 143         f->next = *files;
 144         *files = f;
 145     }
 146     return f;
 147 }
 148 
 149 //
 150 // Free a file and all memory contained inside its members, then set the input
 151 // pointer to NULL.
 152 //
 153 public
 154 void destroy_file(file_t **at_f) {
 155     file_t *f = (file_t *)*at_f;
 156     if (f->filename) delete (&f->filename);
 157 
 158     if (f->lines) delete (&f->lines);
 159 
 160     if (f->allocated) delete (&f->allocated);
 161 
 162     if (f->mmapped) {
 163         require(munmap(f->mmapped, (size_t)(f->end - f->mmapped)), "Failure to un-memory-map some memory");
 164         f->mmapped = NULL;
 165     }
 166 
 167     delete (at_f);
 168 }
 169 
 170 //
 171 // Given a pointer, determine which line number it points to.
 172 //
 173 public
 174 size_t get_line_number(file_t *f, const char *p) {
 175     if (f->nlines == 0) return 0;
 176     // Binary search:
 177     size_t lo = 0, hi = f->nlines - 1;
 178     while (lo <= hi) {
 179         size_t mid = (lo + hi) / 2;
 180         if (f->lines[mid] == p) return mid + 1;
 181         else if (f->lines[mid] < p) lo = mid + 1;
 182         else if (f->lines[mid] > p) hi = mid - 1;
 183     }
 184     return lo; // Return the line number whose line starts closest before p
 185 }
 186 
 187 //
 188 // Given a pointer, determine which line column it points to.
 189 //
 190 public
 191 size_t get_line_column(file_t *f, const char *p) {
 192     size_t line_no = get_line_number(f, p);
 193     return 1 + (size_t)(p - f->lines[line_no]);
 194 }
 195 
 196 //
 197 // Return a pointer to the line with the specified line number.
 198 //
 199 public
 200 const char *get_line(file_t *f, size_t line_number) {
 201     if (line_number == 0 || line_number > f->nlines) return NULL;
 202     return f->lines[line_number - 1];
 203 }
 204 
 205 // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0