Contact
peter@browsex.com

TML Version 2.0:    Generic Embedded Web Script

Table Of Contents

Introduction

For a sizable example of a TML document, see the link to the source for this document at the bottom of this page. For the impatient, see Installation to get started.

A TML PRIMER

  [Bg Four-score and seven years ago] our <I>forefathers</I> ...

Here is a longer sample, with the HTML translation side by side.

[H1 Some Sample TML] [B Here] is some demonstration [A TML.html TML]]. [ul [li List item 1] [li List item 2] [li List item 3] ]

<H1>Some Sample TML</H1> <B>Here</B> is some demonstration <A HREF="TML.html">TML</A>. <UL> <LI>List item 1</LI> <LI>List item 2</LI> <LI>List item 3</LI> </UL>

Defining Procedures

  [%define Bg <B><FONT COLOR=green>$1</FONT></B>]

   Four-score and seven years ago our forefathers ...

Alternatively, programmers can place code or other text inline using a Block Eval escape: [?
Here is the Tcl definition for the above %define:

  [?
     proc Bg {1} {
        return "<B><FONT COLOR=green>$1</FONT></B>"
     }
  ?]

Attributes

  [Bg<attr1=a attr2=b> Four-score and twenty years ago]

  [%define Bg <FONT $2>$1</FONT>]
  [?
      set size 5;
      proc color args {
        return blue
      }
  ?]
  [Bg<size=$size color=[color]> A call with parameters.]

Don't try to use a $size anywhere else in the document, as only function calls, not variables work. Use [set size] instead. Also note that the arguments to procedures within attributes are processed according to Tcl rules, not TML rules, and so may require quoting/bracketing.

Default attributes to many of the predefined HTML TML tags may be defined as in the following for the INPUT tag:

  [? set _input_ " color=white " ?]

target=new		open hyperlink A in a new window
onevent="..."		event handler ala javascript
tclevent="event cmd ..."		bind event to a form element
tclopts="..."		pass tcl options to form element tcl widget
tktable="VAR"		NOT IMPLEMENTED: for a TABLE, use a tktable with Variable VAR

eventinfo		contains information about an event
browser		set to name of browser
islocal		set to 1 if tml is local (ie. file:)
iscgi		set to 1 if tml is begin executed in a cgi
url		url of current page
query		query string of current page

That covers the basics of TML. Here are some additional things to consider.

• For existing HTML, Convert or Block Protect all square brackets.
• You can use simple Tcl variables and calls inside attributes <> only.
• To use Perl or Python for TML calls, see Alternate Languages.

Escaping Square Brackets In HTML

Example:

    tml -quote foo.html > foo.tml

TML BUILTINS

Block Escapes

[# ... #]		Block Comment *
[= ... =]		Block Protect *
[? ... ?]		Block Eval. Optionally with a command: [?<command> ... ?] *

Character Commands

%lb		output a left bracket: [
%rb		output a right bracket: ]
%ch		output special chars, eg: ?, &, copy, nbsp. +opt count
%sp		output a space, with optional repeat count
%vsp		output a vertical space, with optional repeat count

Control Constructs

%source		include a local file and interpret as tml *
%include		include a local file (no tml interpretation) *
%if<cond>		if statement, cond is a Tcl expression *
%elseif<cond>		elseif statement, follows %if or %elseif *
%else		else statement, follows ] of %if or %elseif *
%while<expr>		while loop *
%for<init expr incr>		for loop *
%foreach<var list ...>		foreach loop *
%break		break out of innermost for, foreach or while loops *
%continue		continue at top of inner loop *
%exit		exit processing *
%error		exit processing with given error message *
%limit		limit the maximum loop iterations: default 1000 *
%parse		parse a string containing TML *
%pragma		force options: see CGI *

Tcl commands can of course be accessed directly. Commands that take two or more arguments can be called with eval. For example:

     [eval set x 9]  
     [set x]  

%eval		Tcl eval, no output
%set		set value of a variable, no output
%incr		incr value of a variable, no output
%null		does nothing, no output

Defining commands

%define name ...		define a tag name.
%predefine name pre		pre is a tcl proc that preprocess input to name
%postdefine name post		post is a tcl proc that postprocess output from name

Miscellaneous Commands

%perl		evals perl code
%python		evals python code
%query		return the query args given the url
%name		shortcut for <A NAME=.., ie. defining a label
%ae		like <A HREF=.., but derefs .tml if file exists
%html		generate HTML encodings for all < and >.
%echo		just returns block of text unchanged.
%pre		same as %html, plus wraps output in a pair of PRE tags.
%setcookie		set a cookie value in a CGI
%getcookie		get a cookie value in a CGI
%accessdata		get/set data from storage
%alert		popup a message dialog box
%widgetcmd		execute a formatted command with a widget
%formwidget		execute subcommand for a form widget
%formvalue		get/set value for a form widget
%sqlite		access sqlite database
%urlget		get a url
%urlgetrel		get a url relative to current
%urlview		get a url in a new view
%viewconf		change view configuration

TML Composite Procedures

%trd		specify a whole table row where all the <td>'s are between ,
%tmltoc		generates a table of contents for page headings.
%tmlborder		a table with a nice solid border/header (table in a table)
%tmldef		a definition table, consisting of a bolded term and a Def.
%tdi		a tmldef item. Separate Term and Def with a ,
%footnote		adds text to end of file, and inserts a link image to it.
%iref		an inline reference

TML Widget Commands

tml debug ?N?		get/set the current debug level
tml errorcmd cmd		setup a command as an error handler
tml inputs ?-includes?		get TML page source ?with includes?
tml maxpass ?N?		get/set the maximum number of passes
tml pass		returns current pass number. 1 is the first pass
tml parse		actually performs the parse
tml puts STR		send a string directly to page output (no newline)
tml append STR		append string to end-buffer (footnotes, etc)
tml language STR		sets the default alternate language

The script tml.tcl sets up the proper environment and handles the parse for you. This includes sourcing htmlrule.tcl to create all the other commands needed in the environment. TML can run in either a safe interpreter or a normal one. Please refer to tml.tcl for details.

HTML Commands

Here is a brief usage comparison of TML and HTML:

  
 HTML:   <B>Brave <I>New World</I></B>
 TML:    [B Brave [I New World]]

  
 HTML:   <FONT COLOR=RED SIZE=1>Hello World</FONT>
 TML:    [FONT<COLOR=RED SIZE=1> Hello World]

  FONT "Hello World" "COLOR=RED SIZE=1"

The file htmlrule.tcl contains the macros that encapsulate html tags. At a minimum, the following tags (upper and lower case) are defined in the current htmlrule.tcl:

  TT B I U S STRIKE BIG SMALL SUB SUP EM STRONG DFN CODE SAMP KBD IMG
  VAR CITE LI TITLE CENTER OL UL DL DD DT FORM BLOCKQUOTE TABLE TR TD 
  BR HR FORM SELECT INPUT TEXTAREA MAP FONT
  H1 H2 H3 H4 H5 H6 H+ H= H-

Defining Procedures

  
  proc foo {v args} { return [B some text bolded] };            # WRONG!!
  proc foo {v args} { return "<B>some text bolded</B>" } ;      # OK
  proc foo {v args} { return [B "some text bolded"] };          # OK
  proc foo {v args} { return [FONT "color text" COLOR=WHITE] }; # OK 

For simple tags, TML syntax is straightforward, but the need to handle attributes complicates things a bit.

  <TAG ATTRIBUTES> DATA </TAG>

  [? proc CENTER {data attr} { return <CENTER$attr>$data</CENTER> } ?]
  [CENTER<align=left color=white>
    Some stuff.
  ]
 

  proc foo {data args} {
    ...
  }

  
  proc foo {}                 { return <B>FOO</B> };# 0 args: NOT IN TML
  proc foo {d}                { return <B>$d</B> }; # 1 arg
  proc foo {d attr}           { return <B>$d</B> }; # 2 args
  proc foo {d {attr {}}}      { return <B>$d</B> }; # 1 or 2 args
  proc foo {{d {}} {attr {}}} { return <B>$d</B> }; # 0, 1, or 2
  proc foo {d args}           { return <B>$d</B> }; # 1 or 2 args
  proc foo {args}             { return <B>$args</B> }; # 0 or more

It was said that by convention, attrs are passed in the second argument. A procedure is free to interpret the data any way it likes. For example, the [A] tag is implemented with shortcuts to allow the href to be the first string in the data. See htmlrule.tml and BrowseX  docs for examples.

How Is It Useful

While HTML <script> areas allows for programmable documents on the client side, it comes up short in several respects. Foremost, it is not reasonably useful on the server side. Conversely, languages such as Perl and Tcl are often used server side (CGI et al) to output HTML, but programming syntax is somewhat awkward and cumbersome to use, and read.

There are two implications to embedding Tml inside BrowseX . The first is that .tml files can be viewed directly by BrowseX  without manually preprocessing the files. This works only because the source file is local (a file:) and therefore Safe-Tcl is not by default used (or when it is, safe-read is enabled) in the embedded Tml-Tcl. Thus file source, includes, etc should work fine.

The second implication is that it is possible for Web servers to return documents of type text/tml and have the BrowseX  browser process the document tags correctly. This will however work only with BrowseX , so caution should be exercised with this practice and/or the Browser type should be checked by the web server. In addition, site specific include files would need to be embedded in an eval statement at top.

  set title {Hello World}
  puts "<B>$title</B><BR>"

 

  .tml    text/tml        # HTML Tcl Macro Language

Installation

Edit the Makefile to change the target install destination, if desired. Edit tml.tcl to change the tclsh line at top if you are not using tclsh8.4.

Type make install. This installs the TML library and puts a tml in your bin directory. If using the CGI, see CGI TML. For Perl, see the Perl section. You may want to get BrowseX  so that you can view tml files directly. If using neither CGI nor BrowseX , you can run the tml command to convert .tml files to HTML for local viewing under a standard browser.

In any case, see Escaping Square Brackets In HTML before working with existing html documents. Also, when defining variables or procedures remember that using % as the first character is reserved for TML. Also reserved are htmlrules_init, tml and _tml.

The source for TML is very small: comprised of just the following source files:

tml.c		The tml widget
tml.tcl		Command and CGI front end
htmlrule.tcl		Implements the Tcl procs sourced into the widget

CGI Tml

  AddType application/x-httpd-tml .tml
  Action application/x-httpd-tml "/cgi-bin/tml.tcl"

-sendtml n		Set to 0 to not allow sending raw TML to BrowseX  (default 0)
-safe n		Set to 0 to not use Safe interp (default 1)

The -safe option forces TML to always be run in a safe interpreter. By default, this is off but BrowseX  uses -safe for TML that are not file:/ URLs. ie. sent by CGI's using the -sendtml option. Note: setting this to 1 in CGI will limit operations (ie. no or restricted read/write/exec), and you will not be able to use a alternate language (Perl and Python). You can use the %pragma option on the first line of the Html file to force -safe on or -sendtml off.

Using A Database

• MySql claims to be the most common freeware one. Use the Tcl-Sql package with it.
• Postgresql comes with a Tcl interface.
• For Oracle, there is OraTcl.
• For Sybase, there is SybTcl.
• For ODBC, there is odbcisql-1.0.tar.gz
• or there is Sqllite which gives GDBM a SQL interface

    package require sql
    set conn1 [sql connect mypass]
    sql selectdb $conn1 test
    catch {sql exec $conn1 "drop table foofoo"}
    sql exec $conn1 "create table foofoo (i integer, r real, s char(10))"
    
    for {set i 0} {$i < 10} {incr i} {
            sql exec $conn1 "insert into foofoo values ($i, $i.01, 'xx $i xx')"
    }
    
    sql query $conn1 "select * from foofoo"
    puts "Printing results:"
    while {1} {
            set row [sql fetchrow $conn1]
            if {$row == ""} break
            puts "##row = $row"
    }
    sql endquery $conn1
    sql disconnect $conn1

Some Advantages of TML

• TML is not a language, and so should be relatively static
• TML is small (around 1200 lines of C) and should stay small
• TML is server and/or client side. CGI and embedded work the same
• The BrowseX  client means you can run even DB scripts without a Web Server
• Bracket matching (ala VI) can be used to check nesting.
• Web pages are fully programmable and parameterizable.
• Less tags means pages are more human readable
• Redefine any or all tags: eg. retarget output, say to LaTeX.
• Most of the standard HTML 3.2 tags have also been defined as Tcl procs. So you can supplant HTML entirely, if desired. Using square brackets rather than angle braces means your not constantly hitting the shift key. And end tags are redundant.
• If it doesn't do what you want, or the way you want, you have the (small) source!

Note 1: All the BrowseX  Web pages are written in TML.

Note 2: For backward compatibility, commands that were in Version 1 of TML (eg. source, define, etc), will also work without the leading percent (%), but will be discontinued in future.

Tcl Tutorial and References

A Tcl Tutorial

Tcl has really only one data type: string. If spaces or special characters are within the string, it should be enclosed in quotes (ie. double quotes or curly braces). Double quotes let variables and calls inside the string be evaluated, curly braces don't. Strings can also be treated as a list: Whitespace is the list separator. Curly braces enclose sublists and need to be balanced or be escaped.

Example 1: The Basics

  # TCL {}               # Perl                   /* C */                
  set s1 {Hello World}   $s1="Hello World";       char *s1="Hello World";
  set s2 "Foo Bar"       $s2="Foo Bar";           char *s2="Foo Bar";
  set s3 Fantasy         $s3="Fantasy";           char *s3="Fantasy";
  set y 7                y=7;                     int x, y=7, K;
  proc max {x1 x2} {     sub max {                int max(int x1, int x2) {
    global K               my($x1,$x2) = @_;
    if {$x1>$x2} {         if ($x1>$x2)             if (x1>x2)
       return $x1            return $x1;               return x1;
    } else {               else                     else
       return $x2            return $x2;               return x2;
    }                      $K=1;                    K=1;
    K=1                  }                        }
  }
                    
  set x [max $y 9]        $x=&max($y,9);          x=max(y,9);                
  unset x

• variable declarations aren't required in Tcl.
• all variables in a procedure are local by default.
• Tcl uses the set command to assign values to variables, rather than an =.
• it uses $ to get the value of a variable, but not during a set.
• curly braces are always required for blocks (unless it's a single word).
• use square brackets to call a proc and get it's return value.
• the Tcl comment is like a command: "#" is after ";" or is first word in line.
• and braces in comments must be balanced, if present.

Example 2: Loop constructs

  # TCL                                 /* C */
  set s 0                               int s=0;
  for {set i 0} {$i<10} {incr i} {      for (i=0; i<10; i++)
    incr s $i                             s+=i;
  }
  set s 0                               s=0;
  set i 0                               i=0;
  while {$i<10} {                       while (s<10) 
    incr s $i                             s+=i;
  }
  foreach i {A B C} {                   char *lst[] = {"A","B","C",0}, *cp=lst;
    append str $i                       while (*cp) strcat(buf,cp++);
  }
  switch $i {                           switch (i) {
    A { set l a}                           case 'A': l='a'; break;
    B { set l b}                           case 'B': l='b'; break;
    C { set l c}                           case 'C': l='c'; break;
    default { set l " " }                  default: l=' ';
  }                                     }

Example 3: Expressions and Arrays

  set x 1;                      # there are no integer types
  set y [expr {$x*1.25}];       # i all numeric operations are done by expr
  if {[expr {($y+1)*5}] > 19} { # round braces really only used in expr
     puts "Got it"
  }
  set ar(0) A
  set ar($x) B
  set ar({Hello World}) -1;     # Tcl arrays are always associative.
  array set ar {3 C 4 D 5 E};   # assign array from list: ar(3)=C, ar(4)=D, ...
  set lst [array get ar];       # assign list from array contents
  foreach i {[array names ar]} {
    append str $ar($i)
  }
  unset ar

Example 4: Pass by reference

  # TCL                   /* C */
  set y 7                 int x, y=7;
  proc max {xx x1 x2} {   int max(int *x, int x1, int x2) {
    upvar $xx x            
    if {$x1>$x2} {          if (x1>x2)
       set x $x1              *x=x1;
    } else {                else
       set x $x2              *x=x2;
    }                     }
  }
                    
  max x $y 9              max(&x,$y,9);                 

Tcl Syntax

Tcl is really just a command processor, with all commands in the form of a list:

  cmd arg arg arg ...

The point is that Tcl doesn't really have a syntax. There are quoting rules, commands and [proc calls], but little else. Even the lowly comment in Tcl can be considered as a sort of NULL command. There is no complicated grammar. In fact, the structure of the language could not be simpler.

Tcl References

• Another slightly longer Tcl tutorial.
• Other Tcl tutorials.
• Online Manual Pages
• TclPro: a Tcl debugger.
• The Tcl Main Site

Alternate Languages

Using Perl

Now you can use the %perl command to evaluate blocks of perl code.

    <H1>Test of Perl</H1>
    [?<%perl>
       sub Bold {
	 my($a)=@_;
         return "<b>".$a."</b>";
       }
       return "Perl code: "
    ?]
    [Bold Here is some text bolded by perl]

    <H1>Test of Perl</H1>
    [? rename Bold OldBold ?]
    [?<%perl>
       sub Bold {
	   my($a)=@_;
           return "<b>".$a."</b>";
       }
    ?]
    [Bold Here it is perl]

Using Python

Now you can use the %python command to evaluate blocks of python code. Due to the finicky indenting requirements of python, blocks are stripped of leading whitespace and trailing spaces.

    [?<%python>
      def bold(n): # return bolded string
         "Return a bolded string"
         return "<b>" + n + "</b>"

_="Python code: "
    ?]
    [bold here is some text bolded by python]

TML COMMAND REFERENCE

%ae - like <A HREF=.., but derefs .tml if file exists

The %ae command is like the hyperlink reference <a href= tag. It takes a file name minus extension as the first argument. The remaining arguments are used as the link description. When viewed as a TML file, %ae appends .tml to the filename and uses that as the link. However, if the source is preprocessed to HTML, .html is appended to make it look for preprocessed links. The following example presumes Foo.tml exists.

Example:

    [%ae Foo Link to foo]

%break - break out of innermost for, foreach or while loops

Example:

    [%while<$y>0>
        [%if<$x<9>
            [%break]
        ]
    ]

%ch - output special chars, eg: ?, &, copy, nbsp. +opt count

Example:

    [%ch ,]
    [%ch copy 5]

Output:

, ©©©©©

%continue - continue at top of inner loop

Example:

    [%while<$y>0>
        [%if<$x<9>
	    [%continue]
        ]
    ]

%define - define a macro

Example:

  [%define FOO <b>FOO</b>]
  [%define BAR <b>BAR $1</b>]

which is more or less equivalent to

  [?
     proc FOO {}  { return "<b>FOO</b>"  }
     proc BAR arg { return "<b>BAR $arg</b>"  }
  ?]

%echo, - returns input unchanged.

%else - conditional

%elseif - conditional

%eval - Tcl eval but discard output

Example:

    [%eval set x 99]

%error - exit processing with given error message

Example:

  [%if<$x>10>
    [%error Value [set x] is out of range]
  ]

%exit - exit processing

Example:

  [%if<$x>10>
    [%exit]
  ]

%for<init expr incr> - a for loop

Attributes:

The attribute of %for contains an list of three items which are interpreted/evaluated by Tcl: the initializer, the exit condition, and the increment. Behavior is the same as Tcl for.

Example:

    [%for<{set i 1} {$i<5} {incr i}>
       Here is the output for line [set i]<br>
    ]

Output:

Here is the output for line 1
Here is the output for line 2
Here is the output for line 3
Here is the output for line 4

%foreach<var list ?var list ...?> - foreach loop

Attributes:

The attribute of %foreach contains an even numbered list of two or more items which are interpreted/evaluated by Tcl. Each pair is a variable and its list of values. Behavior is the same as Tcl foreach.

Example:

    [%foreach<i {Tic Tac Toe}>
       Iterate over [set i]<br>
    ]

and ...

Example:

    [%foreach<r {{Bob Ganes} Tom Bill} p {First Second Third}>
       [set r] was [set i]<br>
    ]

Output:

Bob Ganes was First
Tom was Second
Bill was Third

%getcookie, - get a cookie value in a CGI

Example:

  [%getcookie state]

%html, - generate HTML encodings for all < and >.

%if/%else/%elseif - conditional

Attributes:

The attributes for %if and %elseif contain an expression which is passed to Tcl for evaluation.

Example:

  I think that I will
  [%if<$i>3>
     take a <b>walk</b>
     in the park.
  ]
  [%else
     go for a <i>run</i>
     on the beach.
  ]

%include - data file inclusion

Attributes:

nocomplain

- silently fail if file does not exist

Example:

  [%include myincs.txt]
  [%include<nocomplain=1> maybeincs.txt]

%incr - incr value of a variable, discard output

Example:

    [%incr x -1]

%lb - output a left bracket: [

Example:

    Assign A[lb]99[rb] = 19

%limit - limit the maximum loop iterations

Example:

    [%limit 100]

%name - shortcut for <A NAME=.., ie. defining a label

Example:

    [%name foo]

%parse - evaluate tml in current context

Example:

    [?
        set x {[b Bold moves] are required}
    ?]
    [%parse<$x>]

Output:

Bold moves are required

%perl - evaluate a string containing perl code

  [%perl $x=99]

  [%perl]

%postdefine - postmodify a define

%pragma - request override options

Attributes:

-safe		run in safe interpreter
-sendtml		send raw TML to remote BrowseX
-cgidata		cgi send data file in _tml(cgidata:0), multiple sends ok.
-cgilist		cgi send list items from data file in _tml(cgilist:0), multiple sends ok.
inscripts		look for escape chars even inside script/embed tags. Normally TML will try to avoid what is inside of a SCRIPT or EMBED tag.

Example:

    [%pragma<-safe=1,-sendtml=1>]

%pre, - output translated and PRE protected text

%predefine - premodify a define

Example:

  [%define myh2 <A href=#toc>$1</A>]
  [%predefine h2 myh2a]

%python - evaluate a string containing python code

  [%python x=99]

  [%python]

%query - return the query part of the url

Example:

  [?
    array set qargs {toc 1}
    array set qargs [%query]
  ?]
  [%if<$qargs(toc)>
    [%tmltoc 2]
  ]

%rb - , output a right bracket: ]

Example:

    Assign A[lb]99[rb] = 19

%set - set value of a variable, discard output

Example:

    [%set x 99]

%setcookie, - set a cookie value in a CGI

Example:

  [%setcookie state 12345]

%source - tml source file inclusion

Attributes:

nocomplain

- silently fail if file does not exist

Example:

    [%source mysrc.tml]

%sp - output a space, with optional repeat count

Example:

    A [%sp 20] Gap

Output:

A                      Gap

%vsp -output a vertical space, with optional repeat count

Example:

    A [%vsp 3] Gap

Output:

A
 
 
 
Gap

%while<expr> - a while loop

Attributes:

The attributes for %while contain an expression which is passed to Tcl for evaluation.

Example:

    [%set i 5]
    [%while<$i>0>
        Output for line [set i]<br>
	[%incr i -1]
    ]

Output:

Output for line 5
Output for line 4
Output for line 3
Output for line 2
Output for line 1

[? ... ?] - Block Eval. Optionally with command: [?<command> ... ?]

Examples:

   [?
        # Some Tcl code
        set i 99
	proc Foo {x} { return [incr x] }
	tml puts "Foo<br>"
   ?]

==> Foo

The above is equivalent to using the eval command. Note that in Tcl the result of the last expression becomes it's return value:

   [?<eval>
	set x "Foo<br>"
   ?]

==> Foo

Commands may also take preceding arguments.

   [?<string toupper>
	here is a bunch of upper case text.
   ?]

==> HERE IS A BUNCH OF UPPER CASE TEXT.

And the empty attribute just echos output unchanged.

   [?<>
     This is the same as using <%echo> and passes []
   ?]

==> This is the same as using <%echo> and passes []

[= ... =] - Block Protect

Example:

    [=
	Here is an example<>:
            A[99]=19.
    =]

Output:

     Here is an example<>:
        A[99]=19.

[# ... #] - A Block Comment

Example:

   [# This is a comment
      [%if<$i<1>  # Something going on here...
      ]
   #]

Composite Procedures

%iref - Inline Reference Link

Attributes:

usealt		Show ref text as image alt balloon (default 1)
maxalt		Max alt lines to display (default 500)
closealt		alt string to display when open
imgdir		Directory to obtain images from
title		Title string to display before book image
boldtitle		Bold title when reference open (default 1)
goto		label to goto when click occurs
imgopened		minbook1.gif
imgclosed		minbook2.gif

Example:

    [%iref<title="Open Orders">
	Some lines shown upon click
    %]

%footnote - Footnote

Example:

  [%footnote Note: footnote from demo.]

---

%tdi - a %tmldef item. Comma separated Term and Def

%tmltoc - generates a table of contents for page headings.

Attributes:

twopass

do two passes so we can put TOC at top or anywhere.

Example:

  [? proc mytitle {v args} { return "Hello $v World" } ?]
  [H1 My First TML Doc]
  [H2 A First Crack]
  [B [mytitle Brave New]][BR]
  Here is <I>some</I> text.  
  [%tmltoc]

%tmlborder - a table with a nice solid border/header

Example:

    [tmlborder<title="Hello There">
	[trd Here is a bunch of stuff[br]to fill the table]
    ]

Output:

Hello There Here is a bunch of stuff to fill the table

%tmldef - a definition table, consisting of a bolded term and a Def.

Example:

    [tmldef
	[tdi One:, first definition]
	[tdi Two:, second definition]
    ]

Output:

One:		first definition
Two:		second definition

%trd - specify a whole table row where all the <td>'s are comma separated

Example:

    [table<border=1>
	[trd one, two, three]
	[trd A , B, C]
    ]

Output:

one	two	three
A	B	C

TML Widget Subcommands

tml inputs - get TML page source

Example:

    [%iref<title="TML Source Code For This Page">
    [?
      set dat [tml inputs]
      regsub -all {<} $dat {\&lt;} dat
      tml puts <pre>$dat</pre>
    ?]
    ]

tml puts - send a string directly to page output

Example:

   [?
	tml puts "The total is: $ttl"
   ?]

tml append - append string to end-buffer (footnotes, etc)

Example:

   [?
	tml append "note: see references"
   ?]

tml pass/maxpass -access and sets variables pass and maxpass

   [?
       proc Foo args {
          tml maxpass 2
          if {[tml pass] != [tml maxpass]} return
       }
   ?]

   [?
	tml errorcmd MyError
   ?]

This software is copyrighted Peter MacDonald and BrowseX Systems Inc.
The following terms apply to all files associated
with the software unless explicitly disclaimed in individual files.

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose, provided
that existing copyright notices are retained in all copies and that this
notice is included verbatim in any distributions. No written agreement,
license, or royalty fee is required for any of the authorized uses.
Modifications to this software may be copyrighted by their authors
and need not follow the licensing terms described here, provided that
the new terms are clearly indicated on the first page of each file where
they apply.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
MODIFICATIONS.

GOVERNMENT USE: If you are acquiring this software on behalf of the
U.S. government, the Government shall have only "Restricted Rights"
in the software and related documentation as defined in the Federal
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
are acquiring the software on behalf of the Department of Defense, the
software shall be classified as "Commercial Computer Software" and the
Government shall have only "Restricted Rights" as defined in Clause
252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
authors grant the U.S. Government and others acting in its behalf
permission to use and distribute the software in accordance with the
terms specified in this license.