121 lines
4.8 KiB
Markdown
121 lines
4.8 KiB
Markdown
# c2html
|
|
A tool to add HTML syntax highlighting to C code.
|
|
|
|
Basicaly you give `c2html` some C code as input and it classifies all the keywords, identifiers etc using `<span>` elements, associating them with the appropriate class names. By applying the `style.css` stylesheet to the generated output, you get the highliting. If you prefer, you can write your own style.
|
|
|
|
# Index
|
|
* [Install](#install)
|
|
* [Supported platforms](#supported-platforms)
|
|
* [Install the library](#install-the-library)
|
|
* [Install the command-line interface](#install-the-command-line-interface)
|
|
* [Usage](#usage)
|
|
* [Using the command-line interface](#using-the-command-line-interface)
|
|
* [--no-table](#--no-table)
|
|
* [--style](#--style)
|
|
* [--prefix](#--prefix)
|
|
* [Using the library](#using-the-library)
|
|
|
|
# Install
|
|
|
|
## Supported platforms
|
|
The code is very portable so it's be possible to run it everywhere, although there are only a build and install script for \*nix systems.
|
|
|
|
## Install the library
|
|
To install the library, you just need to copy the `c2html.c` and `c2html.h` files wherever you want to use them and compile them as they were your files. Since the library is so small, you can also just copy the contents of `c2html` in your own project.
|
|
|
|
## Install the command-line interface
|
|
To install the `c2html` command under **linux**, you first have to build it by running `build.sh`, then you can install it with `install.sh`.
|
|
|
|
You may need to give these scripts execution privileges first. You can do that by running `chmod +x build.sh` and `chmod +x install.sh`.
|
|
|
|
# Usage
|
|
c2html comes both as a C library and a command-line utility.
|
|
|
|
## Using the command-line interface
|
|
By running `build.sh`, the `c2html` executable is built, which is command-line interface of c2html.
|
|
|
|
You can highlight your C files by doing
|
|
```sh
|
|
./c2html --input file.c --output file.html
|
|
```
|
|
This command will generate the highlighted C code.
|
|
|
|
### --no-table
|
|
Normally, `c2html` will generate html using a `<table>` element, where each line is a `<tr>` element. This makes the output kind of big. By using the `--no-table` option, it's possible to generate a more lightweight output where lines are splitted using `<br/>` elements instead of using a `<table>`.
|
|
|
|
You'd use it like this;
|
|
```sh
|
|
./c2html --input file.c --output file.html --no-table
|
|
```
|
|
|
|
### --style
|
|
The HTML comes with no styling. If you want to apply a CSS to it, you can provide to `c2html` a style file using the `--style` option followed by the name of the file.
|
|
|
|
```sh
|
|
./c2html --input file.c --output file.html --style style.css
|
|
```
|
|
|
|
This will basically add a `<style>` element with the contents of the `style.css` file before the normal HTML output.
|
|
|
|
### --prefix
|
|
By default, all of the HTML class names are prefixed with `c2h-` to avoid namespace collisions with your code. You can change the prefix using the `--prefix` option, like this:
|
|
```sh
|
|
./c2html --input file.c --output file.html --prefix myprefix-
|
|
```
|
|
in which case, identifiers will be generated with the `myprefix-identifier` class name instead of the usual `c2h-identifier`.
|
|
|
|
## Using the library
|
|
The library only exports one function
|
|
```c
|
|
char *c2html(const char *str, long len, _Bool table_mode,
|
|
const char *class_prefix, const char **error);
|
|
```
|
|
which, given a string containing C code, returns the highlighted version using HTML tags.
|
|
|
|
For example, consider the following C code:
|
|
```c
|
|
/* .. include stdlib.h, string.h and stdio.h .. */
|
|
#include "c2html.h"
|
|
|
|
int main()
|
|
{
|
|
_Bool table_mode = 0;
|
|
const char *prefix = NULL;
|
|
|
|
char *c =
|
|
"int main() {\n"
|
|
" int a = 5;\n"
|
|
" return 0;\n"
|
|
"}\n";
|
|
|
|
char *html = c2html(c, strlen(c), table_mode, prefix, NULL);
|
|
printf("%s\n", html);
|
|
free(html);
|
|
return 0;
|
|
}
|
|
```
|
|
when executed, the output will be:
|
|
```
|
|
<div class="code">
|
|
<div class="code-inner">
|
|
<span class="kword kword-int">int</span> <span class="identifier fdeclname">main</span>() {<br />
|
|
    <span class="kword kword-int">int</span> <span class="identifier">a</span> <span class="operator">=</span> <span class="val-int">5</span>;<br />
|
|
    <span class="kword kword-return">return</span> <span class="val-int">0</span>;<br />
|
|
}<br />
|
|
</div>
|
|
</div>
|
|
```
|
|
If `table_mode` were `1`, then the output would have been:
|
|
```
|
|
<div class="code">
|
|
<div class="code-inner">
|
|
<table>
|
|
<tr><td>1</td><td><span class="kword kword-int">int</span> <span class="identifier fdeclname">main</span>() {</td></tr>
|
|
<tr><td>2</td><td>  <span class="kword kword-int">int</span> <span class="identifier">a</span> <span class="operator">=</span> <span class="val-int">5</span>;</td></tr>
|
|
<tr><td>3</td><td>  <span class="kword kword-return">return</span> <span class="val-int">0</span>;</td></tr>
|
|
<tr><td>4</td><td>}</td></tr>
|
|
<tr><td>5</td><td></td></tr>
|
|
</table>
|
|
</div>
|
|
</div>
|
|
``` |