💾 Archived View for republic.circumlunar.space › users › grimmware › to_gem › to_gem.c captured on 2022-01-08 at 14:29:35.
⬅️ Previous capture (2021-12-04)
-=-=-=-=-=-=-
/* to_gem * # What * Convert regular markdown to `text/gemini` in an opinionated manner * * # How * Reads from STDIN and writes to STDOUT by default, alternatively the input * file can be supplied as the first argument and the output file as the * second. In both positions if you supply "-" then the default will be used so * you can (e.g.) specify stdin and an outfile thusly: `to_gem - outfile` * * Text reflow is considered out of scope (for now at least), and you should * check the output manually for errors * * # Why * tl;dr I wanted the practice and to have fun! * * I write a lot of notes in markdown and I'd like to be able to trivially * publish them in `text/gemini` on my capsule. * * This is very much "artisanal" C, in that it targets minimalism and * terseness even though for the specified use case it's more in the spirit of * low resource usage and minimalism of gemini and anachronistic byte-shaving * than is actually sensible for the problem - text conversion is not an easy * problem in C compared to other languages and the bytes shaved are very much * a drop in the ocean for such a low-resource problem. * * But sometimes you just like to express how you wish the world could be :) * * # Opinions * The opinion is that for every link we should replace it with a numbered * reference to a link below the block of text or whatever. * * To do this, we need to iteratively read through text, and for everything * that looks like a markdown link we'll replace it with `[link text][N]` where * N will be the number of the link in the file. Then when we reach the next * block we'll insert the link lines *first* and then move on. * * To get the full lowdown on intended behaviour, compare testfile.md and * testfile.gmi * * Format rules: * - No closing square brackets in a link name - we could accomodate for this * or it could just be sensible markdown :P * - Links in blocks will be ignored * - Link references should already be URI escaped - otherwise this is * undefined behaviour. I've added code to URI escape newlines and spaces to * URI encoded spaces (%20) because my own markdown was riddled with this * problem, but that's it * - Alt-text is not supported so it will cause a breakage due to the last * point - this is due to ease of implementation rather than philosophy, as * I'd prefer that alt-text *was* supported for accessibility. * * # Contributions * Contributions should aim to use minimal memory and avoid reading through the * input stream more than once. `valgrind` should be used to ensure that all * memory is freed, and all memory allocations should aim to be reasonably * dynamic so as to not hog resources unnecessarily. * * If you don't know where else to reach me, oholiab at grimmwa.re is the place * to email! I'll walk you through `git send-email` or other diff sending * workflows if you've not done it before :) */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define CHUNK 128 #define lines_to_print last_printed < linknames->size #define realloc_error "ERROR: Could not allocate memory! Exiting\n" enum boolean {false, true}; enum modes { plaintext, block, }; typedef struct { char** strings; size_t size; } List; static List* initList(const char* string, size_t size){ /* Initialize a List and return a pointer to it * * string: First entry as a null terminated string * size: Size of the string (NOT of the intended list, it grows dynamically) * * return: Pointer to a new List */ List* l = malloc(sizeof(List)); l->strings = malloc(sizeof(char*)); l->strings[0] = (char *) malloc(size); strcpy(l->strings[0], string); l->size = 1; return l; } static void freeList(List* l){ /* Recursively free all malloc'd memory in a List * * l: Pointer to a list */ for(size_t i = 0; i<l->size; i++){ free(l->strings[i]); } free(l->strings); free(l); } static void push(List* l, const char* string, size_t size){ /* Push a new item onto the end of the list * * l: Pointer to a list * string: String to add to the list * size: size of the string */ size_t s = l->size; char** tmp = realloc(l->strings, ++(l->size) * sizeof(char*)); if(tmp == NULL){ fwrite(realloc_error, 1, sizeof(realloc_error), stderr); exit(1); } l->strings = tmp; l->strings[s] = (char *) malloc(size); strcpy(l->strings[s], string); } static void pop(List* l){ /* Pop item from the list. This is not returned. * * l: Pointer to a list */ if(l == NULL) return; if(l->size == 1){ l->size = 0; return; } free(l->strings[--l->size]); char** tmp = realloc(l->strings, l->size * sizeof(char*)); if(tmp == NULL){ fwrite(realloc_error, 1, sizeof(realloc_error), stderr); exit(1); } l->strings = tmp; } static size_t print_from(List* names, List* refs, size_t from, FILE* out){ /* Print links from a pair of lists from item with index `from` to the end * * names: pointer to a list of link names * refs: pointer to a list of link references * from: index to print from * out: output stream * * returns: index of last printed item */ for(;from < names->size; from++){ fprintf(out, "=> "); char c; for(size_t i = 0; (c = (char) refs->strings[from][i]) != 0; i++) { if(c == ' ') fprintf(out, "%%20"); else fputc(c, out); } fprintf(out, " %s [%ld]\n", names->strings[from], from); } return(from); } static FILE* safe_open(const char* filepath, const char* mode) { /* Open and return a file pointer with error checking * * filepath: path to the file * mode: `fopen` format file mode * * returns: file pointer as returned by `fopen` */ FILE* file = fopen(filepath, mode); if(file == NULL){ fprintf(stderr, "Could not open file %s in mode %s\n", filepath, mode); exit(1); } return(file); } static size_t read_until(FILE* in, char until, char** ptr){ /* Read input filestream until char `until` into `ptr` or bail out if EOF is * reached first. Handles input buffering with dynamic resizing in increments * of size `CHUNK` * * in: pointer to input file stream until: The target character to stop * reading at * ptr: pointer to the memory to read in to * * returns: number of bytes read */ size_t bufsize = CHUNK; char* buf = malloc(bufsize); char c; size_t i; for(i=0; (c = (char) fgetc(in)) != until; i++) { if(c == EOF) { fprintf(stderr, "ERROR: Reached EOF whilst looking for matching `%c`\n", until); exit(1); } if(i == bufsize - 2){ // Always leave space for \0 char* newbuf = malloc(bufsize + CHUNK); if(newbuf == NULL) { fprintf(stderr, "Could not allocate memory!"); exit(1); } memcpy(newbuf, buf, bufsize); bufsize += CHUNK; free(buf); buf = newbuf; } buf[i] = c == '\n' ? ' ' : c; } buf[i] = 0; *ptr = buf; return(i+1); } static void read_push_until(FILE* in, char until, List** l, FILE* out){ /* VERY specific to this program, wrapper for `read_until` that also handles * pushing the returned string onto a list, and optionally prints the * characters including the closing one to an output stream if provided * * in: pointer to input stream * until: char to stop reading at * l: list to append the read bytes to * out: output stream to print to. No output will be printed if this is NULL. */ char* text = NULL; size_t s = read_until(in, until, &text); if(*l == NULL){ *l = initList(text, s); } else { push(*l, text, s); } if(out != NULL){ fwrite(text, 1, s-1, out); fputc(until, out); } free(text); return; } int main(int argc, char* argv[]){ FILE* in = stdin; FILE* out = stdout; if(argc > 1 && strcmp(argv[1], "-") != 0) in = safe_open(argv[1], "r"); if(argc > 2 && strcmp(argv[2], "-") != 0) out = safe_open(argv[2], "w"); char c, last = 0; size_t linenum = 1; size_t last_printed = 0; enum modes mode = plaintext; // Links are not respected in `block` mode enum boolean likely_link = false; // Used to indicate whether a `(` is // expected to be a link reference List* linknames = NULL; List* linkrefs = NULL; while((c = (char) fgetc(in)) != EOF){ if(likely_link && (c != '(')) { likely_link = false; // If we just parsed what we thought was a link name but it wasn't // trailed by a ref then it wasn't a link, so we pop it back off again pop(linknames); } switch(c){ case '[': putc(c, out); if(mode == plaintext && last != '\\'){ read_push_until(in, ']', &linknames, out); likely_link = true; } break; case '(': if(likely_link) { read_push_until(in, ')', &linkrefs, NULL); fprintf(out, "[%ld]", linkrefs->size); likely_link = false; break; } fputc(c, out); break; case '`': fputc(c, out); if(last == '\n'){ if((c = (char) fgetc(in)) != '`') { fputc(c, out); break; } if((c = (char) fgetc(in)) != '`') { fputc(c, out); break; } fprintf(out, "``"); if(mode == block){ mode = plaintext; } else if(mode == plaintext) mode = block; } break; case '#': if(last == '\n') { if (linknames != NULL && lines_to_print) { fputc('\n', out); last_printed = print_from(linknames, linkrefs, last_printed, out); fputc('\n', out); } } fputc(c, out); break; case '\n': linenum++; if(last == '\n' && linknames != NULL && lines_to_print) { fputc(c, out); last_printed = print_from(linknames, linkrefs, last_printed, out); } __attribute__((fallthrough)); default: fputc(c, out); } last = c; } if(linknames){ if(lines_to_print) fputc('\n', out); last_printed = print_from(linknames, linkrefs, last_printed, out); } fclose(in); fclose(out); freeList(linknames); freeList(linkrefs); return 0; }