c2html: src/c2html.c@c59fe73459fd (annotated)

src/c2html.c@c59fe73459fd (annotated)

src/c2html.c

Wed, 10 Jul 2013 13:38:28 +0200

author: Mike Becker <universe@uap-core.de>
date: Wed, 10 Jul 2013 13:38:28 +0200
changeset 11: c59fe73459fd
parent 6: d10f7570add4
child 12: 7ce5c4b51959
permissions: -rw-r--r--

option for output file

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
  *
  * Copyright 2013 Mike Becker. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *   1. Redistributions of source code must retain the above copyright
  *      notice, this list of conditions and the following disclaimer.
  *
  *   2. Redistributions in binary form must reproduce the above copyright
  *      notice, this list of conditions and the following disclaimer in the
  *      documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  *
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <ctype.h>
 #define INPUTBUF_SIZE 2048
 #define WORDBUF_SIZE 16
 const char* keywords[] = {
   "auto", "break", "case", "char", "const", "continue", "default", "do",
   "double", "else", "enum", "extern", "float", "for", "goto", "if", "int",
   "long", "register", "return", "short", "signed", "sizeof", "static", "struct",
   "switch", "typedef", "union", "unsigned", "void", "volatile", "while", NULL
 };
 typedef struct {
   char* outfilename;
   char* infilename;
 } settings_t;
 typedef struct {
   size_t count;
   size_t capacity;
   size_t maxlinewidth;
   char** lines;
 } inputfile_t;
 inputfile_t *inputfilebuffer(size_t capacity) {
   inputfile_t *inputfile = (inputfile_t*) malloc(sizeof(inputfile_t));
   inputfile->lines = (char**) malloc(capacity * sizeof(char*));
   inputfile->capacity = capacity;
   inputfile->count = 0;
   inputfile->maxlinewidth = 0;
   return inputfile;
 }
 void addline(inputfile_t *inputfile, char* line, size_t width) {
   char *l = (char*) malloc(width+1);
   memcpy(l, line, width);
   l[width] = 0;
   if (inputfile->count >= inputfile->capacity) {
     inputfile->capacity <<= 1;
     inputfile->lines = realloc(inputfile->lines, inputfile->capacity);
   }
   inputfile->lines[inputfile->count] = l;
   inputfile->maxlinewidth =
           width > inputfile->maxlinewidth ? width : inputfile->maxlinewidth;
   inputfile->count++;
 }
 void freeinputfilebuffer(inputfile_t *inputfile) {
   for (int i = 0 ; i < inputfile->count ; i++) {
     free(inputfile->lines[i]);
   }
   free(inputfile->lines);
   free(inputfile);
 }
 inputfile_t *readinput(char *filename) {
   int fd = open(filename, O_RDONLY);
   if (fd == -1) return NULL;
   inputfile_t *inputfile = inputfilebuffer(512);
   char buf[INPUTBUF_SIZE];
   ssize_t r;
   size_t maxlinewidth = 256;
   char *line = (char*) malloc(maxlinewidth);
   size_t col = 0;
   while ((r = read(fd, buf, INPUTBUF_SIZE)) > 0) {
     for (size_t i = 0 ; i < r ; i++) {
       if (col >= maxlinewidth-4) {
         maxlinewidth <<= 1;
         line = realloc(line, maxlinewidth);
       }
       if (buf[i] == '\n') {
         line[col++] = '\n';
         line[col] = 0;
         addline(inputfile, line, col);
         col = 0;
       } else {
         line[col++] = buf[i];
       }
     }
   }
   free(line);
   close(fd);
   return inputfile;
 }
 size_t writeescapedchar(char *dest, size_t dp, char c) {
   if (c == '>') {
     dest[dp++] = '&'; dest[dp++] = 'g';
     dest[dp++] = 't'; dest[dp++] = ';';
   } else if (c == '<') {
     dest[dp++] = '&'; dest[dp++] = 'l';
     dest[dp++] = 't'; dest[dp++] = ';';
   } else {
     dest[dp++] = c;
   }
   return dp;
 }
 int iskeyword(char *word) {
   for (int i = 0 ; keywords[i] ; i++) {
     if (strncmp(keywords[i], word, WORDBUF_SIZE) == 0) {
       return 1;
     }
   }
   return 0;
 }
 #define istype(word, len) (word[len-2] == '_' && word[len-1] == 't')
 void parseline(char *src, char *dest) {
   size_t sp = 0, dp = 0;
   /* indent */
   while (isspace(src[sp])) {
     dest[dp++] = src[sp++];
   }
   char word[WORDBUF_SIZE];
   memset(word, 0, WORDBUF_SIZE);
   size_t wp = 0;
   int closespan;
   for (char c = src[sp] ; c ; c=src[++sp]) {
     if (!isalnum(c) && c != '_') {
       /* interpret word int_t */
       if (wp > 0 && wp < WORDBUF_SIZE) {
         if (iskeyword(word)) {
           memcpy(&(dest[dp]), "<span class=\"c2html-keyword\">", 29);
           dp += 29;
           closespan = 1;
         } else if (istype(word, wp)) {
           memcpy(&(dest[dp]), "<span class=\"c2html-type\">", 26);
           dp += 26;
           closespan = 1;
         } else {
           closespan = 0;
         }
         for (int i = 0 ; i < wp ; i++) {
           dp = writeescapedchar(dest, dp, word[i]);
         }
         if (closespan) {
           memcpy(&(dest[dp]), "</span>", 7);
           dp += 7;
         }
         memset(word, 0, WORDBUF_SIZE);
         wp = 0;
       }
       dp = writeescapedchar(dest, dp, c);
     } else {
       /* read word */
       if (wp < WORDBUF_SIZE) {
         word[wp++] = c;
       } else if (wp == WORDBUF_SIZE) {
         for (int i = 0 ; i < WORDBUF_SIZE ; i++) {
           dp = writeescapedchar(dest, dp, word[i]);
         }
         wp++;
         dp = writeescapedchar(dest, dp, c);
       } else {
         dp = writeescapedchar(dest, dp, c);
       }
     }
   }
   dest[dp] = 0;
 }
 void printhelp() {
   printf("Formats source code using HTML.\n\nUsage:\n"
       "  c2html [Options] FILE\n\n"
       " Options:\n"
       "  -h                    Prints this help message\n"
       "  -o <output>           Output file (if not specified, stdout is used)\n"
       "\n");
 }
 int lnint(size_t lnc) {
   int w = 1, p = 1;
   while ((p*=10) < lnc) w++;
   return w;
 }
 int main(int argc, char** argv) {
   settings_t settings;
   settings.outfilename = NULL;
   char optc;
   while ((optc = getopt(argc, argv, "ho:")) != -1) {
     switch (optc) {
       case 'o':
         if (!(optarg[0] == '-' && optarg[1] == 0)) {
           settings.outfilename = optarg;
         }
         break;
       case 'h':
         printhelp();
         return 0;
       default:
         return 1;
     }
   }
   if (optind != argc-1) {
     printhelp();
     return 1;
   } else {
     settings.infilename = argv[optind];
     inputfile_t *inputfile = readinput(settings.infilename);
     if (inputfile) {
       FILE *fout;
       if (settings.outfilename) {
         fout = fopen(settings.outfilename, "w");
       } else {
         fout = stdout;
       }
       fprintf(fout, "<pre>\n");
       char *line = (char*) malloc(inputfile->maxlinewidth*64);
       int lnw = lnint(inputfile->count);
       for (int i = 0 ; i < inputfile->count ; i++) {
         parseline(inputfile->lines[i], line);
         fprintf(fout, "<span class=\"c2html-lineno\">%*d:</span> %s",
             lnw, i, line);
       }
       free(line);
       fprintf(fout, "</pre>\n");
       if (fout != stdout) {
         fclose(fout);
       }
       freeinputfilebuffer(inputfile);
     }
     return 0;
   }
 }

Mercurial > hg > c2html / annotate

src/c2html.c@c59fe73459fd (annotated)

src/c2html.c