$ sudo port install cmake

CuPP also uses the boost libraries which have to available on your system. Again, MacPorts is an easy way to get boost:

$ sudo port install boost

Then download CuPP the [website](http://www.plm.eecs.uni-kassel.de/CuPP/), extract it and apply this patch to it:

$ cd cupp
$ patch -p1 < ~/cupp-macosx.patch

After that you can compile CuPP as explained in the BUILDING document:

$ cmake .
$ make

That should do it.
Please note that this patch expects the boost libraries to be installed in ***/opt/local/include/*** directory (if installed via MacPorts this should be fine).

I really enjoyed watching it and I'd recommend to write the application in parallel while you are watching it. That way you'll think more about how all the stuff works.
Every episode (five in total) costs $5 but I think it's completely worth the money.

On the search for an easy way to implement a syntax highlighting mechanism for NSTextView I found an easy and fast (regarding runtime) way to do this. By using flex (a tool with its roots in the 1970's) defining the rules of what should be highlighted makes it a lot more easier and structured.
flex is the GNU version of lex, the lexical analyzer generator (Buzzword jackpot!) developed by Eric Schmidt and Mike Lesk in 1975. By defining some rules (mainly regular expressions) it generates a C program which allows us to scan through a text and do something with the text, e.g. divide it into tokens. Tokens are chunks of characters with a special meaning (as defined in our rules). Confused? Read on, this concept will become very clear soon.

In this article I want to show you how we can use this ancient but very powerful tool to implement a basic syntax highlighting within a NSTextView.

## Overview
At first, let's have a look at the goals. In the demo application (see below) we have one single window with a NSTextView where we can write some text. This text is parsed and highlighted in the following way:

* positive real number will be colored green
* negative real numbers will be colored red

A real number can be entered in the following formats:

* 12
* -3.54
* 23e2
* 23E2
* 423.2e-3
* -5e-1

For the regular expression gurus of you the format can be defined like this:

[-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?

In addition we want to sum up all found real numbers and show the result in our application.

I'd recommend you to download the source code and read the comments there for additional information.
This application consists of three parts:

* NSTextView (for the text) and NSTextField (to show the total value),
* the NSTextStorage delegate and
* the actual scanner created with flex

As you can see, we don't need to subclass NSTextView to add highlighting, everything is done in the NSTextStorage delegate and the scanner.

## NSTextView and NSTextField
The NSTextView is only used for the user to input some text. We don't need to change its behavior nor do we need to subclass it. The NSTextField at the bottom is used to show the total of the collected real number. Nothing special here either.

## NSTextStorage delegate
The NSTextStorage delegte is responsible to pass the entered text to the scanner, to retrieve the token information and to add the string attributes (e.g. the color) to the original text.
The main part is a while-loop which fetches all tokens and if the token indicates a real number, an NSForegroundColorAttribute attribute is added to the text. That's all we have to in the delegate in principle.

## The scanner
The scanner is the heart of this implementation. It takes an ordinary C string and parses through it returning tokens if something interesting is found. Actually, it returns tokens for everything it could find (whether it is text or a real number). This behavior is needed in the delegate to determine the range.
To write such a scanner the flex tool becomes VERY handy, because you can define the behavior of the scanner with a fistful rules. Flex takes these rules and generates a more or less large C file (*lex.yy.c*) which is then the actual scanner.
Xcode supports flex files directly by adding a *.l* file to the project. In the build process Xcode runs flex to "translate" it to C code and it also compiles this C code. We don't have to do anything.
I'd suggest you to read the [flex manual](http://www.gnu.org/software/flex/manual/) to get familiar with flex as I won't explain it in detail. Flex is a really cool tool and to deal with it for some time won't harm.

Unfortunately there is one problem with flex: It doesn't know UTF-8 characters. As you might know UTF-8 characters consist of 2 to 4 bytes and flex thinks every single byte is one character.
But, there is a workaround to this problem. What we can do is to capture all those bytes and return them as on "byte-string". Our delegate will read those bytes in and recognize them as one UTF-8 character.
The designers of UTF-8 were clever and hid the length of the UTF-8 character in the first byte. So, after reading the first UTF-8 byte we can determine how many bytes to follow (more information [here](http://www.unicode.org/versions/Unicode5.0.0/ch03.pdf), page 103). This buffer mechanism requires some additional variables and functions the scanner.

The regular expression mentioned above can easily be split up into more readable parts on the *flex.l* file. Changes to the rules can be applied easily this way.

## Download
The demo application source code can be downloaded via [Git](http://www.git-scm.com):

git clone git://github.com/simonboots/CaptureReals.git

A universal binary is also available [here](http://www.stiefels.net/wp-content/uploads/2008/01/Capture%20Reals.zip).

## Summary
If you're interested in adding a real fast syntax highlighting to your application, doing this with flex should be one option to be considered. It may not be the perfect solution (UTF-8 workaround, missing runtime flexibility) but it is very easy to implement and may fit your requirements.
I hope this article was at least a little bit helpful. Please let me know what you think about it.
Thanks for reading!

## Requirements
This short tutorial requires you to have Mac OS X Leopard (it also may work with Tiger) installed on your system along with the [Xcode tools](http://developer.apple.com/tools/xcode/).

## Getting the sources
The sources of PostgreSQL are free available from one of the mirrors listed [here](http://wwwmaster.postgresql.org/download/mirrors-ftp). Download the current beta from the *source* directory and unpack it.

## Configuring
Before you can start the actual build process, you have to generate the Makefiles. This is done by running the included **configure** script with optional parameters. Available parameters can be listed with the following command:

$ ./configure --help

I decided to build my installation with the following parameters:

$ ./configure --prefix=/opt/local/postgresql83b3
--enable-thread-safety
--without-docdir
--with-perl
--with-gssapi
--with-pam
--with-bonjour
--with-openssl

There is no need to install 3rd party libraries when you use these parameters, but feel free to change them. For a full description of all the parameters have a look at this [website](http://www.postgresql.org/docs/8.3/static/install-procedure.html). The **configure** script now does some checks and creates the Makefiles needed for the build process.

## Building PostgreSQL
The actual build process is started by running the **make** command. The created Makefiles are used to tell the **make** program which files have to be compiled and how the whole application has to build together.

$ make

Depending on your machine the build process takes a few minutes. If **make** succeeds you should see this line:

All of PostgreSQL successfully made. Ready to install.

Great!

## Installing PostgreSQL
The install process is as easy as the build process. The only thing we do is telling **make** to start the installation:

$ make install

A few seconds later you should see this:

PostgreSQL installation complete.

## Creating the database cluster
Before we can use PostgreSQL we have to create at least one database cluster. That is the location where all the data will be stored (here in the directory *data*).

$ cd /opt/local/postgresql83b3
$ bin/initdb ./data

## Starting the server process
Starting the PostgreSQL server process is done via the **pg_ctl** program located in the *bin* directory.

$ bin/pg_ctl -D ./data start

To stop it, use

$ bin/pg_ctl -D ./data stop

## Using launchd to start automatically
If you plan to use PostgreSQL frequently you might be interested in starting PostgreSQL automatically when you log into your system. To do this, download [this file](http://www.stiefels.net/wp-content/uploads/2007/11/net.stiefels.postgresql.starter.plist) and copy it into *~/Library/LaunchAgents* (you may create the *LaunchAgents* directory if it doesn’t already exist). Next time you log in, the PostgreSQL server process is started automatically. The file expects to find your PostgreSQL installation in */opt/local/postgresql83b3*. Feel free to change it, if you installed it somewhere else.

## Connecting to the database
To test if your installation is actually working you can use **psql** to make a local connection to your server. Please note, that PostgreSQL doesn’t allow any network connections using the default configuration. Have a look at the [manual](http://www.postgresql.org/docs/8.3/static/index.html) for further information.

$ cd /opt/local/postgresql83b3$ bin/psql -d postgres
Welcome to psql 8.3beta3, the PostgreSQL interactive terminal.

## Congratulations
The purpose of this little tutorial is to show you how source packages can be compiled on Mac OS X (and other Unices). This way of building applications (configure/make/make install) is a common way in the Unix world and you'll come across these tools very often if you build applications from source packages.

[Philip Hazel](http://www.uit.co.uk/exim-book/author-bio.htm) (who also wrote my favourite SMTP server, [Exim](http://www.exim.org) created a library called [PCRE (Perl-Compatible Regular Expressions)](http://www.pcre.org) a long time ago which implements the Regular Expression syntax used in [Perl](http://www.uit.co.uk/exim-book/author-bio.htm) (sometimes I miss that time) for the C Programming Language.
While PCRE is great for doing Regular Expressions in C, it's usage with Objective-C is some kind of cumbersome as NSString objects must be converted to plain C strings and back again.

But recently John Engelhart released an alpha version of his PCRE-based [RegexKit framework](http://regexkit.sourceforge.net), which provides a sweet object-oriented interface to Regular Expressions. It looks very mature and there is also a [very good documentation](http://regexkit.sourceforge.net/Documentation/index.html) available.

Thank you very much, John!