c2html: src/c2html.c@925172e535a9

     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 };

    51 typedef struct {

    52   size_t count;

    53   size_t capacity;

    54   size_t maxlinewidth;

    55   char** lines;

    56 } inputfile_t;

    58 inputfile_t *inputfilebuffer(size_t capacity) {

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

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

    61   inputfile->capacity = capacity;

    62   inputfile->count = 0;

    63   inputfile->maxlinewidth = 0;

    65   return inputfile;

    66 }

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

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

    70   memcpy(l, line, width);

    71   l[width] = 0;

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

    73     inputfile->capacity <<= 1;

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

    75   }

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

    77   inputfile->maxlinewidth =

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

    79   inputfile->count++;

    80 }

    82 void freeinputfilebuffer(inputfile_t *inputfile) {

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

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

    85   }

    86   free(inputfile->lines);

    87   free(inputfile);

    88 }

    90 inputfile_t *readinput(char *filename) {

    92   int fd = open(filename, O_RDONLY);

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

    95   inputfile_t *inputfile = inputfilebuffer(512);

    97   char buf[INPUTBUF_SIZE];

    98   ssize_t r;

   100   size_t maxlinewidth = 256;

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

   102   size_t col = 0;

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

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

   106       if (col >= maxlinewidth-4) {

   107         maxlinewidth <<= 1;

   108         line = realloc(line, maxlinewidth);

   109       }

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

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

   113         line[col] = 0;

   114         addline(inputfile, line, col);

   115         col = 0;

   116       } else {

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

   118       }

   119     }

   120   }

   122   free(line);

   124   close(fd);

   126   return inputfile;

   127 }

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

   130   if (c == '>') {

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

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

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

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

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

   136   } else {

   137     dest[dp++] = c;

   138   }

   140   return dp;

   141 }

   143 int iskeyword(char *word) {

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

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

   146       return 1;

   147     }

   148   }

   149   return 0;

   150 }

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

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

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

   155       return 0;

   156     }

   157   }

   158   return 1;

   159 }

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

   162   size_t sp = 0, dp = 0;

   163   /* indent */

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

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

   166   }

   168   static char word[WORDBUF_SIZE];

   169   static char includefile[FILENAME_MAX];

   171   memset(word, 0, WORDBUF_SIZE);

   172   size_t wp = 0, ifp = 0;

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

   174   static int iscommentml;

   175   int isescaping = 0;

   177   if (iscommentml) {

   178     iscomment = 1;

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

   180     dp += 29;

   181   }

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

   184     /* comments */

   185     if (c == '/') {

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

   187         iscomment = 0;

   188         iscommentml = 0;

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

   190         dp += 8;

   191         continue;

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

   193         iscomment = 1;

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

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

   196         dp += 29;

   197       }

   198     }

   200     if (iscomment) {

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

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

   203         dp += 7;

   204       }

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

   206     } else if (isinclude) {

   207       if (c == '<') {

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

   209         dp += 32;

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

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

   212         if (parseinclude) {

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

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

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

   216           dp += ifp;

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

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

   220           dp += 4;

   221           parseinclude = 0;

   222         } else {

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

   224           dp += 35;

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

   226           ifp = 0;

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

   228           parseinclude = 1;

   229         }

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

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

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

   233         dp += 7;

   234       } else {

   235         if (parseinclude) {

   236           includefile[ifp++] = c;

   237         }

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

   239       }

   240     } else {

   241       /* strings */

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

   243         isstring ^= 1;

   244         if (isstring) {

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

   246           dp += 28;

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

   248         } else {

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

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

   251           dp += 7;

   252         }

   253       } else {

   254         if (isstring) {

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

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

   257           /* interpret word int_t */

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

   259             int closespan = 1;

   260             if (iskeyword(word)) {

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

   262               dp += 29;

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

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

   265               dp += 26;

   266             } else if (isdirective(word)) {

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

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

   269               dp += 31;

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

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

   272               dp += 32;

   273             } else {

   274               closespan = 0;

   275             }

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

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

   278             }

   279             if (closespan) {

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

   281               dp += 7;

   282             }

   283           }

   284           memset(word, 0, WORDBUF_SIZE);

   285           wp = 0;

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

   287         } else {

   288           /* read word */

   289           if (wp < WORDBUF_SIZE) {

   290             word[wp++] = c;

   291           } else if (wp == WORDBUF_SIZE) {

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

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

   294             }

   295             wp++;

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

   297           } else {

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

   299           }

   300         }

   301       }

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

   304     }

   305   }

   306   dest[dp] = 0;

   307 }

   309 void printhelp() {

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

   311       "  c2html [FILE...]"

   312       "\n");

   315 }

   317 int lnint(size_t lnc) {

   318   int w = 1, p = 1;

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

   320   return w;

   321 }

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

   325   if (argc == 1) {

   326     printhelp();

   327     return 0;

   328   } else {

   330     inputfile_t *inputfile = readinput(argv[1]);

   331     if (inputfile) {

   332       printf("<pre>\n");

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

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

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

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

   337         printf("<span class=\"c2html-lineno\">%*d:</span> %s",

   338             lnw, i+1, line);

   339       }

   340       free(line);

   341       printf("</pre>\n");

   342       freeinputfilebuffer(inputfile);

   343     }

   345     return 0;

   346   }

   347 }

Mercurial > hg > c2html / file revision

src/c2html.c@925172e535a9

src/c2html.c