(fwd) A Mud Protocol (MUD Markup Language)

[clawrenc at cup.hp.com]

I'm not sure I forwarded this before:

From: brandon at cc.usu.edu (Brandon Gillespie)
Newsgroups: rec.games.mud.admin
Subject: A Mud Protocol (MUD Markup Language)
Date: 15 Apr 97 12:10:30 MDT

ColdCore ships with 'CML' aka Cold Markup Language, which is the final
result of me thinking the same thoughts you are bouncing
around--except for I did it back when HTML 1.0 was 'the thing'.  CML
has years of evolution behind it, and actually you wouldn't really
recognize it much--it has more of a TCL feel than an SGML, this was
for several reasons--one of which is that SGML is a static document
language, where with CML the 'document' is a dynamic changing entity
with embedded code and whatnot--not to mention that CML is actually
intended for a step above 'formatting', as a CML document can be
'formatted' to HTML, SGML, Postscript, Plaintext, or whatever you
please.  This was also another drive behind CML.  In ColdCore the
simple command:

    @set content-type=text/html

Will change the formatting of your output to be in HTML instead of
plaintext.  For somebody to add 'spiffyhtml' or whatever is trivial. 
Infact, I believe some people have a formatter for pueblo as well
(minor changes to the default html formatter).

You can get full information on CML at the Cold Dark's web port (keep
in mind that all of the documents you see on the Cold Dark--with the
exception of a minor few--are written in CML):

    http://www.cold.org:1180/

The Document that follows is the introductory document on CML.

-Brandon Gillespie

---------------------------------------------------------

CML is used to markup text for dynamic generation and formatting. CML
text is compiled to an internal abstraction called Ctext which can be
easilly decompiled to plain text, HTML or any other format that may be
desired. Ctext is also dynamically interpreted for each interface
receiving the text. This gives extreme power in the final result, and
is much faster   than older MUD systems which use %x replacements in
strings to achieve the same result.

The CML syntax is made of tags embedded within the text. Tags can be
formatted one of two ways depending upon if they are for dynamic text
generation (Generator) or as a formatting or other directive
(Formatter):

        Generator Format: [<name> <options>:<arguments>] 
        Directive Format: {<name> <options>:<arguments>}

Specific tag names may vary depending upon the system. For more
information on the specific tags for this system see help on
Formatters and Generators.

The exact behaviour of a tag may be controlled using options
(sometimes called flags). Options can be in any order, and are
specified in one of two ways:

        key=value    sets the option named key to value
        key          sets the option named key to true (if
                     unspecified it will be false).
                     
Arguments (anything following the colon) are optional, and depend upon
the tag. How arguments are handled depends on whether the tag is a
Generator   or a Formatter. A Generator will treat it's arguments as a
space seperated list. A formatter will treat it's argument as a single
string, starting at the first non-space character following the colon.
Arguments may contain   other tags.

--
J C Lawrence                           Internet: claw at null.net
(Contractor)                           Internet: coder at ibm.net
---------------(*)               Internet: clawrenc at cup.hp.com
...Honorary Member Clan McFUD -- Teamer's Avenging Monolith...