All File in undroid/tcLex/
Not logged in

Files in directory undroid/tcLex in any check-in

  • doc
  • examples
  • src
  • tclconfig
  • AFAIRE.txt
  • ANNONCE.txt
  • ANNOUNCE.txt
  • LISEZMOI.txt
  • README.chw
  • README.txt
  • TODO.txt
  • aclocal.m4
  • changements.txt
  • changes.txt
  • configure
  • license.txt

tcLex: a lexical analyzer generator for Tcl

tcLex is a lexer (lexical analyzer) generator extension to Tcl. It is inspired 
by Unix and GNU lex and flex, which are "tools for generating programs that 
perform pattern-matching on text". tcLex is very similar to these programs, 
except it uses Tcl philosophy and syntax, whereas the others use their own 
syntax and are used in conjunction with the C language. People used to lex or 
flex should then feel familiar with tcLex. tcLex is a small extension (the 
Windows compiled version is about 20kb, and the source is about 150kb), because 
it extensively uses the Tcl library. However, the current doesn't use Tcl's 
regexp code anymore but a patched version is now included in tcLex, which makes 
it slightly bigger (by a few KB). tcLex should work with Tcl 8.0 and later. 
tcLex will NEVER work with earlier versions, because it uses Tcl 8.0's "object" 
system for performance. The most interesting features are:

 * cross-platform support, thanks to Tcl. Though it has been developped on
   Windows and tested on Windows and Unix only, it should work on other 
   platforms as long as Tcl exists on these platforms. Supported Tcl platforms 
   are Windows 95/NT, Unix (Linux, Solaris...) and Macintosh. Other platforms 
   are VMS, OS/2, NeXTStep, Amiga...
 * unlike lex and flex, which only generate static lexers written in C and
   intended to be compiled, tcLex dynamically generates Tcl commands that can be 
   used like other C commands or Tcl procedures from within Tcl scripts or C 
 * it uses Tcl regular expressions. That means you don't have to learn another
   regexp language.
 * it works with Tcl namespaces
 * the generated lexer commands can be used in one pass or incrementally,
   because they maintain state information. That way, several instances of the 
   same lexer (eg a HTML parser) can run at the same time in distinct call 
   frames and maintain distinct states (local variables...). Lexer need not be 
   specially designed in order to be used incrementally, the same lexer can 
   transparently be used in one pass or incrementally. This feature is 
   especially useful when processing text from a file or an Internet socket (Web 
   pages for example), when data is not necessarily available at the beginning 
   of the processing.


The current tcLex version is 1.2a1. The suffix "a1" means "alpha 1", meaning 
that this version is the first fature-incomplete release of the future 1.2, 
extending and correcting the previous 1.1. The file changes.txt describes the 
changes made between the first version of tcLex and the current version. 
Although it is alpha software, it brings more bugs corrections than new ones 
;-). In this case, alpha means that many planned features are not yet 
implemented, and documentation may be incomplete. Most of the useful info is in 
the file changes.txt. The file TODO.txt contains planned features that needs to 
be implemented.


When I decided to write tcLex, I needed an efficient way to parse HTML and CSS 
files, in order to build a Web browser (a long term project of mine). I was 
trying to use the built-in Tcl commands (regexp, regsub...) to achieve that. 
Although a basic HTML parser was quite simple to write, the limitations of the 
classic approach began to appear with CSS.
Basically, I needed to limit the scope of the regexp/regsub commands to specific 
parts of the parsed text, depending on lexical rules.
For example, the classic way of transforming a HTML file into a Tcl list (for 
easier processing) is to replace (with "regsub") the HTML tag delimiters (<>) 
with Tcl list delimiters (Stephen Uhler does it this way in his html_lib), or 
with brackets for further evaluation with "subst" or "eval". The problems begin 
to arise when HTML delimiter characters are used within strings for attribute 
values (for example, "<IMG ALT='=> home'>"), in this case this method doesn't 
work and the generated list is invalid. Besides, parsing misformed files will 
certainly fail and generate an error. Apart from that, performance is not 
guaranteed, especially if you want to respect the standards and handle all the 
error cases, and also because you need several passes.
I then considered writing specific C extensions for parsing these files, using 
lexers written with lex or flex, but the problem is that you need one extension 
for each file type. Besides, these parsers are static and not extensible, even 
though their basics are the same.
I finally decided to write a Tcl extension for writing lexers. It first tries to 
follow the (f)lex philosophy and syntax while adapting them to Tcl. It then uses 
Tcl's command line syntax and regular expressions, and Tcl scripts instead of C 
code. It also build dynamic Tcl commands instead of C files intended to be 
compiled. The idea behind that is to write a "generic lexer" that would be 
scriptable and extensible with Tcl. Thus, only one extension is needed whatever 
the text data type can be.


Home Page:

Distribution files: 
  (Windows binaries for Tcl8.0.5, Tcl8.1.1 and Tcl8.2)

  (Windows/Unix sources for Tcl8.0.5, Tcl8.1.1 and Tcl8.2)

  (patch file for version 1.1.4)


Since 11/17/1998, tcLex has a dedicated mailing list. The Web site for this list 
is: .
To subscribe, send a e-mail to the following address: .
Also, I try to answer all the mails users send me regarding tcLex.


If you want to compile tcLex yourself, you must know that it needs the Tcl 
source to compile because it makes use of some internal structures. It will 
compile with Tcl 8.0, 8.1 or 8.2.

* Windows:
Precompiled libraries are available in a separate binary distribution. However, 
you can compile the extension yourself. Go to the "src" directory of the source 
distribution, edit the file  "" for Microsoft Visual C++ (no Borland 
file yet, volunteers :-) and edit the different variables to reflect your own 
installation (compiler, Tcl...).

Next, type on the command line:

	nmake -f

Once the compilation has succeeded, type:

	nmake -f install

And it will copy the necessary files in a subdirectory of the Tcl "lib" dir, so 
that it can be used with "package require tcLex" 

* Unix:
(Thanks to John Ellson <> for these files and instructions)
To build tcLex on Unix systems, type:

      cd src
      chmod u+x configure
	chmod u+x install-sh
      make install

The configure script will attempt to deduce a $PREFIX from an existing Tcl 
installation. You may still want to use --prefix=... if tclsh is not in your 
$PATH, or if you have multiple tclsh installed.

The generated Makefile uses the file $PREFIX/lib/ that was left by 
the make of Tcl for most of its configuration parameters.

The Makefile generates a pkgIndex.tcl file that is compatible with Tcl7.6 and 

* MacOS:
There are no makefiles for this platform yet, however compilation should be 
easy, there are only two C files. The only things the source needs are the 
variables TCLEX_VERSION, BUILD_tcLex and USE_TCL_STUBS (if appliable) being 
defined at compile time. You can take a look at the makefile for Windows.


Three precompiled libraries are provided in the binary distribution, named 
tcLex80.dll, tcLex81.dll and tcLex82.dll, respectively for Tcl 8.0, 8.1 and 8.2. 
Just copy them and the file pkgIndex.tcl in a sub-directory of your choice in 
the Tcl "lib" dir.

MacOS, Unix:
No binary distribution for now.


The directory doc contains tcLex documentation in HTML files. The documentation
is available in english (subdir en) and french (subdir fr). Read it carefully.


* Please read the license (file license.txt), and especially the "beerware
  clause" ;-)
* Please send any bugs or comments to <>. Bug reports
  and user feedback are the only way I intend to improve and correct tcLex. If
  no one uses tcLex, I see no reason why I should improve this extension except
  for my own use (for which tcLex is more than adequate for now).
* Even if you have no comment, I'd appreciate that every tcLex user send me a
  mail to the address mentioned above. That gives me information about the
  number of users which is an important part of my motivation. I won't use your
  address to send you unsollicited email, spam, or sell it to telemarketers, but
  only to keep track of users.
* If you find a bug, a short piece of Tcl that exercises it would be very
  useful, or even better, compile with debugging and specify where it crashed in 
that short piece of Tcl.


Since I only use MS Visual C++ on Windows, I'd appreciate contributions from 
people providing other compilers' makefiles (eg Borland), GNU autoconf's, or 
even better, compiled extensions for binay distribution on Macintosh and Unix 
(esp. Linux and Solaris).

I'd also like to gather all the lexers made with tcLex in a single place (a Web 
page for example) as a valuable resource for the Tcl community. Interesting 
contributions would be for example parsers for HTML, XML, CSS, JavaScript and 
other Web languages.