files.c - tomo

(312 lines)
   1 // Implementation of some file loading functionality.
   2 
   3 #include <ctype.h>
   4 #include <err.h>
   5 #include <fcntl.h>
   6 #include <gc.h>
   7 #include <libgen.h>
   8 #include <limits.h>
   9 #include <stdarg.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <sys/param.h>
  14 
  15 #include "files.h"
  16 #include "print.h"
  17 #include "util.h"
  18 
  19 static const int tabstop = 4;
  20 
  21 public
  22 char *resolve_path(const char *path, const char *relative_to, const char *system_path) {
  23     if (!relative_to || streq(relative_to, "/dev/stdin")) relative_to = ".";
  24     if (!path || strlen(path) == 0) return NULL;
  25 
  26     // Resolve the path to an absolute path, assuming it's relative to the file
  27     // it was found in:
  28     char buf[PATH_MAX] = {0};
  29     if (streq(path, "~") || starts_with(path, "~/")) {
  30         char *resolved = realpath(String(getenv("HOME"), path + 1), buf);
  31         if (resolved) return GC_strdup(resolved);
  32     } else if (streq(path, ".") || starts_with(path, "./") || starts_with(path, "../")) {
  33         char *relative_dir = dirname(GC_strdup(relative_to));
  34         char *resolved = realpath(String(relative_dir, "/", relative_dir, path), buf);
  35         if (resolved) return GC_strdup(resolved);
  36     } else if (path[0] == '/') {
  37         // Absolute path:
  38         char *resolved = realpath(path, buf);
  39         if (resolved) return GC_strdup(resolved);
  40     } else {
  41         // Relative path:
  42         char *relative_dir = dirname(GC_strdup(relative_to));
  43         if (!system_path) system_path = ".";
  44         char *copy = GC_strdup(system_path);
  45         for (char *dir, *pos = copy; (dir = strtok(pos, ":")); pos = NULL) {
  46             if (dir[0] == '/') {
  47                 char *resolved = realpath(String(dir, "/", path), buf);
  48                 if (resolved) return GC_strdup(resolved);
  49             } else if (dir[0] == '~' && (dir[1] == '\0' || dir[1] == '/')) {
  50                 char *resolved = realpath(String(getenv("HOME"), dir + 1, "/", path), buf);
  51                 if (resolved) return GC_strdup(resolved);
  52             } else if (streq(dir, ".") || strncmp(dir, "./", 2) == 0) {
  53                 char *resolved = realpath(String(relative_dir, "/", path), buf);
  54                 if (resolved) return GC_strdup(resolved);
  55             } else if (streq(dir, ".") || streq(dir, "..") || strncmp(dir, "./", 2) == 0
  56                        || strncmp(dir, "../", 3) == 0) {
  57                 char *resolved = realpath(String(relative_dir, "/", dir, "/", path), buf);
  58                 if (resolved) return GC_strdup(resolved);
  59             } else {
  60                 char *resolved = realpath(String(dir, "/", path), buf);
  61                 if (resolved) return GC_strdup(resolved);
  62             }
  63         }
  64     }
  65     return NULL;
  66 }
  67 
  68 public
  69 char *file_base_name(const char *path) {
  70     const char *slash = strrchr(path, '/');
  71     if (slash) path = slash + 1;
  72     assert(!isdigit(*path));
  73     const char *end = path + strcspn(path, ".");
  74     size_t len = (size_t)(end - path);
  75     char *buf = GC_MALLOC_ATOMIC(len + 1);
  76     strncpy(buf, path, len);
  77     buf[len] = '\0';
  78     return buf;
  79 }
  80 
  81 static file_t *_load_file(const char *filename, FILE *file) {
  82     if (!file) return NULL;
  83 
  84     file_t *ret = new (file_t, .filename = filename);
  85 
  86     size_t file_size = 0, line_cap = 0;
  87     char *file_buf = NULL, *line_buf = NULL;
  88     FILE *mem = open_memstream(&file_buf, &file_size);
  89     int64_t line_len = 0;
  90     while ((line_len = getline(&line_buf, &line_cap, file)) >= 0) {
  91         if (ret->line_capacity <= ret->num_lines)
  92             ret->line_offsets = GC_REALLOC(ret->line_offsets, sizeof(int64_t[ret->line_capacity += 32]));
  93         ret->line_offsets[ret->num_lines++] = (int64_t)file_size;
  94         fwrite(line_buf, sizeof(char), (size_t)line_len, mem);
  95         fflush(mem);
  96     }
  97     fclose(file);
  98 
  99     char *copy = GC_MALLOC_ATOMIC(file_size + 1);
 100     memcpy(copy, file_buf, file_size);
 101     copy[file_size] = '\0';
 102     ret->text = copy;
 103     ret->len = (int64_t)file_size;
 104     fclose(mem);
 105 
 106     free(file_buf);
 107     ret->relative_filename = filename;
 108     if (filename && filename[0] != '<' && !streq(filename, "/dev/stdin")) {
 109         filename = resolve_path(filename, ".", ".");
 110         // Convert to relative path (if applicable)
 111         char buf[PATH_MAX];
 112         char *cwd = getcwd(buf, sizeof(buf));
 113         if (cwd != NULL) {
 114             size_t cwd_len = strlen(cwd);
 115             if (strncmp(cwd, filename, cwd_len) == 0 && filename[cwd_len] == '/')
 116                 ret->relative_filename = &filename[cwd_len + 1];
 117         }
 118     }
 119     if (line_buf != NULL) free(line_buf);
 120     return ret;
 121 }
 122 
 123 //
 124 // Read an entire file into memory.
 125 //
 126 public
 127 file_t *load_file(const char *filename) {
 128     FILE *file = filename[0] ? fopen(filename, "r") : stdin;
 129     return _load_file(filename, file);
 130 }
 131 
 132 //
 133 // Create a virtual file from a string.
 134 //
 135 public
 136 file_t *spoof_file(const char *filename, const char *text) {
 137     FILE *file = fmemopen((char *)text, strlen(text) + 1, "r");
 138     return _load_file(filename, file);
 139 }
 140 
 141 //
 142 // Given a pointer, determine which line number it points to (1-indexed)
 143 //
 144 public
 145 int64_t get_line_number(file_t *f, const char *p) {
 146     // Binary search:
 147     int64_t lo = 0, hi = (int64_t)f->num_lines - 1;
 148     if (p < f->text) return 0;
 149     int64_t offset = (int64_t)(p - f->text);
 150     while (lo <= hi) {
 151         int64_t mid = (lo + hi) / 2;
 152         int64_t line_offset = f->line_offsets[mid];
 153         if (line_offset == offset) return mid + 1;
 154         else if (line_offset < offset) lo = mid + 1;
 155         else if (line_offset > offset) hi = mid - 1;
 156     }
 157     return lo; // Return the line number whose line starts closest before p
 158 }
 159 
 160 //
 161 // Given a pointer, determine which line column it points to.
 162 //
 163 public
 164 int64_t get_line_column(file_t *f, const char *p) {
 165     int64_t line_no = get_line_number(f, p);
 166     int64_t line_offset = f->line_offsets[line_no - 1];
 167     return 1 + (int64_t)(p - (f->text + line_offset));
 168 }
 169 
 170 //
 171 // Return a pointer to the line with the specified line number (1-indexed)
 172 //
 173 public
 174 const char *get_line(file_t *f, int64_t line_number) {
 175     if (line_number == 0 || line_number > (int64_t)f->num_lines) return NULL;
 176     int64_t line_offset = f->line_offsets[line_number - 1];
 177     return f->text + line_offset;
 178 }
 179 
 180 //
 181 // Return a value like /foo:line.col
 182 //
 183 public
 184 const char *get_file_pos(file_t *f, const char *p) {
 185     return String(f->filename, ":", get_line_number(f, p), ".", get_line_column(f, p));
 186 }
 187 
 188 static int fputc_column(FILE *out, char c, char print_char, int *column) {
 189     int printed = 0;
 190     if (print_char == '\t') print_char = ' ';
 191     if (c == '\t') {
 192         for (int to_fill = tabstop - (*column % tabstop); to_fill > 0; --to_fill) {
 193             printed += fputc(print_char, out);
 194             ++*column;
 195         }
 196     } else {
 197         printed += fputc(print_char, out);
 198         ++*column;
 199     }
 200     return printed;
 201 }
 202 
 203 //
 204 // Print a span from a file
 205 //
 206 public
 207 int highlight_error(file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines,
 208                     bool use_color) {
 209     if (!file) return 0;
 210 
 211     // Handle spans that come from multiple files:
 212     if (start < file->text || start > file->text + file->len) start = end;
 213     if (end < file->text || end > file->text + file->len) end = start;
 214     // Just in case neither end of the span came from this file:
 215     if (end < file->text || end > file->text + file->len) start = end = file->text;
 216 
 217     const char *lineno_prefix, *lineno_suffix, *normal_color, *empty_marker;
 218     bool print_carets = false;
 219     int printed = 0;
 220     if (use_color) {
 221         lineno_prefix = "\x1b[0;2m";
 222         lineno_suffix = "\x1b(0\x78\x1b(B\x1b[m ";
 223         normal_color = "\x1b[m";
 224         empty_marker = "\x1b(0\x61\x1b(B";
 225         printed += fprint(stderr, "\x1b[33;4;1m", file->relative_filename, "\x1b[m");
 226     } else {
 227         lineno_prefix = "";
 228         lineno_suffix = "| ";
 229         hl_color = "";
 230         normal_color = "";
 231         empty_marker = " ";
 232         print_carets = true;
 233         printed += fprint(stderr, file->relative_filename);
 234     }
 235 
 236     if (context_lines == 0) return fprint(stderr, hl_color, string_slice(start, (size_t)(end - start)), normal_color);
 237 
 238     int64_t start_line = get_line_number(file, start), end_line = get_line_number(file, end);
 239 
 240     int64_t first_line = start_line - (context_lines - 1), last_line = end_line + (context_lines - 1);
 241 
 242     if (first_line < 1) first_line = 1;
 243     if (last_line > file->num_lines) last_line = file->num_lines;
 244 
 245     int digits = 1;
 246     for (int64_t i = last_line; i > 0; i /= 10)
 247         ++digits;
 248 
 249     for (int64_t line_no = first_line; line_no <= last_line; ++line_no) {
 250         if (line_no > first_line + 5 && line_no < last_line - 5) {
 251             if (use_color)
 252                 printed += fprint(stderr, "\x1b[0;2;3;4m     ... ", (last_line - first_line) - 11,
 253                                   " lines omitted ...     \x1b[m");
 254             else printed += fprint(stderr, "     ... ", (last_line - first_line) - 11, " lines omitted ...");
 255             line_no = last_line - 6;
 256             continue;
 257         }
 258 
 259         int needed_spaces = digits;
 260         for (int64_t n = line_no; n > 0; n /= 10)
 261             needed_spaces -= 1;
 262 
 263         printed += fprint_inline(stderr, lineno_prefix, repeated_char(' ', needed_spaces), line_no, lineno_suffix);
 264         const char *line = get_line(file, line_no);
 265         if (!line) break;
 266 
 267         int column = 0;
 268         const char *p = line;
 269         // Before match
 270         for (; *p && *p != '\r' && *p != '\n' && p < start; ++p)
 271             printed += fputc_column(stderr, *p, *p, &column);
 272 
 273         // Zero-width matches
 274         if (p == start && start == end) {
 275             printed += fprint_inline(stderr, hl_color, empty_marker, normal_color);
 276             column += 1;
 277         }
 278 
 279         // Inside match
 280         if (start <= p && p < end) {
 281             printed += fputs(hl_color, stderr);
 282             for (; *p && *p != '\r' && *p != '\n' && p < end; ++p)
 283                 printed += fputc_column(stderr, *p, *p, &column);
 284             printed += fputs(normal_color, stderr);
 285         }
 286 
 287         // After match
 288         for (; *p && *p != '\r' && *p != '\n'; ++p)
 289             printed += fputc_column(stderr, *p, *p, &column);
 290 
 291         printed += fprint_inline(stderr, "\n");
 292 
 293         const char *eol = line + strcspn(line, "\r\n");
 294         if (print_carets && start >= line && start < eol && line <= start) {
 295             for (int num = 0; num < digits; num++)
 296                 printed += fputc(' ', stderr);
 297             printed += fputs(": ", stderr);
 298             int col = 0;
 299             for (const char *sp = line; *sp && *sp != '\n'; ++sp) {
 300                 char print_char;
 301                 if (sp < start) print_char = ' ';
 302                 else if (sp == start && sp == end) print_char = '^';
 303                 else if (sp >= start && sp < end) print_char = '-';
 304                 else print_char = ' ';
 305                 printed += fputc_column(stderr, *sp, print_char, &col);
 306             }
 307             printed += fputs("\n", stderr);
 308         }
 309     }
 310     fflush(stderr);
 311     return printed;
 312 }