Mercurial > hg > c2html / changeset

     1.1 --- a/src/c2html.c	Tue Aug 23 16:34:02 2016 +0200
     1.2 +++ b/src/c2html.c	Tue Aug 23 17:24:58 2016 +0200
     1.3 @@ -47,18 +47,12 @@
     1.4          "\n");
     1.5  }
     1.6  
     1.7 -/* TODO: remove this workaround after refactoring highlighter structure */
     1.8 -static void plainparseline(char *src, UcxBuffer *dest, int* x) {
     1.9 -    size_t dp = 0;
    1.10 -    char *buf = dest->space + dest->pos;
    1.11 +static void plain_highlighter(char *src, UcxBuffer *dest, int* x) {
    1.12      while (*src && *src != '\n') {
    1.13 -        dp = writeescapedchar(buf, dp, *src);
    1.14 +        put_htmlescaped(dest, *src);
    1.15          src++;
    1.16      }
    1.17 -    buf[dp++] = '\n';
    1.18 -    buf[dp] = '\0';
    1.19 -    dest->pos += dp;
    1.20 -    dest->size += dp;
    1.21 +    ucx_buffer_putc(dest, '\n');
    1.22  }
    1.23  
    1.24  int formatlines(highlighter_func highlighter,
    1.25 @@ -101,7 +95,7 @@
    1.26          /* process code line */
    1.27          highlighter(sourceline->data, line, &multiline_comment);
    1.28          
    1.29 -        /* write code line */
    1.30 +        /* write code line and reset buffer */
    1.31          out(line->space, 1, line->size, stream);
    1.32      }
    1.33      
    1.34 @@ -177,13 +171,13 @@
    1.35          highlighter_func hltr = NULL;
    1.36          switch (sourcetype) {
    1.37              case SOURCE_C:
    1.38 -                hltr = cparseline;
    1.39 +                hltr = c_highlighter;
    1.40                  break;
    1.41              case SOURCE_JAVA:
    1.42 -                hltr = jparseline;
    1.43 +                hltr = java_highlighter;
    1.44                  break;
    1.45              case SOURCE_PLAIN:
    1.46 -                hltr = plainparseline;
    1.47 +                hltr = plain_highlighter;
    1.48                  break;
    1.49              default: /* should be unreachable */
    1.50                  fprintf(stderr, "error in enum source_type\n");

     2.1 --- a/src/ccodegen.c	Tue Aug 23 16:34:02 2016 +0200
     2.2 +++ b/src/ccodegen.c	Tue Aug 23 17:24:58 2016 +0200
     2.3 @@ -28,6 +28,7 @@
     2.4   */
     2.5  
     2.6  #include "ccodegen.h"
     2.7 +#include "ucx/utils.h"
     2.8  #include <string.h>
     2.9  #include <ctype.h>
    2.10  
    2.11 @@ -39,13 +40,7 @@
    2.12      "while", NULL
    2.13  };
    2.14  
    2.15 -#define memcpy_const(darr,doff,str) memcpy(&(darr[doff]), str, sizeof(str)-1); \
    2.16 -                                    dp += sizeof(str)-1
    2.17 -
    2.18 -void cparseline(char *src, UcxBuffer *destbuf, int *multiline_comment) {
    2.19 -    /* TODO: workaround for using old code with UcxBuffer */
    2.20 -    char *dest = destbuf->space + destbuf->pos;
    2.21 -
    2.22 +void c_highlighter(char *src, UcxBuffer *dest, int *multiline_comment) {
    2.23      /* TODO: try to replace these buffers */
    2.24      char wordbuf[WORDBUF_SIZE];
    2.25      sstr_t word;
    2.26 @@ -56,7 +51,7 @@
    2.27      includefile.ptr = includefilebuf;
    2.28      includefile.length = 0;
    2.29      
    2.30 -    size_t sp = (size_t)-1, dp = 0;
    2.31 +    size_t sp = (size_t)-1;
    2.32      int isstring = 0, iscomment = 0, isinclude = 0, parseinclude = 0;
    2.33      char quote = '\0';
    2.34      int isescaping = 0;
    2.35 @@ -64,7 +59,7 @@
    2.36      /* continue a multi line comment highlighting */
    2.37      if (*multiline_comment) {
    2.38          iscomment = 1;
    2.39 -        memcpy_const(dest, dp, "<span class=\"c2html-comment\">");
    2.40 +        ucx_buffer_puts(dest, "<span class=\"c2html-comment\">");
    2.41      }
    2.42  
    2.43      char c;
    2.44 @@ -77,113 +72,103 @@
    2.45              if (*multiline_comment && sp > 0 && src[sp-1] == '*') {
    2.46                  iscomment = 0;
    2.47                  *multiline_comment = 0;
    2.48 -                memcpy_const(dest, dp, "/</span>");
    2.49 +                ucx_buffer_puts(dest, "/</span>");
    2.50                  continue;
    2.51              } else if (!iscomment && (src[sp+1] == '/' || src[sp+1] == '*')) {
    2.52                  iscomment = 1;
    2.53                  *multiline_comment = (src[sp+1] == '*');
    2.54 -                memcpy_const(dest, dp, "<span class=\"c2html-comment\">");
    2.55 +                ucx_buffer_puts(dest, "<span class=\"c2html-comment\">");
    2.56              }
    2.57          }
    2.58  
    2.59          if (iscomment) {
    2.60              if (c == '\n') {
    2.61 -                memcpy_const(dest, dp,  "</span>");
    2.62 +                ucx_buffer_puts(dest, "</span>\n");
    2.63 +            } else {
    2.64 +                put_htmlescaped(dest, c);
    2.65              }
    2.66 -            dp = writeescapedchar(dest, dp, c);
    2.67          } else if (isinclude) {
    2.68              if (c == '<') {
    2.69 -                memcpy_const(dest, dp, "<span class=\"c2html-stdinclude\">");
    2.70 -                dp = writeescapedchar(dest, dp, c);
    2.71 +                ucx_buffer_puts(dest,
    2.72 +                        "<span class=\"c2html-stdinclude\">&lt;");
    2.73              } else if (c == '\"') {
    2.74                  if (parseinclude) {
    2.75 -                    dest[dp++] = '\"';
    2.76 -                    dest[dp++] = '>';
    2.77 -                    memcpy(&(dest[dp]), includefile.ptr, includefile.length);
    2.78 -                    dp += includefile.length;
    2.79 -
    2.80 -                    dp = writeescapedchar(dest, dp, c);
    2.81 -                    memcpy_const(dest, dp, "</a>");
    2.82 +                    ucx_bprintf(dest, "\">%.*s\"</a>",
    2.83 +                            includefile.length, includefile.ptr);
    2.84                      parseinclude = 0;
    2.85                  } else {
    2.86 -                    memcpy_const(dest, dp,
    2.87 -                        "<a class=\"c2html-userinclude\" href=");
    2.88 -                    dp = writeescapedchar(dest, dp, c);
    2.89 +                    ucx_buffer_puts(dest,
    2.90 +                            "<a class=\"c2html-userinclude\" href=\"");
    2.91                      includefile.length = 0;
    2.92                      includefile.ptr[includefile.length++] = '\"';
    2.93                      parseinclude = 1;
    2.94                  }
    2.95              } else if (c == '>') {
    2.96 -                dp = writeescapedchar(dest, dp, c);
    2.97 -                memcpy_const(dest, dp, "</span>");
    2.98 +                ucx_buffer_puts(dest,  "&gt;</span>");
    2.99              } else {
   2.100                  if (parseinclude) {
   2.101                      includefile.ptr[includefile.length++] = c;
   2.102                  }
   2.103 -                dp = writeescapedchar(dest, dp, c);
   2.104 +                put_htmlescaped(dest, c);
   2.105              }
   2.106          } else {
   2.107              /* strings */
   2.108              if (!isescaping && (c == '\'' || c == '\"')) {
   2.109                  if (isstring) {
   2.110 -                    dp = writeescapedchar(dest, dp, c);
   2.111 +                    put_htmlescaped(dest, c);
   2.112                      if (c == quote) {
   2.113                          isstring = 0;
   2.114 -                        memcpy_const(dest, dp, "</span>");
   2.115 +                        ucx_buffer_puts(dest, "</span>");
   2.116                      } else {
   2.117 -                        dp = writeescapedchar(dest, dp, c);
   2.118 +                        put_htmlescaped(dest, c);
   2.119                      }
   2.120                  } else {
   2.121                      isstring = 1;
   2.122                      quote = c;
   2.123 -                    memcpy_const(dest, dp,
   2.124 -                        "<span class=\"c2html-string\">");
   2.125 -                    dp = writeescapedchar(dest, dp, c);
   2.126 +                    ucx_buffer_puts(dest, "<span class=\"c2html-string\">");
   2.127 +                    put_htmlescaped(dest, c);
   2.128                  }
   2.129              } else {
   2.130                  if (isstring) {
   2.131 -                    dp = writeescapedchar(dest, dp, c);
   2.132 -                } else if (!iswordcharacter(c)) {
   2.133 +                    put_htmlescaped(dest, c);
   2.134 +                } else if (!check_alnumex(c)) {
   2.135                      if (word.length > 0 && word.length < WORDBUF_SIZE) {
   2.136                          int closespan = 1;
   2.137                          sstr_t typesuffix = ST("_t");
   2.138                          if (check_keyword(word, ckeywords)) {
   2.139 -                            memcpy_const(dest, dp, 
   2.140 -                                "<span class=\"c2html-keyword\">");
   2.141 +                            ucx_buffer_puts(dest,
   2.142 +                                    "<span class=\"c2html-keyword\">");
   2.143                          } else if (sstrsuffix(word, typesuffix)) {
   2.144 -                            memcpy_const(dest, dp, 
   2.145 +                            ucx_buffer_puts(dest,
   2.146                                  "<span class=\"c2html-type\">");
   2.147                          } else if (word.ptr[0] == '#') {
   2.148                              isinclude = !sstrcmp(word, S("#include"));
   2.149 -                            memcpy_const(dest, dp, 
   2.150 +                            ucx_buffer_puts(dest,
   2.151                                  "<span class=\"c2html-directive\">");
   2.152                          } else if (check_capsonly(word)) {
   2.153 -                            memcpy_const(dest, dp, 
   2.154 +                            ucx_buffer_puts(dest,
   2.155                                  "<span class=\"c2html-macroconst\">");
   2.156                          } else {
   2.157                              closespan = 0;
   2.158                          }
   2.159 -                        for (int i = 0 ; i < word.length ; i++) {
   2.160 -                            dp = writeescapedchar(dest, dp, word.ptr[i]);
   2.161 -                        }
   2.162 +                        put_htmlescapedstr(dest, word);
   2.163                          if (closespan) {
   2.164 -                            memcpy_const(dest, dp, "</span>");
   2.165 +                            ucx_buffer_puts(dest, "</span>");
   2.166                          }
   2.167                      }
   2.168                      word.length = 0;
   2.169 -                    dp = writeescapedchar(dest, dp, c);
   2.170 +                    put_htmlescaped(dest, c);
   2.171                  } else {
   2.172                      /* read word */
   2.173                      if (word.length < WORDBUF_SIZE) {
   2.174                          word.ptr[word.length++] = c;
   2.175                      } else if (word.length == WORDBUF_SIZE) {
   2.176 -                        for (int i = 0 ; i < WORDBUF_SIZE ; i++) {
   2.177 -                            dp = writeescapedchar(dest, dp, word.ptr[i]);
   2.178 -                        }
   2.179 -                        word.length++;
   2.180 -                        dp = writeescapedchar(dest, dp, c);
   2.181 +                        /* TODO: this will be removed */
   2.182 +                        ucx_buffer_puts(dest,
   2.183 +                                "!!! WARNING - WORD TOO LONG TO PARSE !!!");
   2.184 +                        word.length = 0;
   2.185                      } else {
   2.186 -                        dp = writeescapedchar(dest, dp, c);
   2.187 +                        put_htmlescaped(dest, c);
   2.188                      }
   2.189                  }
   2.190              }
   2.191 @@ -191,9 +176,4 @@
   2.192              isescaping = !isescaping & (c == '\\');
   2.193          }
   2.194      } while (c != '\n');
   2.195 -    dest[dp] = 0;
   2.196 -    
   2.197 -    /* TODO: workaround */
   2.198 -    destbuf->pos += dp;
   2.199 -    destbuf->size += dp;
   2.200  }

     3.1 --- a/src/ccodegen.h	Tue Aug 23 16:34:02 2016 +0200
     3.2 +++ b/src/ccodegen.h	Tue Aug 23 17:24:58 2016 +0200
     3.3 @@ -37,11 +37,7 @@
     3.4  extern "C" {
     3.5  #endif
     3.6  
     3.7 -extern const char* ckeywords[];
     3.8 -
     3.9 -int check_ctype(char *word, size_t len);
    3.10 -int check_cdirective(char *word);
    3.11 -void cparseline(char *src, UcxBuffer *dest, int *mlc);
    3.12 +void c_highlighter(char *src, UcxBuffer *dest, int *mlc);
    3.13  
    3.14  #ifdef	__cplusplus
    3.15  }

     4.1 --- a/src/codegens.c	Tue Aug 23 16:34:02 2016 +0200
     4.2 +++ b/src/codegens.c	Tue Aug 23 17:24:58 2016 +0200
     4.3 @@ -32,16 +32,20 @@
     4.4  #include "codegens.h"
     4.5  
     4.6  
     4.7 -size_t writeescapedchar(char *dest, size_t dp, char c) {
     4.8 +void put_htmlescaped(UcxBuffer *dest, char c) {
     4.9      if (c == '>') {
    4.10 -        dest[dp++] = '&'; dest[dp++] = 'g'; dest[dp++] = 't'; dest[dp++] = ';';
    4.11 +        ucx_buffer_puts(dest, ">");
    4.12      } else if (c == '<') {
    4.13 -        dest[dp++] = '&'; dest[dp++] = 'l'; dest[dp++] = 't'; dest[dp++] = ';';
    4.14 +        ucx_buffer_puts(dest, "&lt;");
    4.15      } else {
    4.16 -        dest[dp++] = c;
    4.17 +        ucx_buffer_putc(dest, c);
    4.18      }
    4.19 +}
    4.20  
    4.21 -    return dp;
    4.22 +void put_htmlescapedstr(UcxBuffer *dest, sstr_t s) {
    4.23 +    for (int i = 0 ; i < s.length ; i++) {
    4.24 +        put_htmlescaped(dest, s.ptr[i]);
    4.25 +    }
    4.26  }
    4.27  
    4.28  int check_keyword(sstr_t word, const char** keywords) {

     5.1 --- a/src/codegens.h	Tue Aug 23 16:34:02 2016 +0200
     5.2 +++ b/src/codegens.h	Tue Aug 23 17:24:58 2016 +0200
     5.3 @@ -42,8 +42,10 @@
     5.4  
     5.5  typedef void(*highlighter_func)(char*,UcxBuffer*,int*);
     5.6  
     5.7 -#define iswordcharacter(c) (isalnum(c) || c=='_' || c=='#' || c=='@')
     5.8 -size_t writeescapedchar(char *dest, size_t dp, char c);
     5.9 +void put_htmlescaped(UcxBuffer *dest, char c);
    5.10 +void put_htmlescapedstr(UcxBuffer *dest, sstr_t s);
    5.11 +
    5.12 +#define check_alnumex(c) (isalnum(c) || c=='_' || c=='#' || c=='@')
    5.13  int check_keyword(sstr_t word, const char** keywords);
    5.14  int check_capsonly(sstr_t word);
    5.15  

     6.1 --- a/src/javacodegen.c	Tue Aug 23 16:34:02 2016 +0200
     6.2 +++ b/src/javacodegen.c	Tue Aug 23 17:24:58 2016 +0200
     6.3 @@ -41,26 +41,21 @@
     6.4      "volatile", "const", "float", "native", "super", "while", NULL
     6.5  };
     6.6  
     6.7 -#define memcpy_const(darr,doff,str) memcpy(&(darr[doff]), str, sizeof(str)-1); \
     6.8 -                                    dp += sizeof(str)-1
     6.9 +void java_highlighter(char *src, UcxBuffer *dest, int *multiline_comment) {
    6.10  
    6.11 -void jparseline(char *src, UcxBuffer *destbuf, int *multiline_comment) {
    6.12 -    /* TODO: workaround for using old code with UcxBuffer */
    6.13 -    char *dest = destbuf->space + destbuf->pos;
    6.14 -    
    6.15      /* TODO: try to replace this buffer */
    6.16      char wordbuf[WORDBUF_SIZE];
    6.17      sstr_t word;
    6.18      word.ptr = wordbuf; word.length = 0;
    6.19      
    6.20 -    size_t sp = (size_t)-1, dp = 0;
    6.21 +    size_t sp = (size_t)-1;
    6.22      int isstring = 0, iscomment = 0, isimport = 0;
    6.23      char quote = '\0';
    6.24      int isescaping = 0;
    6.25  
    6.26      if (*multiline_comment) {
    6.27          iscomment = 1;
    6.28 -        memcpy_const(dest, dp, "<span class=\"c2html-comment\">");
    6.29 +        ucx_buffer_puts(dest, "<span class=\"c2html-comment\">");
    6.30      }
    6.31  
    6.32      char c;
    6.33 @@ -73,83 +68,81 @@
    6.34              if (*multiline_comment && sp > 0 && src[sp-1] == '*') {
    6.35                  iscomment = 0;
    6.36                  *multiline_comment = 0;
    6.37 -                memcpy_const(dest, dp, "/</span>");
    6.38 +                ucx_buffer_puts(dest, "/</span>");
    6.39                  continue;
    6.40              } else if (!iscomment && (src[sp+1] == '/' || src[sp+1] == '*')) {
    6.41                  iscomment = 1;
    6.42                  *multiline_comment = (src[sp+1] == '*');
    6.43 -                memcpy_const(dest, dp, "<span class=\"c2html-comment\">");
    6.44 +                ucx_buffer_puts(dest, "<span class=\"c2html-comment\">");
    6.45              }
    6.46          }
    6.47  
    6.48          if (iscomment) {
    6.49              if (c == '\n') {
    6.50 -                memcpy(&(dest[dp]), "</span>", 7);
    6.51 -                dp += 7;
    6.52 +                ucx_buffer_puts(dest, "</span>\n");
    6.53 +            } else {
    6.54 +                put_htmlescaped(dest, c);
    6.55              }
    6.56 -            dp = writeescapedchar(dest, dp, c);
    6.57          } else if (isimport) {
    6.58              /* TODO: local imports */
    6.59          } else {
    6.60              /* strings */
    6.61              if (!isescaping && (c == '\'' || c == '\"')) {
    6.62                  if (isstring) {
    6.63 -                    dp = writeescapedchar(dest, dp, c);
    6.64 +                    put_htmlescaped(dest, c);
    6.65                      if (c == quote) {
    6.66                          isstring = 0;
    6.67 -                        memcpy_const(dest, dp, "</span>");
    6.68 +                        ucx_buffer_puts(dest, "</span>");
    6.69                      } else {
    6.70 -                        dp = writeescapedchar(dest, dp, c);
    6.71 +                        put_htmlescaped(dest, c);
    6.72                      }
    6.73                  } else {
    6.74                      isstring = 1;
    6.75                      quote = c;
    6.76 -                    memcpy_const(dest, dp,
    6.77 +                    ucx_buffer_puts(dest,
    6.78                          "<span class=\"c2html-string\">");
    6.79 -                    dp = writeescapedchar(dest, dp, c);
    6.80 +                    put_htmlescaped(dest, c);
    6.81                  }
    6.82              } else {
    6.83                  if (isstring) {
    6.84 -                    dp = writeescapedchar(dest, dp, c);
    6.85 -                } else if (!iswordcharacter(c)) {
    6.86 +                    put_htmlescaped(dest, c);
    6.87 +                } else if (!check_alnumex(c)) {
    6.88                      if (word.length > 0 && word.length < WORDBUF_SIZE) {
    6.89                          int closespan = 1;
    6.90                          if (check_keyword(word, jkeywords)) {
    6.91 -                            memcpy_const(dest, dp, 
    6.92 +                            ucx_buffer_puts(dest,
    6.93                                  "<span class=\"c2html-keyword\">");
    6.94                          } else if (isupper(word.ptr[0])) {
    6.95 -                            memcpy_const(dest, dp, 
    6.96 +                            ucx_buffer_puts(dest,
    6.97                                  "<span class=\"c2html-type\">");
    6.98                          } else if (word.ptr[0] == '@') {
    6.99 -                            memcpy_const(dest, dp, 
   6.100 +                            ucx_buffer_puts(dest,
   6.101                                  "<span class=\"c2html-directive\">");
   6.102                          } else if (check_capsonly(word)) {
   6.103 -                            memcpy_const(dest, dp, 
   6.104 +                            ucx_buffer_puts(dest,
   6.105                                  "<span class=\"c2html-macroconst\">");
   6.106                          } else {
   6.107                              closespan = 0;
   6.108                          }
   6.109 -                        for (int i = 0 ; i < word.length ; i++) {
   6.110 -                            dp = writeescapedchar(dest, dp, word.ptr[i]);
   6.111 -                        }
   6.112 +                        put_htmlescapedstr(dest, word);
   6.113 +                        
   6.114                          if (closespan) {
   6.115 -                            memcpy_const(dest, dp, "</span>");
   6.116 +                            ucx_buffer_puts(dest, "</span>");
   6.117                          }
   6.118                      }
   6.119                      word.length = 0;
   6.120 -                    dp = writeescapedchar(dest, dp, c);
   6.121 +                    put_htmlescaped(dest, c);
   6.122                  } else {
   6.123                      /* read word */
   6.124                      if (word.length < WORDBUF_SIZE) {
   6.125                          word.ptr[word.length++] = c;
   6.126                      } else if (word.length == WORDBUF_SIZE) {
   6.127 -                        for (int i = 0 ; i < WORDBUF_SIZE ; i++) {
   6.128 -                            dp = writeescapedchar(dest, dp, word.ptr[i]);
   6.129 -                        }
   6.130 -                        word.length++;
   6.131 -                        dp = writeescapedchar(dest, dp, c);
   6.132 +                        /* TODO: this will be removed */
   6.133 +                        ucx_buffer_puts(dest,
   6.134 +                                "!!! WARNING - WORD TOO LONG TO PARSE !!!");
   6.135 +                        word.length = 0;
   6.136                      } else {
   6.137 -                        dp = writeescapedchar(dest, dp, c);
   6.138 +                        put_htmlescaped(dest, c);
   6.139                      }
   6.140                  }
   6.141              }
   6.142 @@ -157,9 +150,4 @@
   6.143              isescaping = !isescaping & (c == '\\');
   6.144          }
   6.145      } while (c != '\n');
   6.146 -    dest[dp] = 0;
   6.147 -    
   6.148 -    /* TODO: workaround */
   6.149 -    destbuf->pos += dp;
   6.150 -    destbuf->size += dp;
   6.151  }

     7.1 --- a/src/javacodegen.h	Tue Aug 23 16:34:02 2016 +0200
     7.2 +++ b/src/javacodegen.h	Tue Aug 23 17:24:58 2016 +0200
     7.3 @@ -37,12 +37,7 @@
     7.4  extern "C" {
     7.5  #endif
     7.6  
     7.7 -extern const char* jkeywords[];
     7.8 -
     7.9 -int check_jtype(char *word, size_t len);
    7.10 -int check_jdirective(char *word);
    7.11 -void jparseline(char *src, UcxBuffer *dest, int *mlc);
    7.12 -
    7.13 +void java_highlighter(char *src, UcxBuffer *dest, int *mlc);
    7.14  
    7.15  #ifdef	__cplusplus
    7.16  }