c2html: src/c2html.c@398a7589297f

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2013 Mike Becker. All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  *

    28  */

    30 #include <stdio.h>

    31 #include <stdlib.h>

    32 #include <string.h>

    33 #include <fcntl.h>

    34 #include <unistd.h>

    35 #include <ctype.h>

    37 #define INPUTBUF_SIZE 2048

    38 #define WORDBUF_SIZE 16

    40 #define istype(word, len) (word[len-2] == '_' && word[len-1] == 't')

    41 #define isdirective(word) (word[0] == '#')

    43 const char* keywords[] = {

    44   "auto", "break", "case", "char", "const", "continue", "default", "do",

    45   "double", "else", "enum", "extern", "float", "for", "goto", "if", "int",

    46   "long", "register", "return", "short", "signed", "sizeof", "static", "struct",

    47   "switch", "typedef", "union", "unsigned", "void", "volatile", "while", NULL

    48 };

    50 typedef struct {

    51   char* outfilename;

    52   char* infilename;

    53   int highlight;

    54 } settings_t;

    56 typedef struct {

    57   size_t count;

    58   size_t capacity;

    59   size_t maxlinewidth;

    60   char** lines;

    61 } inputfile_t;

    63 inputfile_t *inputfilebuffer(size_t capacity) {

    64   inputfile_t *inputfile = (inputfile_t*) malloc(sizeof(inputfile_t));

    65   inputfile->lines = (char**) malloc(capacity * sizeof(char*));

    66   inputfile->capacity = capacity;

    67   inputfile->count = 0;

    68   inputfile->maxlinewidth = 0;

    70   return inputfile;

    71 }

    73 void addline(inputfile_t *inputfile, char* line, size_t width) {

    74   char *l = (char*) malloc(width+1);

    75   memcpy(l, line, width);

    76   l[width] = 0;

    77   if (inputfile->count >= inputfile->capacity) {

    78     inputfile->capacity <<= 1;

    79     inputfile->lines = realloc(inputfile->lines, inputfile->capacity);

    80   }

    81   inputfile->lines[inputfile->count] = l;

    82   inputfile->maxlinewidth =

    83           width > inputfile->maxlinewidth ? width : inputfile->maxlinewidth;

    84   inputfile->count++;

    85 }

    87 void freeinputfilebuffer(inputfile_t *inputfile) {

    88   for (int i = 0 ; i < inputfile->count ; i++) {

    89     free(inputfile->lines[i]);

    90   }

    91   free(inputfile->lines);

    92   free(inputfile);

    93 }

    95 inputfile_t *readinput(char *filename) {

    97   int fd = open(filename, O_RDONLY);

    98   if (fd == -1) return NULL;

   100   inputfile_t *inputfile = inputfilebuffer(512);

   102   char buf[INPUTBUF_SIZE];

   103   ssize_t r;

   105   size_t maxlinewidth = 256;

   106   char *line = (char*) malloc(maxlinewidth);

   107   size_t col = 0;

   109   while ((r = read(fd, buf, INPUTBUF_SIZE)) > 0) {

   110     for (size_t i = 0 ; i < r ; i++) {

   111       if (col >= maxlinewidth-4) {

   112         maxlinewidth <<= 1;

   113         line = realloc(line, maxlinewidth);

   114       }

   116       if (buf[i] == '\n') {

   117         line[col++] = '\n';

   118         line[col] = 0;

   119         addline(inputfile, line, col);

   120         col = 0;

   121       } else {

   122         line[col++] = buf[i];

   123       }

   124     }

   125   }

   127   free(line);

   129   close(fd);

   131   return inputfile;

   132 }

   134 size_t writeescapedchar(char *dest, size_t dp, char c) {

   135   if (c == '>') {

   136     dest[dp++] = '&'; dest[dp++] = 'g';

   137     dest[dp++] = 't'; dest[dp++] = ';';

   138   } else if (c == '<') {

   139     dest[dp++] = '&'; dest[dp++] = 'l';

   140     dest[dp++] = 't'; dest[dp++] = ';';

   141   } else {

   142     dest[dp++] = c;

   143   }

   145   return dp;

   146 }

   148 int iskeyword(char *word) {

   149   for (int i = 0 ; keywords[i] ; i++) {

   150     if (strncmp(keywords[i], word, WORDBUF_SIZE) == 0) {

   151       return 1;

   152     }

   153   }

   154   return 0;

   155 }

   157 int iscapsonly(char *word, size_t wp) {

   158   for (size_t i = 0 ; i < wp ; i++) {

   159     if (!isupper(word[i]) && word[i] != '_') {

   160       return 0;

   161     }

   162   }

   163   return 1;

   164 }

   166 void parseline(char *src, char *dest) {

   167   size_t sp = 0, dp = 0;

   168   /* indent */

   169   while (isspace(src[sp])) {

   170     dest[dp++] = src[sp++];

   171   }

   173   static char word[WORDBUF_SIZE];

   174   static char includefile[FILENAME_MAX];

   176   memset(word, 0, WORDBUF_SIZE);

   177   size_t wp = 0, ifp = 0;

   178   int isstring = 0, iscomment = 0, isinclude = 0, parseinclude = 0;

   179   static int iscommentml;

   180   int isescaping = 0;

   182   if (iscommentml) {

   183     iscomment = 1;

   184     memcpy(&(dest[dp]), "<span class=\"c2html-comment\">", 29);

   185     dp += 29;

   186   }

   188   for (char c = src[sp] ; c ; c=src[++sp]) {

   189     /* comments */

   190     if (c == '/') {

   191       if (iscommentml && sp > 0 && src[sp-1] == '*') {

   192         iscomment = 0;

   193         iscommentml = 0;

   194         memcpy(&(dest[dp]), "/</span>", 8);

   195         dp += 8;

   196         continue;

   197       } else if (!iscomment && (src[sp+1] == '/' || src[sp+1] == '*')) {

   198         iscomment = 1;

   199         iscommentml = (src[sp+1] == '*');

   200         memcpy(&(dest[dp]), "<span class=\"c2html-comment\">", 29);

   201         dp += 29;

   202       }

   203     }

   205     if (iscomment) {

   206       if (c == '\n') {

   207         memcpy(&(dest[dp]), "</span>", 7);

   208         dp += 7;

   209       }

   210       dp = writeescapedchar(dest, dp, c);

   211     } else if (isinclude) {

   212       if (c == '<') {

   213         memcpy(&(dest[dp]), "<span class=\"c2html-stdinclude\">", 32);

   214         dp += 32;

   215         dp = writeescapedchar(dest, dp, c);

   216       } else if (c == '\"') {

   217         if (parseinclude) {

   218           dest[dp++] = '\"';

   219           dest[dp++] = '>';

   220           memcpy(&(dest[dp]), includefile, ifp);

   221           dp += ifp;

   223           dp = writeescapedchar(dest, dp, c);

   224           memcpy(&(dest[dp]), "</a>", 4);

   225           dp += 4;

   226           parseinclude = 0;

   227         } else {

   228           memcpy(&(dest[dp]), "<a class=\"c2html-userinclude\" href=", 35);

   229           dp += 35;

   230           dp = writeescapedchar(dest, dp, c);

   231           ifp = 0;

   232           includefile[ifp++] = '\"';

   233           parseinclude = 1;

   234         }

   235       } else if (c == '>') {

   236         dp = writeescapedchar(dest, dp, c);

   237         memcpy(&(dest[dp]), "</span>", 7);

   238         dp += 7;

   239       } else {

   240         if (parseinclude) {

   241           includefile[ifp++] = c;

   242         }

   243         dp = writeescapedchar(dest, dp, c);

   244       }

   245     } else {

   246       /* strings */

   247       if (!isescaping && (c == '\'' || c == '\"')) {

   248         isstring ^= 1;

   249         if (isstring) {

   250           memcpy(&(dest[dp]), "<span class=\"c2html-string\">", 28);

   251           dp += 28;

   252           dp = writeescapedchar(dest, dp, c);

   253         } else {

   254           dp = writeescapedchar(dest, dp, c);

   255           memcpy(&(dest[dp]), "</span>", 7);

   256           dp += 7;

   257         }

   258       } else {

   259         if (isstring) {

   260           dp = writeescapedchar(dest, dp, c);

   261         } else if (!isalnum(c) && c != '_' && c != '#' && c != '.') {

   262           /* interpret word int_t */

   263           if (wp > 0 && wp < WORDBUF_SIZE) {

   264             int closespan = 1;

   265             if (iskeyword(word)) {

   266               memcpy(&(dest[dp]), "<span class=\"c2html-keyword\">", 29);

   267               dp += 29;

   268             } else if (istype(word, wp)) {

   269               memcpy(&(dest[dp]), "<span class=\"c2html-type\">", 26);

   270               dp += 26;

   271             } else if (isdirective(word)) {

   272               isinclude = !strncmp("#include", word, WORDBUF_SIZE);

   273               memcpy(&(dest[dp]), "<span class=\"c2html-directive\">", 31);

   274               dp += 31;

   275             } else if (iscapsonly(word, wp)) {

   276               memcpy(&(dest[dp]), "<span class=\"c2html-macroconst\">", 32);

   277               dp += 32;

   278             } else {

   279               closespan = 0;

   280             }

   281             for (int i = 0 ; i < wp ; i++) {

   282               dp = writeescapedchar(dest, dp, word[i]);

   283             }

   284             if (closespan) {

   285               memcpy(&(dest[dp]), "</span>", 7);

   286               dp += 7;

   287             }

   288           }

   289           memset(word, 0, WORDBUF_SIZE);

   290           wp = 0;

   291           dp = writeescapedchar(dest, dp, c);

   292         } else {

   293           /* read word */

   294           if (wp < WORDBUF_SIZE) {

   295             word[wp++] = c;

   296           } else if (wp == WORDBUF_SIZE) {

   297             for (int i = 0 ; i < WORDBUF_SIZE ; i++) {

   298               dp = writeescapedchar(dest, dp, word[i]);

   299             }

   300             wp++;

   301             dp = writeescapedchar(dest, dp, c);

   302           } else {

   303             dp = writeescapedchar(dest, dp, c);

   304           }

   305         }

   306       }

   308       isescaping = !isescaping & (c == '\\');

   309     }

   310   }

   311   dest[dp] = 0;

   312 }

   314 void printhelp() {

   315   printf("Formats source code using HTML.\n\nUsage:\n"

   316       "  c2html [Options] FILE\n\n"

   317       " Options:\n"

   318       "  -h                    Prints this help message\n"

   319       "  -o <output>           Output file (if not specified, stdout is used)\n"

   320       "  -p                    Disable highlighting (plain text)\n"

   321       "\n");

   324 }

   326 int lnint(size_t lnc) {

   327   int w = 1, p = 1;

   328   while ((p*=10) < lnc) w++;

   329   return w;

   330 }

   332 int main(int argc, char** argv) {

   334   settings_t settings;

   335   settings.outfilename = NULL;

   336   settings.highlight = 1;

   338   char optc;

   339   while ((optc = getopt(argc, argv, "ho:p")) != -1) {

   340     switch (optc) {

   341       case 'o':

   342         if (!(optarg[0] == '-' && optarg[1] == 0)) {

   343           settings.outfilename = optarg;

   344         }

   345         break;

   346       case 'p':

   347         settings.highlight = 0;

   348         break;

   349       case 'h':

   350         printhelp();

   351         return 0;

   352       default:

   353         return 1;

   354     }

   355   }

   357   if (optind != argc-1) {

   358     printhelp();

   359     return 1;

   360   } else {

   361     settings.infilename = argv[optind];

   363     inputfile_t *inputfile = readinput(settings.infilename);

   364     if (inputfile) {

   365       FILE *fout;

   366       char *line;

   367       if (settings.highlight) {

   368         line = (char*) malloc(inputfile->maxlinewidth*64);

   369       } else {

   370         line = NULL;

   371       }

   372       if (settings.outfilename) {

   373         fout = fopen(settings.outfilename, "w");

   374       } else {

   375         fout = stdout;

   376       }

   377       fprintf(fout, "<pre>\n");

   378       int lnw = lnint(inputfile->count);

   379       for (int i = 0 ; i < inputfile->count ; i++) {

   380         if (settings.highlight) {

   381           parseline(inputfile->lines[i], line);

   382         } else {

   383           line = inputfile->lines[i];

   384         }

   385         fprintf(fout, "<span class=\"c2html-lineno\">%*d:</span> %s",

   386             lnw, i+1, line);

   387       }

   388       if (settings.highlight) {

   389         free(line);

   390       }

   391       fprintf(fout, "</pre>\n");

   393       if (fout != stdout) {

   394         fclose(fout);

   395       }

   397       freeinputfilebuffer(inputfile);

   398     }

   400     return 0;

   401   }

   402 }

Mercurial > hg > c2html / file revision

src/c2html.c@398a7589297f

src/c2html.c