(fwd) A Mud Protocol (MUD Markup Language)

coder at ibm.net coder at ibm.net
Wed Apr 16 22:15:24 New Zealand Standard Time 1997

This is worth reading:

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):


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: coder at ibm.net
---------------(*)               Internet: clawrenc at cup.hp.com ...Honorary
Member Clan McFUD -- Teamer's Avenging Monolith...

More information about the MUD-Dev mailing list