gout

format.c (7320B)

---

 #include "format.h"
 
 #include <err.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 void print_time(FILE* out, time_t time, int timezone_offset) {
   // Reject any offset > 24 hours.
   if (timezone_offset < -1440 || timezone_offset > 1440) {
     warnx("invalid timezone offset: %d", timezone_offset);
     return;
   }
   time_t local_time = time + (timezone_offset * 60);
   struct tm* time_in = gmtime(&local_time);
   if (!time_in) {
     return;
   }
 
   char formatted_time[32];
   if (!strftime(formatted_time, sizeof(formatted_time), "%a, %e %b %Y %H:%M:%S",
                 time_in)) {
     err(1, "strftime");
   }
 
   char timezone_sign = timezone_offset < 0 ? '-' : '+';
   int timezone_hours = (timezone_offset < 0 ? -1 : 1) * timezone_offset / 60;
   int timezone_mins = (timezone_offset < 0 ? -1 : 1) * timezone_offset % 60;
   char out_str[64];
   if (snprintf(out_str, sizeof(out_str), "%s %c%02d%02d", formatted_time,
                timezone_sign, timezone_hours, timezone_mins) < 0) {
     err(1, "snprintf");
   }
   fprintf(out, "%s", out_str);
 }
 
 void print_time_z(FILE* out, time_t time) {
   struct tm* time_in = gmtime(&time);
   if (!time_in) {
     return;
   }
 
   char formatted_time[32];
   if (!strftime(formatted_time, sizeof(formatted_time), "%Y-%m-%dT%H:%M:%SZ",
                 time_in)) {
     err(1, "strftime");
   }
   fprintf(out, "%s", formatted_time);
 }
 
 void print_time_short(FILE* out, time_t time) {
   struct tm* time_in = gmtime(&time);
   if (!time_in) {
     return;
   }
 
   char formatted_time[32];
   if (!strftime(formatted_time, sizeof(formatted_time), "%Y-%m-%d %H:%M",
                 time_in)) {
     err(1, "strftime");
   }
   fprintf(out, "%s", formatted_time);
 }
 
 void print_percent_encoded(FILE* out, const char* str) {
   static const char* hex_chars = "0123456789ABCDEF";
 
   size_t str_len = strlen(str);
   for (size_t i = 0; i < str_len; i++) {
     unsigned char uc = str[i];
     // NOTE: do not encode '/' for paths or ",-."
     if (uc < ',' || uc >= 127 || (uc >= ':' && uc <= '@') || uc == '[' ||
         uc == ']') {
       fprintf(out, "%%%c%c", hex_chars[(uc >> 4) & 0x0f], hex_chars[uc & 0x0f]);
     } else {
       fprintf(out, "%c", uc);
     }
   }
 }
 
 void print_xml_encoded(FILE* out, const char* str) {
   print_xml_encoded_len(out, str, -1, true);
 }
 
 void print_xml_encoded_len(FILE* out,
                            const char* str,
                            ssize_t str_len,
                            bool output_crlf) {
   size_t len = (str_len >= 0) ? (size_t)str_len : strlen(str);
   for (size_t i = 0; i < len && str[i] != '\0'; i++) {
     char c = str[i];
     switch (c) {
       case '<':
         fprintf(out, "&lt;");
         break;
       case '>':
         fprintf(out, "&gt;");
         break;
       case '\'':
         fprintf(out, "&#39;");
         break;
       case '&':
         fprintf(out, "&amp;");
         break;
       case '"':
         fprintf(out, "&quot;");
         break;
       case '\r':
       case '\n':
         if (output_crlf) {
           fprintf(out, "%c", c);
         }
         break;
       default:
         fprintf(out, "%c", c);
     }
   }
 }
 
 void print_gopher_text(FILE* out, const char* str, bool output_lf) {
   print_gopher_text_len(out, str, -1, output_lf);
 }
 
 void print_gopher_text_len(FILE* out,
                            const char* str,
                            ssize_t str_len,
                            bool output_lf) {
   size_t len = (str_len >= 0) ? (size_t)str_len : strlen(str);
   bool start_of_line = true;
   for (size_t i = 0; i < len && str[i] != '\0'; i++) {
     char c = str[i];
     if (output_lf && start_of_line && c == '[') {
       fprintf(out, "[|");
     } else if (c == '\t') {
       fprintf(out, "        ");
     } else if (c == '\r' || (!output_lf && c == '\n')) {
       /* Ignore. */
     } else {
       fprintf(out, "%c", c);
     }
     start_of_line = (c == '\n');
   }
 }
 
 void print_gopher_link(FILE* out, const char* str) {
   for (size_t i = 0; str[i] != '\0'; i++) {
     char c = str[i];
     if (c == '|') {
       fprintf(out, "\\|");
     } else if (c == '\t') {
       fprintf(out, "        ");
     } else if (c == '\r' || c == '\n') {
       // Ignore.
     } else {
       fprintf(out, "%c", c);
     }
   }
 }
 
 static size_t utf8_char_length(const char* str) {
   unsigned char c = (unsigned char)*str;
   if (c < 0x80) {
     return 1;
   }
   if ((c & 0xe0) == 0xc0) {
     return 2;
   }
   if ((c & 0xf0) == 0xe0) {
     return 3;
   }
   if ((c & 0xf8) == 0xf0) {
     return 4;
   }
   // Invalid UTF-8 sequence. Treat as single byte.
   return 1;
 }
 
 static bool is_zwj(const char* str) {
   return str[0] == '\xe2' && str[1] == '\x80' && str[2] == '\x8d';
 }
 
 static bool is_variation_selector(const char* str) {
   return str[0] == '\xef' && str[1] == '\xb8' && str[2] == '\x8f';
 }
 
 static size_t get_char_width(wchar_t c) {
   // ASCII characters in the range [0-31] and [127-255] are control characters
   // or non-printable characters
   if ((c >= 0 && c <= 31) || (c >= 127 && c <= 255)) {
     return 1;
   }
 
   // Emoji range.
   if (c >= 0x1F300 && c <= 0x1F6FF) {
     return 2;
   }
 
   // Extended pictographic characters.
   if (c >= 0x1F900 && c <= 0x1F9FF) {
     return 2;
   }
 
   // Hiragana and Katakana ranges.
   if ((c >= 0x3040 && c <= 0x309F) || (c >= 0x30A0 && c <= 0x30FF)) {
     return 2;
   }
 
   // Kanji range.
   if (c >= 0x4E00 && c <= 0x9FFF) {
     return 2;
   }
   return 1;
 }
 
 // TODO(cbracken): There has to be a better way.
 void print_gopher_link_padded(FILE* out,
                               const char* str,
                               size_t width,
                               char pad_char) {
   size_t str_len = strlen(str);
   size_t char_count = 0;
   size_t last_char_width = 0;
   size_t byte_count = 0;
   while (byte_count < str_len) {
     size_t pos = byte_count;
     size_t char_length = utf8_char_length(&str[byte_count]);
     byte_count += char_length;
     if (char_count == width - 1 && byte_count < str_len) {
       fprintf(out, "\u2026");
       last_char_width = 1;
       char_count += last_char_width;
     } else if (char_count < width) {
       if (str[pos] == '|') {
         fprintf(out, "\\|");
         char_count++;
         last_char_width = 1;
       } else if (str[pos] == '\t') {
         for (size_t i = 0; i < 8 && char_count < width; i++) {
           fprintf(out, " ");
           char_count++;
         }
         last_char_width = 1;
       } else if (str[pos] == '\r' || str[pos] == '\n') {
         // Ignore.
         last_char_width = 0;
       } else if (char_length == 3 && is_zwj(&str[pos])) {
         fprintf(out, "\xe2\x80\x8d");
         char_count -= last_char_width;
         last_char_width = 0;
       } else if (char_length == 3 && is_variation_selector(&str[pos])) {
         fprintf(out, "\xef\xb8\x8f");
         char_count -= last_char_width;
         last_char_width = 0;
       } else {
         for (size_t i = pos; i < byte_count; i++) {
           fprintf(out, "%c", str[i]);
         }
         wchar_t wide_char;
         if (mbtowc(&wide_char, &str[pos], MB_CUR_MAX) >= 0) {
           last_char_width = get_char_width(wide_char);
         } else {
           last_char_width = 1;
         }
         char_count += last_char_width;
       }
     }
   }
   if (pad_char != '\0') {
     while (char_count < width) {
       fprintf(out, "%c", pad_char);
       char_count++;
     }
   }
 }