Document Description and Template Languages are easy and straight forward for simple applications. However, there usually comes a point when an application grows so complex that a Programming Language provides a better solution. heitml is designed to integrate these types of languages, and not just glue them together as we have seen in previous approaches to Web Publishing.

heitml was designed as an extension of HTML. The idea is to deliver a single integrated tool which enables Users to get their Applications up and running quickly and with minimum effort..

Currently, most Web Application Developers use a development model which involves Scripting Languages to produce HTML, which is then sent to the Browser for interpretation.

heitml offers a new approach, illustrated by the following example:

 <if 0 <amount >
   Please send us the amount of $ <? amount>. 
   <br> 
 <else>
   We will send you 
   <font color="red"> $<? -amount> </font>.
   <br> 
 </if>

We assume the value amount was obtained from a database. If amount is positive, the above code fragment prints "Please send us the amount of...", and if it is negative "We will send you ..." appears on the User's screen. (In the latter case amount should be displayed in red.)

Previously, (using a hypothetical Scripting Language) the same process would look something like this:

 if 0<amount; 
    echo "Please send us the amount of "; 
    echo  amount;
    echo "<br> \\n";
 else
    echo "We will send you; 
    echo <font color=\"red\"> $";
    echo -amount;
    echo "</font><br>\\n";
 /if

Although both approaches use a control statement in the form of
if - else - endif, there are a number of artifacts of the Scripting Language which serve only to add complexity to what really should be a quite simple task.

First, the Scripting Language requires a special command (in this case the echo statement) to send output to the Browser. Also, text has to be enclosed in quotation marks in order to distinguish it from variables (in this case amount).

Because the Scripting Language requires quotation marks to handle text, it runs into difficulties when passing values to HTML Tags that also require them. Hence, yet another artifact is introduced, namely the backslash or escape character "\" as seen in the <FONT> Tag above.

However the biggest drawback is that the <FONT> Tag is called in a completely different syntax (inside the echo) than the if. This constantly reminds a programmer of the fact that he is actually writing a program that is generating some other program (in this case, an HTML page) which is then interpreted and displayed. The programmer must forever distinguish between Scripting Lanugage and HTML functionality.

This unneccessay complexity is always present during development, distracting the User from the real problem and so slowing down the development process and increasing the error rate.

heitml avoids all of these problems by offering a syntactically similar environment to HTML. Note that in the heitml example text and variables can be handled on the same line. The <? > Tag asks the question "What is?" and passes information to HTML in text format, exactly as required. The Tag also begins and ends with less-than / greater-than symbols, giving it the familiar appearance of an HTML Tag. Finally, the HTML <br> Tag signals the end of a line, bringing things to a logical conclusion.

Besides Scripting Languages, Template Tools are used for Web-applications. Template Tools avoid writing the echo statements of the Scripting Language, but most of them still use a very different syntax for their commands than HTML uses, and these differences create difficulties that often leads to confusion in the mind of the programmer.

With the design of heitml there is no principle difference between the <if> Tag and the <font> Tag. Both are functions of the heitml "Programming Language". You don't have to know what runs on the Browser and what happens on the Server.

All heitml Tags are used in the same manner as HTML Tags, with the same syntax, parameter passing convention etc.

Furthermore, heitml allows you to define your own Tags in the HTML style, which means you can extened HTML in your own manner, to suit your own purposes, and not have to worry about compatibility with any current or future HTML standards.

Template or Macro languages usually work well in simple cases, but as soon as an application gets complicated you run into problems. This often happens simply because Template Languages are not powerful enough, or they do not take advantage of well-known Programming Language concepts. Unfortunately, even when they do embrace high-level Language features, all too often we wind up using cumbersome Syntactical constructs that make Source Code listings difficult to read.

We often see Template Languages and Programming Languages used in concert with one another. This approach is at least workable, since you can solve all your application problems with it. But it has the drawback that you have to use two languages instead of one, which doubles your learning effort. (In some cases it can be successfully argued that problems related to the interface of these languages actually quadruples the total complexity associated with getting an application up and running.)

The solutions heitml provides to address these problems are many.

First, heitml is a full featured, professional Programming Language. Everything you expect to find in a modern-day Programming Language is contained within heitml: Procedures, Functions, Local Variables, Recursion, Parameter Passing, etc.

heitml is, however, a Template Language and a Programming Language at the same time, and the following examples show how the heitml Syntax manages to bring these two diverse models into harmony with each other:

First, we look at a code fragment:

Are we looking at an if Tag followed by some text and an end-if Tag? This is certainly a traditional HTML-centric view, as can be seen by an illustration following the same format, but with different Tags:

While HTML has trained us to look at things this way, the following code fragment shows that we could just as easily view things from a different perspective:

 if a==5
  > Hello World < 
 /if

We now see that the if statement contains the text Hello World wrapped in > ... < brackets. In other words, we could think of heitml as a Programming Language that contains a > Text < construct, the function of which is to display text.

For example:

 i=1;
 while i<10;
  > The square of <  ?i  > is <  ?i*i  > <br> < 
  let i=i+1;
 /while;

The > Text < construct appears three times in the above example. Everything else is what we would normally view as high-level Language contructs such as control statements and expression evaluation routines.

While newcomers to the heitml Language may feel more comfortable staying with the traditional HTML Tag-oriented view of things, we feel certain that as time goes on, the heitml Programming Language view will become dominant. It will likely be a gradual, almost invisible process, but as one begins to develop applications with thoughts in mind such as, "What if User A has an old Browser and User B has the latest, supporting FRAMES, JavaScripts, etc.? How can I design a single Template to handle both cases?"

Another thought might be, "How can I tailor my Applications to respond to Users with different interests?"

As time goes on, you'll find yourself thinking more and more in terms of if THIS then I'll do THAT, and while This condition remains true, I'll present This specific view of a database. After awhile, you'll realize that you've made the transition from a Tag-oriented to a process oriented mindset, and you'll wonder how you ever got along without it.

User-defined Tags in heitml work just like Procedure Calls of a Programming Language, and that's where the true power lies in developing next-generation Web Applications.

heitml contains special features to integrate with SQL, so writing database programs becomes a straight-forward process.

Additionally, heitml has a built in tuple data type, which is very convenient when programming database applications. It can be used like a struct in C. It can directly be passed to the database, and it can even be used anonymously without knowing the individual field names.

The tuple data type is dynamic. That means fields can dynamically be added. Tuples can be compared and assigned as a whole, in which case pointer semantics apply as in modern Object Oriented Languages.

heitml Pages can be ported to many different kinds of systems. This means that applications are independent of the underlying Operating System, the Web Server, and the Database System.

heitml is designed to be safe - i.e. heitml programs can not produce core dumps and they can access only certain system resources. The latter feature makes it possible to upload heitml Pages to an Internet Provider's Website without the usual security risks associated with programs that contain CGI scripts.

Actually, this has been achieved by leaving out features, rather than including them. heitml pages do not have access to files, they can not access operating system functions, and they can not access special (non-standard) features of a particular Database System. Interfaces to system components have their own definition in heitml. They are not realized by making available the functional interfaces of specific components.

It should be noted, however, that Web Server Administrators can link User written C libraries to heitml, and adaptations can be made to the database interface. Although system specific needs can be met in this manner, portability comes to an end here, as well as when a non-standard SQL implementation is used.

Input text can be processed in

HTML mode or in expression mode

Expressions

Expressions can occur as parameters for heitml and user defined tags. They are evaluated before execution of a specific tag.

Datatypes

heitml knows the following data types:

Integer, 32-Bits Boolean, true or false Float, 64-Bits String, up to 32767 characters Tuple Unknown

A tuple is (as a struct in C) a sequence of fields with an associated value. However the number of fields, their names and types can change dynamically.

heitml Tags

heitml contains a number of special purpose Tags that bring full-featured programming language capability to your Web Page Development Projects. These Tags will help you dynamically format and control the flow of Data to the User's Browser window.

A basic explanation of each Tag, as well as a short Source Code example, can be found in the individual sub-pages in this section.

Note: These Tags are Case Sensitive, which means that heitml will only recognize them in lower-case format.

Purpose: Evaluates Expression and outputs the result.

The Expression part can take various forms. Here are just a few examples:

Special attention need the HTML special characters "<", ">", and "&". replaces them by the neccessary control characters to display these characters unchanges on the screnn on the browser screen:

You can also specify one of the four below-listed Format options if you need to exercise a finer degree of control over the outputed result. The format can be either one of the words HTML, quoted, heitml, or furl; or it can be a string expression.

HTML - The content of Expression is interpreted as HTML. The less-than and greater-than symbols "<" and ">" are not replaced, so the field may contain HTML tags, which are interpreted by the browser.

quoted - The field content is printed in double quotes.

heitml - The field content itself is interpreted as heitml code and executed. This way layouts or even complete heitml pages can be maintained in the database.

heitml source code:	heitml output:
<let x = "<Pic>" + "<p>" + "<Slogan>" <?  x   heitml>	heitml takes the World Wide Web to a higher level!

furl - The field content is encoded as a url parameter.

String Expression - The string expression must evaluate to an option string. Each character of the option string has its own meaning and special effect on the formatting done. A precise description is found below.

Formatting works differently when the ? tag is used in text mode. Replacement of characters for the browser do not take place. The quoted format uses the escaping mechanism of the underlying database system instead. Only quoted and furl format are allowed in text mode.

String Format Parameters

However s formatting options go far beyond for example the "T" format formats a value for use in an HTML table so

   < let x="Numbers are right aligned"; y=700; >
   < table >
   <tr> <? y "Tn" > </tr > 
   <tr> <? x "Tn" > </tr > 
   < /table >

y	700
x	Numbers are right aligned

In general the formatting option string has the following format:

[Separator%] [Context] [Options] [Format]

Separator a string of arbitrary characters excluding %. Context is one of the following characters (sequences): 'H','A','T','F','FT','Q','U','P'. Options are documented below. The Format is one of the following characters 'x','i','s','f','e','E','g','t' .

Context specifies for what context the output should be formatted. Per default the Context is 'H' for HTML. This means the value is formatted in a way to be shown on a HTML page. In contrast 'A' stands for ASCII-File. For example formatting the string "x<p" prints the characters 'x','<','p' in the ASCII Context, but 'x','&','l','t',';','p' in HTML. The < character is substituted so that the browser shows 'x<p' rather than interpreting the < character as an HTML tag.

Other Contexts are T for inside an HTML table, F for inside an HTML form, FT for inside a form and inside a table, 'P' for an HTML tag parameter, 'Q' for inside an SQL query, and 'U' for inside an URL.

The Format character specifies different ways to format a value. These are dependent on the type of the value to be formatted. For strings there is 's' Format only and 's' is the default. For integers 'i' is the default and other possibilities are 'x','X','o','c' for hexadecimal, octal or character representation. For reals 'f' is the default and other possibilies are 'e','E', and 'g' requesting different forms of scientific notation. For tuples there is the special 't' Format described later. If the data type does not match the Format character given, then the default Format is taken.

Also complete tuples can be formatted. Without Options the tuple is shown nicely as in debugging mode: if it is small enough in one line otherwise inside a table. With the Format character 't' all fields of the tuple are formatted with the format specified. The fields are separated by the Separator string.

There are various Options possible. Most important are : the 'n' option that will include the field name and a number specifying the field size.

Formatting Contexts

'T' - format for use inside an HTML table: Formatting is very similar as with 'H'. However the field is enclosed in <td> and </td> tags. This is convenient especially when a tuple is formatted, because the <td> and </td> tags are put around each field. Field alignment is handled by specifying the align parameter in the <td> tag, normally strings are left aligned and numbers are right aligned.

'F' - format for use inside an HTML form: An HTML form-textfield is created using the HTML-input tag. The value to be formatted is put into the textfield. As a name the field receives the name of the variable or tuple field being formatted. The field size is taken from the field size option specified in the format string. Using the 'h' option also hidden fields can be created.

'TF' - format for use inside an HTML form and a table: This combines table and form Context ('T' and 'F'). Form fields are produced, embedded in <td> and </td> tags.

'P' - format for use inside an HTML tag: This format applies when creating an HTML tag definition. For example if you want to create an image tag where the filename is stored in a variable named src

< img src=< ? src "P"; > >

'U' - format for use inside an URL: The value is formatted to be used inside an URL. Characters are encoded in the way required for URLs. It is possible to format tuples. In this case the Separator defaults to & as required for URLs.

'A' - format for use inside an ASCII text: The value is formatted to be used in an ASCII text. No character replacement is performed. The 'A' format is useful inside the mail tag or inside the assign tag. 'A' format can also be used to insert a string into an HTML document without doing any character translation.

The default Separator is a tabulator character. So formatting of a tuple results in a field list, separated by tabs.

'Q' - format for use inside a query: The value is formatted to be used inside an SQL query as a field content. It is enclosed in quotes and special characters are encoded as required for the database system at hand.

Using the 'n' option the fieldname followed by a '=' sign is written before the value. This is useful inside an SQL-update statement or in a search condition. Tuples can also be formatted, the default for the Separator is ','. So the value list for a SQL update statement can be direcly produced.

Format Characters

For Integer Values 'i' is the default. It will print the integer value as a decimal number. 'x' will print it as a hexadecimal number using lowercase letters. 'X' will print a hexadecimal number using uppercase letters. 'o' will print the number in octal. If a precision option is given, it gives the minimal number of digits to be displayed. If neccessary leading zeros are inserted.

For Real Values 'f' is the default. It will print the real number in the form dd.dd where dd is a sequence of digits. As precision option the number of digits after the decimal point can be specified, the default is 6. The 'e' Format will display the real number in exponential representation. 'E' does the same, but uses a capital E to show the exponent. 'g' (or 'G') will use either 'f' or 'e' (or 'E') Format. 'e' is used if the precision is smaller than the exponent or if the exponent is less than -4. The precision here give the number of significant digits.

The number formatting Options are very similar to those of the C printf library. If you are interested in a more detailed discussion please refer to these.

For Tuple Values there are two fundamental different formatting mechanisms. In HTML Context a tuple is formatted by an intelligent formatting routine, that tries to show the tuple in the most readable way. If the tuple is small, it is printed within one line, if it is bigger it is printed in form of a table. Nested tuples are also shown, up to a sensible limit. This formatting option is very good for debug and test output, as well as applications that do not require a customized format.

The other way of tuple formatting applies in all other Contexts and when using the 't' Format in HTML Context. All fields of the tuple are formatted with the same given format. The fields are separated by the Separator string given. The default Separator is ' ' in HTML and 'P' Contexts, tab in 'A' Context, newline in 'T' and 'F' Contexts, and ',' in the 'Q' Context. Using the 'n' option the field name can be printed for each field. If the 't' Format character is used in any Context other than 'H', field names have the form tuplename.fieldname. Tuplename is the name of the tuple variable that is formatted, fieldname the name of the current tuple field. Nested tuples are not displayed. Fields containing null are displayed according to the N option, including the Separator. If 'Nv' is specified, fields containing null are completely left out (including the Separator and the field name).

Options

In 'H', 'A', 'F', 'P', 'Q', and 'U' Contexts the field name followed by a '=' sign is printed before the formatted value. In 'T' and 'TF' Context a table column containing the name is shown before the table column containing the value.

If a tuple is formatted in field list format, (option 'Ht' or any other Context) then the 'n' option will include the field names for each field of the tuple. The name of the tuple itself is printed in 'H' format only.

dd - Field Size dd must be a sequence of digits. They specify the minimal field size. If the field content is smaller then the field is filled up with spaces (or zeros, see option '0'). Numbers are shown right justified, strings left justified. In 'F' and 'TF' Context the field size is also taken as the size of the form field.

.dd - Precision dd must be a sequence of digits. If field size and precision are give, then precision must be given immediatly after the field size. The precision can have very different meanings, depending on the Format character. Please read the documentation of the Format character you are using.

'-' - Alternative Alignment With this Options numbers are left aligned and strings are right aligned.

'D' - Use Default Function The default function is used on the argument before it is formatted: If the variable or the tuple field that should be displayed is not declared then null is assumed. Normally an undefined variable error message is shown.

'N'x - Handling of Null Values The capital N must be followed by another character that specifies how null values are formatted. Possibilities are '0' to display an integer 0, 'r' to display a real 0.0, 'e' to display an empty string, 'b' to display false, 's' to display a string consisting of one space. Other possibilities are 'n' to display 'null', 'N' to display 'NULL', 'S' to display &nbsp, and 'v' to display nothing.

'v' is special, it does not even display the field name and the Separator. It is useful in 'P', 'U', and 'Q' Contexts to completely leave out the fields containing null. The 'S' is useful to display a normal but empty table cell in HTML. HTML normally displays empty table cells in a different layout.

In 'H', 'P', 'U', and 'A' Context 'v' is the default. In the 'Q' Context 'N' is the default. In 'T', 'F', and 'TF' Contexts 'e' is the default.

'NV' - does not show a value This is useful to display the field name only. So "NV" prints all field names of a tuple separated by commas, "\t%NV" prints them separated by tabs.

'h' - create hidden fields This Options is valid in 'F' and 'FT' Contexts only. Then it creates hidden fields instead of normal text form fields.

'0' - Zero Padding Fields are padded with zeros instead of blanks.

'+' - Show Sign For non negative numbers a '+' sign is printed. Normally a sign is printed for negative numbers only.

' ' - Show a space for the + sign Leaves a space as sign for positive numbers.

'#' - Alternative Format In real formatting always a decimal point is shown, even if not followed by a digit. Octal conversions start with a leading 0. Hexadecimal conversions start with 0x or 0X for x and X Formats respectively.