c2html: src/c2html.c@f82aa7afe872

more and better test cases + fixed memory leak introduced by changeset e43dee5892f4

     1 /*

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

     3  *

     4  * Copyright 2015 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  */

    29 #include "c2html.h"

    31 inputfile_t *inputfilebuffer(size_t capacity) {

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

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

    34     inputfile->capacity = capacity;

    35     inputfile->count = 0;

    36     inputfile->maxlinewidth = 0;

    38     return inputfile;

    39 }

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

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

    43     memcpy(l, line, width);

    44     l[width] = 0;

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

    46         inputfile->capacity <<= 1;

    47         inputfile->lines = realloc(inputfile->lines,

    48             sizeof(char*)*inputfile->capacity);

    49     }

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

    51     inputfile->maxlinewidth =

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

    53     inputfile->count++;

    54 }

    56 void freeinputfilebuffer(inputfile_t *inputfile) {

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

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

    59     }

    60     free(inputfile->lines);

    61     free(inputfile);

    62 }

    64 inputfile_t *readinput(char *filename) {

    66     int fd = open(filename, O_RDONLY);

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

    69     inputfile_t *inputfile = inputfilebuffer(512);

    71     char buf[INPUTBUF_SIZE];

    72     ssize_t r;

    74     size_t maxlinewidth = 256;

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

    76     size_t col = 0;

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

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

    80             if (col >= maxlinewidth-4) {

    81                 maxlinewidth <<= 1;

    82                 line = realloc(line, maxlinewidth);

    83             }

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

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

    87                 line[col] = 0;

    88                 addline(inputfile, line, col);

    89                 col = 0;

    90             } else {

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

    92             }

    93         }

    94     }

    96     free(line);

    98     close(fd);

   100     return inputfile;

   101 }

   103 void printhelp() {

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

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

   106         " Options:\n"

   107         "  -h                    Prints this help message\n"

   108         "  -j                    Highlight Java instead of C source code\n"

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

   110         "  -H <header>           Prepend header file\n"

   111         "  -F <footer>           Append footer file\n"

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

   113         "  -l                    Disable line numbers\n"

   114         "\n");

   117 }

   119 int lnint(size_t lnc) {

   120     int w = 1, p = 1;

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

   122     return w;

   123 }

   125 int copyfile(char *filename, FILE *dest) {

   126     if (!filename) {

   127         return 0;

   128     }

   130     FILE *src = fopen(filename, "r");

   131     if (src) {

   132         char buf[4096];

   133         int r;

   134         while ((r = fread(buf, 1, 4096, src)) > 0) {

   135             fwrite(buf, 1, r, dest);

   136         }

   137         fclose(src);

   138         return 0;

   139     } else {

   140         return -1;

   141     }

   142 }

   144 #define WRITECONST(stream, out, cstr) out(cstr, 1, sizeof(cstr)-1, stream)

   145 int formatfile(

   146         highlighter_t *highlighter,

   147         inputfile_t *in,

   148         fmt_write_func out,

   149         void *stream,

   150         _Bool showln) {

   151     // formats an input file and writes the result to out

   153     char *line = malloc(in->maxlinewidth*64);

   154     if(!line) {

   155         return 1;

   156     }

   157     WRITECONST(stream, out, "<pre>\n");

   159     int lnw = lnint(in->count);

   160     for (int i = 0 ; i < in->count ; i++) {

   161         char *ln = line;

   162         if (highlighter) {

   163             highlighter->parser(in->lines[i], line, highlighter);

   164         } else {

   165             ln = in->lines[i];

   166         }

   168         // write line number

   169         if (showln) {

   170             WRITECONST(stream, out, "<span class=\"c2html-lineno\">");

   171             char lnbuf[16];

   172             int len = snprintf(lnbuf, 16, "%*d ", lnw, i+1);

   173             out(lnbuf, 1, len, stream);

   174             WRITECONST(stream, out, "</span> ");

   175         }

   177         // write formated (or plain) code line

   178         out(ln, 1, strlen(ln), stream);

   179     }

   181     WRITECONST(stream, out, "</pre>\n");

   182     free(line);

   183     return 0;

   184 }

   186 void init_c_highlighter(highlighter_t *highlighter) {

   187     memset(highlighter, 0, sizeof(highlighter_t));

   188     highlighter->isdirective = iscdirective;

   189     highlighter->istype = isctype;

   190     highlighter->keywords = ckeywords;

   191     highlighter->parser = cparseline;

   192 }

   194 void init_java_highlighter(highlighter_t *highlighter) {

   195     memset(highlighter, 0, sizeof(highlighter_t));

   196     highlighter->isdirective = isjdirective;

   197     highlighter->istype = isjtype;

   198     highlighter->keywords = jkeywords;

   199     highlighter->parser = jparseline;

   200 }

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

   203     int retcode = EXIT_SUCCESS;

   205     settings_t settings;

   206     memset(&settings, 0, sizeof(settings));

   207     settings.highlight = 1;

   208     settings.showlinenumbers = 1;

   210     int lang = C2HTML_C;

   212     char optc;

   213     while ((optc = getopt(argc, argv, "hljo:pH:F:")) != -1) {

   214         switch (optc) {

   215             case 'o':

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

   217                     settings.outfilename = optarg;

   218                 }

   219                 break;

   220             case 'F':

   221                 settings.footerfile = optarg;

   222                 break;

   223             case 'H':

   224                 settings.headerfile = optarg;

   225                 break;

   226             case 'j':

   227                 lang = C2HTML_JAVA;

   228                 break;

   229             case 'p':

   230                 settings.highlight = 0;

   231                 break;

   232             case 'l':

   233                 settings.showlinenumbers = 0;

   234                 break;

   235             case 'h':

   236                 printhelp();

   237                 return 0;

   238             default:

   239                 return 1;

   240         }

   241     }

   243     if (optind != argc-1) {

   244         printhelp();

   245         return 1;

   246     } else {

   247         settings.infilename = argv[optind];

   248         FILE *fout;

   249         if (settings.outfilename) {

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

   251             if (!fout) {

   252                 perror("Error opening output file");

   253                 return -1;

   254             }

   255         } else {

   256             fout = stdout;

   257         }

   259         if (copyfile(settings.headerfile, fout)) {

   260             perror("Error opening header file");

   261             retcode = -1;

   262             goto prog_end;

   263         }

   265         highlighter_t highlighter;

   266         highlighter_t *hptr = &highlighter;

   267         switch (lang) {

   268             case C2HTML_C:

   269                 init_c_highlighter(&highlighter);

   270                 break;

   271             case C2HTML_JAVA:

   272                 init_java_highlighter(&highlighter);

   273                 break;

   274             default:

   275                 hptr = NULL;

   276                 break;

   277         }

   278         if (!settings.highlight) {

   279             hptr = NULL;

   280         }

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

   283         if (inputfile) {

   284             formatfile(

   285                     hptr,

   286                     inputfile,

   287                     (fmt_write_func)fwrite,

   288                     fout,

   289                     settings.showlinenumbers);

   290             freeinputfilebuffer(inputfile);

   291         } else {

   292             perror("Error opening input file");

   293             retcode = -1;

   294         }

   296         if (copyfile(settings.footerfile, fout)) {

   297             perror("Error opening footer file");

   298             retcode = -1;

   299         }

   301         prog_end:

   302         if (fout != stdout) {

   303             fclose(fout);

   304         }

   306         return retcode;

   307     }

   308 }

Mercurial > hg > c2html / file revision

src/c2html.c@f82aa7afe872

src/c2html.c