![]() |
Web Development »
Client side scripting »
General
Intermediate
Multiple Language Syntax Highlighting, Part 1: JScriptBy Jonathan de HalleuxMakes automaticaly highlighting source code in web page a reality (for C,C++,JScript, VBScript, XML) |
Javascript, Windows, .NET, ASP, ASP.NET, Visual Studio, Dev
|
|
Advanced Search Add to IE Search |
|
|
||||||||||||||||||

This is the first of a 2 articles serie. In this article, the techniques and ideas are discussed and a Javascript solution is given. In Part 2, a C# solution is given.
Unfortunately for JScript users, I will not update the JScript code and focus on C# only. :)
Have you ever wondered how the CP team highlights the source code in their edited article ? I suppose it's not by hand and they must have some clever code to do it.
However, if you look around in the forums on the web, you will see that there are few if any who have this feature. Sad thing, because colored source code is much easier to read. In fact, it would be great to have source code in forums automatically colored with your favorite coloring scheme.
The last-but-not-least reason for writing this article was to learn regular expressions, javascript and DOM in one project.
The source code entirely written in JScript so it can be included server-side or client-side in your web pages.
The techniques used are:
When reading this article, I will assume that you have little knowledge of regular expressions, DOM and XSLT although I'm also a newbie in those 3 topics.
script or form tags in the article. To play with the live demo, download the "JScript" enabled page (see download section).
![]() |
| Parsing pipe |
All the boxes will be discussed in details in the next chapter. I will give here an short overview of the process.
First, a language syntax specification file is loaded (Language specification box). This specification is a plain xml file given by the users. In order to speed up things, preprocessing is made on this document (Preprocessing box).
Let us suppose for simplicity that we have the source code to colorize (Code box). Note that I will show how to apply the coloring to a whole html page later on. The parser, using the preprocessed syntax document, builds an XML document representing the parsed code (Parsing box). The technique used by the parser is to split up the code in a succession of nodes of different types: keyword, comment, litteral, etc...
At last, an XSTL transformation are applied to the parsed code document to render it to HTML and a CSS style is given to match the desired appearance.
The philosophy used to build the parser is inspired from the Kate documentation (see [1]).
The code is considered as a succession of contexts. For example, in C++,
For each context, we define rules that have 3 properties:
The rules have priority among them. For example, we will first look for a /* ... */ comment, then a // ... line comment, then litteral, etc...
When a rule is matched using a regular expression, the string matched by the rule is assigned with the attribute context, the current context is updated as context and the parsing continues. The diagram show the possible path between contexts. As one can see, some rule do not lead to a need context.
| |
| Context dynamics |
Let me explain a bit the schema below. Consider that we are in the code context. We are going to look for the first match of the code rules: /**/, //, "...", keyword. Moreover, we have to take into account their priorities: a keyword is not really a keyword in a block of comment, so it has a lower priority. This task is easily and naturally done through regular expressions.
Once we find a match, we look for the rule that triggered that match (always following the priority of the rules). Therefore, pathological like is well parsed:
// a keyword while in a commentwhile is not considered as a keyword since it is in a comment.
There are 5 rules currently available:
regexp is by far the most powerful rule of all as all other rules are represented internally by regular expressions.
From the rules and context above, we derive an XML structure as described in the XSD schema below (I don't really understand xsd but .Net generates this nice diagram...)
![]() |
| Language specification schema. Click on the image to view it full size. |
I will breifly discuss the language specification file here. For more details, look at the xsd schema or at highlight.xml specification file (for C++). Basically, you must define families of keywords, choose context and write the rule to pass from one to another.
| Name | Type | Parent Node | Description |
| highlight | root | none |
The root node |
| needs-build | A (optional) | highlight | "yes" if file needs preprocessing |
| save-build | A (optional***) | highlight | "yes" if file has to be saved after preprocessing |
| keywordlists | E | highlight | Node containing families of keywords as children |
| keywordlist | E | keywordlist | A family of keywords |
| id | A | keywordlist | String identifier |
| pre | A (optional) | keywordlist | Regular to append before keyword |
| post | A (optional) | keywordlist | Regular to append at the end of the keyword |
| regexp | A (optional*) | keywordlist | Regular expression matching the keyword family. Build by the preprocessor |
| kw | E | keywordlist | Text or CDATA node containing the keywords |
| languages | E | highlight | Node containing languages as children |
| language | E | languages | A language specification |
| contexts | E | language | A collection of context node |
| default | A | contexts | String identifying the default context |
| context | E | contexts | A context node containing rules as children |
| id | A | context | String identifier |
| attribute | A | context | The name of the node in which the context will be stored. |
| detect2chars** | E | context | Rule to dectect pair of characters. (ex: /*) |
| char | A | detect2chars | First character of the pattern |
| char1 | A | detect2chars | Second character of the pattern |
| detectchar** | E | context | Rule to dectect one character. (ex: ") |
| char | A | detectchar | character to match |
| keyword** | E | context | Rule to match a family of keywords |
| family | A | keyword | Family indentifier, must match /highlight/keywordlists/keyword[@id] |
| regexp | E | context | A regular expression to match |
| expression | A | regexp | the regular expression. |
| attribute (optional) | A | a rule | The name of the node in which the string match will be stored. If not set or equal to "hidden", no node is created. |
| context | A | a rule | The next context. |
<keywordlist ...>
<kw>if</kw>
<kw>else</kw>
</keywordlist>will be matched by \b(if|else)\b
The generated regular expression is added as an attribute to the keywordlist node:
<keywordlist regexp="\b(if|else)\b">
<kw>if</kw>
<kw>else</kw>
</keywordlist>
When using libraries of function, it is usual to have a common function header, like for OpenGL:
glVertex2f, glPushMatrix(), etc...
You can skip the hassle of rewritting gl in all the kw items by using the attribute pre which takes a regular expression as a parameter: <keywordlist pre="gl" ...>
<kw>Vertex2f</kw>
<kw>PushMatrix</kw>
</keywordlist>will be matched by \bgl(Vertex2f|PushMatrix)\bYou can also add regular expression after the keyword using post. Still working on our OpenGL example, there are some methods that have characters at the end to tell the type of parameters:
glCoord2f: takes 2 floats,
glRaster3f: takes 3 floats,
glVertex4v: takes an array of floats of size 4 post and regular expression, we can match it easily: <keywordlist pre="gl" post="[2-4]{1}(f|v){1}" ...>
<kw>Vertex</kw>
<kw>Raster</kw>
</keywordlist>will be matched by \bgl(Vertex2f|PushMatrix)[2-4]{1}(f|v){1}\b
This is a little exercise on regular expression: How to match a literal string in C++? Remember that it must support \", end of line with \.
My answer (remember I'm a newbie) is
"(.|\\"|\\\r\n)*?((\\\\)+"|[^\\]{1}")I tested this expression on the following string: "a simple string"
---
"a less \" simple string"
---
"a even less simple string \\"
---
"a double line\
string"
---
"a double line string does not work without
backslash"
---
"Mixing" string "can\"" become "tricky"
---
"Mixing \" nasty" string is \" even worst"
The context regular expression is also build by concatenating the regular expression of the rules. The value is added as an attribute to the context node:
<context regexp="(...|...)">
| Attribute | Description | Default |
| need-build | "yes" if needs preprocessing | yes |
| save-build | "yes" if saving preprocessed language specification to disk | no |
The preprocessing phase is done through the javascript method loadAndBuildSyntax:
// language specification file
var sXMLSyntax = "highlight.xml";
// loading is done by loadXML
// preprocessing is done in loadAnd... It returns a DOMDocument
var xmlDoc = loadAndBuildSyntax( loadXML( sXMLSyntax ) );
We can start parsing the string (pseudo-code below):
source = source code;
context = code; // current context
regExp = context.regexp; // regular expresion of the current context
while( source.length > 0)
{
Here we follow the procedure:
match = regExp.execute( source );
// check if the rules matched something
if( !match)
{
// no match, creating node with the remaining source and finishing.
addChildNode( context // name of the node,
source // content of the node);
break;
}
else
{
The source before the match has to be stored in a new node: addChildNode( context, source before match);
We now have to find the rule that has matched. This is done by the method findRule that returns the rule node. The rule is then processed using attribute and context parameters.
// getting new node
ruleNode = findRule( match );
// testing if matching string has to be stored
// if yes, adding
if (ruleNode.attribute != "hidden")
addChildNode( attribute, match);
// getting new context
context=ruleNode.context;
// getting new relar expression
regExp=context.regexp;
}
}
At the end of this method, we have build an XML tree containing the context. For example, consider the classic of the classic "Hello world" program below:
int main(int argc, char* argv[])
{
// my first program
cout<<"Hello world";
return -1;
};
This sample is translated in the following xml structure: <parsedcode lang="cpp" in-box="-1">
<reservedkeyword>int</reservedkeyword>
<code> main(</code>
<reservedkeyword>int</reservedkeyword>
<code> argc, >Here is the specification of the resulting XML file:
| Node Name | Type | Parent Node | Description |
| parsedcode | root | Root node of document | |
| lang | A | parsedcode | type of language: c, cpp, jscript, etc. |
| in-box | A | parsedcode | -1 if it should be enclosed in a pre tag, otherwize in code tag |
| code | E | parsedcode | non special source code |
| and others... | E | parsedcode |
The algorithm above is implemented in the applyRules method:
applyRules( languageNode, contextNode, sCode, parsedCodeNode);
where
languageNode is the current language node (XMLDOMNode),
contextNode is the start context node (XMLDOMNode),
sCode is the source code (String),
parsedCodeNode is the parent node of the parsed code (XMLDOMNode)Once you have the XML representation of your code, you can basically do whatever you want with it using XSLT transformations.
Every XSL file starts with some declarations and other standard options:
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output encoding="ISO-8859-1" indent="no" omit-xml-declaration="yes"/>
Since source code indenting has to be conserved, we disable automatic indenting and, also the xml declaration is omitted:
<xsl:output encoding="ISO-8859-1" indent="no" omit-xml-declaration="yes"/>
<xsl:template match="cpp-linecomment">
<span class="cpp-comment">//<xsl:value-of select="text()"
disable-output-escaping="yes" /></span>
</xsl:template>
This template appies to the node cpp-linecomment which corresponds to single line comment in C++.
We apply the CSS style to this node by encapsulating it in span tags and by specifying the CSS class.
Moreovern, we do not want character escaping for that, so we use
<xsl:value-of select="text()" disable-output-escaping="yes" /></span>
It gets a little complicated here. As everybody knows, XSL quicly becomes really complicated once you want to do more advanced stylesheets. Below is the template for parsedcode, it does simple thing but looks ugly:
Checks if in-box parameter is true, if true create pre tags, otherwize create code tags.
<xsl:template match="parsedcode">
<xsl:choose>
<xsl:when test="@in-box[.=0]">
<xsl:element name="span">
<xsl:attribute name="class">cpp-inline</xsl:attribute>
<xsl:attribute name="lang">
<xsl:value-of select="@lang"/>
</xsl:attribute>
<xsl:apply-templates/>
</xsl:element>
</xsl:when>
<xsl:otherwise>
<xsl:element name="pre">
<xsl:attribute name="class">cpp-pre</xsl:attribute>
<xsl:attribute name="lang">
<xsl:value-of select="@lang"/>
</xsl:attribute>
<xsl:apply-templates/>
</xsl:element>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
This is where you have to customize a bit the methods. The rendering is done in the method highlightCode:
highlightCode( sLang, sRootTag, bInBox, sCode)where
sLang is a string identifying the language ( "cpp" for C++),
sRootTag will the node name encapsulation the code. For example, pre for boxed code, code for inline code,
bInCode a boolean set to true if in-box has to be set to true.
sCode is the source code
The file names are hardcoded inside the highlightCode method: hightlight.xml for the language specification, highlight.xsl for the stylesheet. In the article, the XML syntax is embed in a xml tag and is simply accessed using the id
So now you are wondering how to apply this transformation to an entire HTML page? Well surprisingly, this can be done in... 2 lines! In fact, there exist the method String::replace(regExp, replace) that replaces the substring matching the regular expressions regExp with replace. The best part of the story is that replace can be a function... So we just (almost) need to pass highlightCode and we are done.
For example, we want to match the code enclosed in pre tags:
// this is javascript
var regExp=/<pre>(.|\n)*?<\/pre>/gim;
// render xml
var sValue = sValue.replace( regExp,
function( $0 )
{
return highlightCode("cpp", "cpp",$0.substring( 5, $0.length-6 ));
}
);
In practice, some checking are made on the language name and all these computations are hidden in the replaceCode method.
<script language="javascript" runat="server">
...
</script>
processAndHighlightCode to suit your needs
css style with the corresponding classes. The demonstration application is a hack of the CodeProject Article Helper. Type in code in pre or code to see the results.
| Date | Description |
|---|---|
| 02-20-2002 |
|
| 02-17-2002 | Minor changes in stylesheet |
| 02-14-2003 |
|
| 02-13-2003 | Initial release. |
| [1] | The Kate Syntax Highlight System documentation files. |
| [2] | The Code Project Article Helper, Jason Henderson |
| [3] | Expresso - A Tool for Building and Testing Regular Expressions, Hollenhorst |
| [4] | Article Part 2 |
General
News
Question
Answer
Joke
Rant
Admin
|
PermaLink |
Privacy |
Terms of Use
Last Updated: 12 Mar 2003 Editor: Chris Maunder |
Copyright 2003 by Jonathan de Halleux Everything else Copyright © CodeProject, 1999-2009 Web10 | Advertise on the Code Project |