The reorg is being put in trunk, I think it's ready. Now we just get to find

out how many applications won't work anymore :)
author: Mike Buland <eichlan@xagasoft.com> 2007-07-03 00:28:59 +0000
committer: Mike Buland <eichlan@xagasoft.com> 2007-07-03 00:28:59 +0000
commit: ac517a2b7625e0aa0862679e961c6349f859ea3b (patch)
tree: e3e27a6b9bd5e2be6150088495c91fc91786ad9d
parent: f8d4301e9fa4f3709258505941e37fab2eadadc6 (diff)
parent: bd865cee5f89116c1f054cd0e5c275e97c2d0a9b (diff)
download: libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.gz
libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.bz2
libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.xz
libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.zip
251 files changed, 11269 insertions, 4473 deletions
diff --git a/Doxyfile b/Doxyfile
index 6c7412e..c3168fa 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -74,9 +74,9 @@ QUIET                  = NO
 WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = YES
 WARN_IF_DOC_ERROR      = YES
-WARN_NO_PARAMDOC       = NO
+WARN_NO_PARAMDOC       = YES
 WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           = 
+WARN_LOGFILE           = Doxywarn
 #---------------------------------------------------------------------------
 # configuration options related to the input files
 #---------------------------------------------------------------------------
diff --git a/bu b/bu
new file mode 120000
index 0000000..02b8847
--- /dev/null
+++ b/bu
@@ -0,0 +1 @@
+src/bu/
+\ No newline at end of file
diff --git a/build.conf b/build.conf
index 5c4dbb6..d994977 100644
--- a/build.conf
+++ b/build.conf
@@ -1,13 +1,20 @@
 # This is a build file for libbu++
-default action: check "libbu++.a"
+default action: check group "lnhdrs", check "libbu++.a"
-"clean" action: clean targets()
+"tests" action: check group "lnhdrs", check group "tests"
-"tests" action: check targets() filter regexp("^tests/.*$")
+"all" action: check group "lnhdrs", check targets()
-"all" action: check targets()
-"fstring" action: check "tests/fstring"
 set "CXXFLAGS" += "-ggdb -Wall"
+#set "CXXFLAGS" += "-pg"
+#set "LDFLAGS" += "-pg"
+filesIn("src") filter regexp("^src/(.*)\\.h$", "src/bu/{re:1}.h"):
+        rule "hln",
+        group "lnhdrs",
+        target file,
+        input "src/{re:1}.h"
 "libbu++.a":
        rule "lib",
        target file,
@@ -17,6 +24,7 @@ set "CXXFLAGS" += "-ggdb -Wall"
 directoriesIn("src/tests","tests/"):
        rule "exe",
        target file,
+        group "tests",
        requires "libbu++.a",
        set "CXXFLAGS" += "-Isrc",
        set "LDFLAGS" += "-L. -lbu++",
@@ -25,6 +33,18 @@ directoriesIn("src/tests","tests/"):
 filesIn("src/tests") filter regexp("^src/tests/(.*)\\.cpp$", "tests/{re:1}"):
        rule "exe",
        target file,
+        group "tests",
+        requires "libbu++.a",
+        set "CXXFLAGS" += "-Isrc",
+        set "LDFLAGS" += "-L. -lbu++",
+        input "src/{target}.cpp"
+["tests/itoqueue1", "tests/itoqueue2"]: set "LDFLAGS" += "-lpthread"
+filesIn("src/unit") filter regexp("^src/unit/(.*)\\.cpp$", "unit/{re:1}"):
+        rule "exe",
+        target file,
+        group "tests",
        requires "libbu++.a",
        set "CXXFLAGS" += "-Isrc",
        set "LDFLAGS" += "-L. -lbu++",
@@ -32,6 +52,8 @@ filesIn("src/tests") filter regexp("^src/tests/(.*)\\.cpp$", "tests/{re:1}"):
 "tests/plugin": set "LDFLAGS" += "-ldl"
+"tests/bzip2": set "LDFLAGS" += "-lbz2"
 rule "exe":
        matches regexp("(.*)\\.o$"),
        aggregate toString(" "),
@@ -47,3 +69,9 @@ rule "cpp":
        produces "{re:1}.o",
        requires commandToList("g++ -M {CXXFLAGS} {match}", "make"),
        perform command("g++ {CXXFLAGS} -c -o {target} {match}")
+rule "hln":
+        matches regexp("src/(.*)\\.h"),
+        produces "src/bu/{re:1}.h",
+        perform command("ln -s ../{re:1}.h {target}")
diff --git a/fstringtest.dev b/fstringtest.dev
new file mode 100644
index 0000000..297242d
--- /dev/null
+++ b/fstringtest.dev
@@ -0,0 +1,59 @@
+[Project]
+FileName=fstringtest.dev
+Name=fstringtest
+UnitCount=1
+Type=1
+Ver=1
+ObjFiles=
+Includes=z:\home\neonphog\wine_documents\libbu++\src\bu
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=_@@_
+Linker=libbu++.a_@@_
+IsCpp=1
+Icon=
+ExeOutput=
+ObjectOutput=
+OverrideOutput=0
+OverrideOutputName=fstringtest.exe
+HostApplication=
+Folders=
+CommandLine=
+UseCustomMakefile=0
+CustomMakefile=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=0
+CompilerSettings=0000000000000000000000
+[VersionInfo]
+Major=0
+Minor=1
+Release=1
+Build=1
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+[Unit1]
+FileName=src\tests\fstring.cpp
+CompileCpp=1
+Folder=fstringtest
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
diff --git a/libbu++.dev b/libbu++.dev
new file mode 100644
index 0000000..2fb1ae9
--- /dev/null
+++ b/libbu++.dev
@@ -0,0 +1,209 @@
+[Project]
+FileName=libbu++.dev
+Name=libbu++
+UnitCount=16
+Type=2
+Ver=1
+ObjFiles=
+Includes=z:\home\neonphog\wine_documents\libbu++\src\bu
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=1
+Icon=
+ExeOutput=
+ObjectOutput=
+OverrideOutput=0
+OverrideOutputName=libbu++.a
+HostApplication=
+Folders=
+CommandLine=
+UseCustomMakefile=0
+CustomMakefile=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=0
+CompilerSettings=0000000000000000000000
+[Unit1]
+FileName=src\stream.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[VersionInfo]
+Major=0
+Minor=1
+Release=1
+Build=1
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+[Unit2]
+FileName=src\stream.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit3]
+FileName=src\file.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit4]
+FileName=src\file.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit5]
+FileName=src\fstring.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit6]
+FileName=src\fstring.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit7]
+FileName=src\archival.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit8]
+FileName=src\archival.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit9]
+FileName=src\archive.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit10]
+FileName=src\archive.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit11]
+FileName=src\hash.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit12]
+FileName=src\hash.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit13]
+FileName=src\exceptionbase.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit14]
+FileName=src\exceptionbase.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit15]
+FileName=src\list.cpp
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+[Unit16]
+FileName=src\list.h
+CompileCpp=1
+Folder=libbu++
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
diff --git a/misc/taf b/misc/taf
new file mode 100644
index 0000000..045b042
--- /dev/null
+++ b/misc/taf
@@ -0,0 +1,26 @@
+{player:
+        password = "aoeuaoeuao"
+        userclass = "implementor"
+        species = "human"
+        sex = "male"
+        active
+        startroom = "Salourn::Xagafinelle's Room"
+        {stats: str=14 dex=12 spd=12 enr=7 rea=12 wil=10 int=13 cha=14}
+        {hp: cur = 100 max = 100}
+        {en: cur = 100 max = 100}
+        attackrate = 30
+        gold = 0
+        {inventory:
+                {: count=1 id="Salourn::Dark Blade"}
+                {: count=1 id="Salourn::Dark Suit"}
+                {: count=3 id="Salourn::Small Fig"}
+        }
+        {aliases:
+                {: key="." value="say"}
+                {: key="," value="yell"}
+                {: key="li" value="lightning"}
+        }
+        description = "They appear to be rather average looking, not particularly
+                tall or short, with facial features that are difficult to remember even
+                seconds after witnessing them."
+}
diff --git a/misc/w3c-xml-1.1.html b/misc/w3c-xml-1.1.html
new file mode 100644
index 0000000..6a9211a
--- /dev/null
+++ b/misc/w3c-xml-1.1.html
@@ -0,0 +1,1598 @@
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html lang="EN" xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8" /><title>Extensible Markup Language (XML) 1.1</title><style type="text/css">
+code           { font-family: monospace; }
+div.constraint,
+div.issue,
+div.note,
+div.notice     { margin-left: 2em; }
+li p           { margin-top: 0.3em;
+                 margin-bottom: 0.3em; }
+div.exampleInner pre { margin-left: 1em;
+                       margin-top: 0em; margin-bottom: 0em}
+div.exampleOuter {border: 4px double gray;
+                  margin: 0em; padding: 0em}
+div.exampleInner { background-color: #d5dee3;
+                   border-top-width: 4px;
+                   border-top-style: double;
+                   border-top-color: #d3d3d3;
+                   border-bottom-width: 4px;
+                   border-bottom-style: double;
+                   border-bottom-color: #d3d3d3;
+                   padding: 4px; margin: 0em }
+div.exampleWrapper { margin: 4px }
+div.exampleHeader { font-weight: bold;
+                    margin: 4px}
+em.rfc2119 { text-transform: lowercase;
+             font-variant: small-caps;
+             font-style: normal; }
+</style><link rel="stylesheet" type="text/css" href="http://www.w3.org/StyleSheets/TR/W3C-REC.css" /></head><body><div class="head"><p><a href="http://www.w3.org/"><img src="http://www.w3.org/Icons/w3c_home" alt="W3C" height="48" width="72" /></a></p>
+<h1><a name="title" id="title" />Extensible Markup Language (XML) 1.1</h1>
+<h2><a name="w3c-doctype" id="w3c-doctype" />W3C Recommendation 04
+             February 2004, edited in place 15 April 2004</h2><dl><dt>This version:</dt><dd><a href="http://www.w3.org/TR/2004/REC-xml11-20040204/">http://www.w3.org/TR/2004/REC-xml11-20040204/</a></dd><dt>Latest version:</dt><dd><a href="http://www.w3.org/TR/xml11">http://www.w3.org/TR/xml11</a></dd><dt>Previous version:</dt><dd><a href="http://www.w3.org/TR/2003/PR-xml11-20031105/">http://www.w3.org/TR/2003/PR-xml11-20031105/</a></dd><dt>Editors:</dt><dd>Tim Bray, Textuality and Netscape <a href="mailto:tbray@textuality.com">&lt;tbray@textuality.com&gt;</a></dd><dd>Jean Paoli, Microsoft <a href="mailto:jeanpa@microsoft.com">&lt;jeanpa@microsoft.com&gt;</a></dd><dd>C. M. Sperberg-McQueen, W3C <a href="mailto:cmsmcq@w3.org">&lt;cmsmcq@w3.org&gt;</a></dd><dd>Eve Maler, Sun Microsystems, Inc. <a href="mailto:elm@east.sun.com">&lt;eve.maler@east.sun.com&gt;</a></dd><dd>François Yergeau <a href="mailto:fyergeau@alis.com">&lt;fyergeau@alis.com&gt;</a></dd><dd>John Cowan <a href="mailto:cowan@ccil.org">&lt;cowan@ccil.org&gt;</a></dd></dl><p>Please refer to the <a href="http://www.w3.org/XML/xml-V11-1e-errata"><strong>errata</strong></a> for this document, which may include some normative corrections.</p><p>This document is also available in these non-normative formats: <a href="REC-xml11-20040204.xml">XML</a> and <a href="REC-xml11-20040204-review.html">XHTML with color-coded revision indicators</a>.</p><p>See also <a href="http://www.w3.org/2003/03/Translations/byTechnology?technology=xml11"><strong>translations</strong></a>.</p><p class="copyright"><a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © 2004 <a href="http://www.w3.org/"><acronym title="World Wide Web Consortium">W3C</acronym></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><acronym title="Massachusetts Institute of Technology">MIT</acronym></a>, <a href="http://www.ercim.org/"><acronym title="European Research Consortium for Informatics and Mathematics">ERCIM</acronym></a>, <a href="http://www.keio.ac.jp/">Keio</a>), All Rights Reserved. W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a>, <a href="http://www.w3.org/Consortium/Legal/copyright-documents">document use</a> and <a href="http://www.w3.org/Consortium/Legal/copyright-software">software licensing</a> rules apply.</p></div><hr /><div> <h2><a name="abstract" id="abstract" />Abstract</h2><p>The Extensible Markup Language (XML) is a subset of SGML that is completely
+described in this document. Its goal is to enable generic SGML to be served,
+received, and processed on the Web in the way that is now possible with HTML.
+XML has been designed for ease of implementation and for interoperability
+with both SGML and HTML.</p></div><div> <h2><a name="status" id="status" />Status of this Document</h2><p><em>This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the <a href="http://www.w3.org/TR/">W3C technical reports index</a> at http://www.w3.org/TR/.</em></p><p>This document is a <a href="http://www.w3.org/2003/06/Process-20030618/tr.html#RecsW3C">Recommendation</a> of the W3C.
+It has been reviewed by W3C Members and other interested parties, and has
+been endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited as a normative reference from another document. W3C's role in making the
+Recommendation is to draw attention to the specification and to promote its widespread deployment.
+This enhances the functionality and interoperability of the Web.</p><p>This document specifies a syntax created by subsetting an existing, widely
+used international text processing standard (Standard Generalized Markup Language,
+ISO 8879:1986(E) as amended and corrected) for use on the World Wide Web.
+It is a product of the <a
+             href="http://www.w3.org/XML/Activity.html">W3C XML
+             Activity</a>.</p>
+<p>On 15 April 2004, this document was edited in place to add two
+missing spaces to <a
+href="http://www.w3.org/TR/2004/REC-xml11-20040204/Overview.html#NT-document">production
+[1]</a> in section 2.1</p>
+<p>The English version of this specification is the only normative version. However,
+for translations of this document, see <a href="http://www.w3.org/2003/03/Translations/byTechnology?technology=xml11">http://www.w3.org/2003/03/Translations/byTechnology?technology=xml11</a>.
+</p><p>Documentation of intellectual property possibly relevant to this recommendation
+may be found at the Working Group's public
+<a href="http://www.w3.org/2002/08/xmlcore-IPR-statements">IPR disclosure page</a>.</p><p>An implementation report for XML 1.1 is available at <a href="http://www.w3.org/XML/2002/09/xml11-implementation.html">http://www.w3.org/XML/2002/09/xml11-implementation.html</a>.</p><p>Please report errors in this document to <a href="mailto:xml-editor@w3.org">xml-editor@w3.org</a>; <a href="http://lists.w3.org/Archives/Public/xml-editor">archives</a> are available. The errata list for this edition is available
+at <a href="http://www.w3.org/XML/xml-V11-1e-errata">http://www.w3.org/XML/xml-V11-1e-errata</a>.</p><p>A <a href="http://www.w3.org/XML/Test/">Test Suite</a> is maintained to help assessing conformance to this specification.</p></div><div class="toc"> <h2><a name="contents" id="contents" />Table of Contents</h2><p class="toc">1 <a href="#sec-intro">Introduction</a><br />     1.1 <a href="#sec-origin-goals">Origin and Goals</a><br />     1.2 <a href="#sec-terminology">Terminology</a><br />     1.3 <a href="#sec-xml11">Rationale and list of changes for XML 1.1</a><br /> 2 <a href="#sec-documents">Documents</a><br />     2.1 <a href="#sec-well-formed">Well-Formed XML Documents</a><br />     2.2 <a href="#charsets">Characters</a><br />     2.3 <a href="#sec-common-syn">Common Syntactic Constructs</a><br />     2.4 <a href="#syntax">Character Data and Markup</a><br />     2.5 <a href="#sec-comments">Comments</a><br />     2.6 <a href="#sec-pi">Processing Instructions</a><br />     2.7 <a href="#sec-cdata-sect">CDATA Sections</a><br />     2.8 <a href="#sec-prolog-dtd">Prolog and Document Type Declaration</a><br />     2.9 <a href="#sec-rmd">Standalone Document Declaration</a><br />     2.10 <a href="#sec-white-space">White Space Handling</a><br />     2.11 <a href="#sec-line-ends">End-of-Line Handling</a><br />     2.12 <a href="#sec-lang-tag">Language Identification</a><br />     2.13 <a href="#sec-normalization-checking">Normalization Checking</a><br /> 3 <a href="#sec-logical-struct">Logical Structures</a><br />     3.1 <a href="#sec-starttags">Start-Tags, End-Tags, and Empty-Element Tags</a><br />     3.2 <a href="#elemdecls">Element Type Declarations</a><br />         3.2.1 <a href="#sec-element-content">Element Content</a><br />         3.2.2 <a href="#sec-mixed-content">Mixed Content</a><br />     3.3 <a href="#attdecls">Attribute-List Declarations</a><br />         3.3.1 <a href="#sec-attribute-types">Attribute Types</a><br />         3.3.2 <a href="#sec-attr-defaults">Attribute Defaults</a><br />         3.3.3 <a href="#AVNormalize">Attribute-Value Normalization</a><br />     3.4 <a href="#sec-condition-sect">Conditional Sections</a><br /> 4 <a href="#sec-physical-struct">Physical Structures</a><br />     4.1 <a href="#sec-references">Character and Entity References</a><br />     4.2 <a href="#sec-entity-decl">Entity Declarations</a><br />         4.2.1 <a href="#sec-internal-ent">Internal Entities</a><br />         4.2.2 <a href="#sec-external-ent">External Entities</a><br />     4.3 <a href="#TextEntities">Parsed Entities</a><br />         4.3.1 <a href="#sec-TextDecl">The Text Declaration</a><br />         4.3.2 <a href="#wf-entities">Well-Formed Parsed Entities</a><br />         4.3.3 <a href="#charencoding">Character Encoding in Entities</a><br />         4.3.4 <a href="#sec-version-info">Version Information in Entities</a><br />     4.4 <a href="#entproc">XML Processor Treatment of Entities and References</a><br />         4.4.1 <a href="#not-recognized">Not Recognized</a><br />         4.4.2 <a href="#included">Included</a><br />         4.4.3 <a href="#include-if-valid">Included If Validating</a><br />         4.4.4 <a href="#forbidden">Forbidden</a><br />         4.4.5 <a href="#inliteral">Included in Literal</a><br />         4.4.6 <a href="#notify">Notify</a><br />         4.4.7 <a href="#bypass">Bypassed</a><br />         4.4.8 <a href="#as-PE">Included as PE</a><br />         4.4.9 <a href="#error">Error</a><br />     4.5 <a href="#intern-replacement">Construction of Entity Replacement Text</a><br />     4.6 <a href="#sec-predefined-ent">Predefined Entities</a><br />     4.7 <a href="#Notations">Notation Declarations</a><br />     4.8 <a href="#sec-doc-entity">Document Entity</a><br /> 5 <a href="#sec-conformance">Conformance</a><br />     5.1 <a href="#proc-types">Validating and Non-Validating Processors</a><br />     5.2 <a href="#safe-behavior">Using XML Processors</a><br /> 6 <a href="#sec-notation">Notation</a><br /> </p> <h3><a name="appendices" id="appendices" />Appendices</h3><p class="toc">A <a href="#sec-bibliography">References</a><br />     A.1 <a href="#sec-existing-stds">Normative References</a><br />     A.2 <a href="#null">Other References</a><br /> B <a href="#sec-CharNorm">Definitions for Character Normalization</a><br /> C <a href="#sec-entexpand">Expansion of Entity and Character References</a> (Non-Normative)<br /> D <a href="#determinism">Deterministic Content Models</a> (Non-Normative)<br /> E <a href="#sec-guessing">Autodetection of Character Encodings</a> (Non-Normative)<br />     E.1 <a href="#sec-guessing-no-ext-info">Detection Without External Encoding Information</a><br />     E.2 <a href="#sec-guessing-with-ext-info">Priorities in the Presence of External Encoding Information</a><br /> F <a href="#sec-xml-wg">W3C XML Working Group</a> (Non-Normative)<br /> G <a href="#sec-core-wg">W3C XML Core Working Group</a> (Non-Normative)<br /> H <a href="#prod-notes">Production Notes</a> (Non-Normative)<br /> I <a href="#sec-suggested-names">Suggestions for XML Names</a> (Non-Normative)<br /> </p></div><hr /><div class="body"><div class="div1"> <h2><a name="sec-intro" id="sec-intro" />1 Introduction</h2><p>Extensible Markup Language, abbreviated XML, describes a class of data
+objects called <a title="XML Document" href="#dt-xml-doc">XML documents</a> and partially
+describes the behavior of computer programs which process them. XML is an
+application profile or restricted form of SGML, the Standard Generalized Markup
+Language <a href="#ISO8879">[ISO 8879]</a>. By construction, XML documents are conforming
+SGML documents.</p><p>XML documents are made up of storage units called <a title="Entity" href="#dt-entity">entities</a>,
+which contain either parsed or unparsed data. Parsed data is made up of <a title="Character" href="#dt-character">characters</a>, some of which form <a title="Character Data" href="#dt-chardata">character
+data</a>, and some of which form <a title="Markup" href="#dt-markup">markup</a>.
+Markup encodes a description of the document's storage layout and logical
+structure. XML provides a mechanism to impose constraints on the storage layout
+and logical structure.</p><p>[<a name="dt-xml-proc" id="dt-xml-proc" title="XML Processor">Definition</a>: A software module called
+an <b>XML processor</b> is used to read XML documents and provide access
+to their content and structure.] [<a name="dt-app" id="dt-app" title="Application">Definition</a>: It
+is assumed that an XML processor is doing its work on behalf of another module,
+called the <b>application</b>.] This specification describes
+the required behavior of an XML processor in terms of how it must read XML
+data and the information it must provide to the application.</p><div class="div2"> <h3><a name="sec-origin-goals" id="sec-origin-goals" />1.1 Origin and Goals</h3><p>XML was developed by an XML Working Group (originally known as the SGML
+Editorial Review Board) formed under the auspices of the World Wide Web Consortium
+(W3C) in 1996. It was chaired by Jon Bosak of Sun Microsystems with the active
+participation of an XML Special Interest Group (previously known as the SGML
+Working Group) also organized by the W3C. The membership of the XML Working
+Group is given in an appendix. Dan Connolly served as the Working Group's contact with
+the W3C.</p><p>The design goals for XML are:</p><ol type="1"><li><p>XML shall be straightforwardly usable over the Internet.</p></li><li><p>XML shall support a wide variety of applications.</p></li><li><p>XML shall be compatible with SGML.</p></li><li><p>It shall be easy to write programs which process XML documents.</p></li><li><p>The number of optional features in XML is to be kept to the absolute
+minimum, ideally zero.</p></li><li><p>XML documents should be human-legible and reasonably clear.</p></li><li><p>The XML design should be prepared quickly.</p></li><li><p>The design of XML shall be formal and concise.</p></li><li><p>XML documents shall be easy to create.</p></li><li><p>Terseness in XML markup is of minimal importance.</p></li></ol><p>This specification, together with associated standards (Unicode
+<a href="#Unicode">[Unicode]</a> and ISO/IEC 10646 <a href="#ISO10646">[ISO/IEC 10646]</a>
+for characters, Internet RFC 3066 <a href="#RFC1766">[IETF RFC 3066]</a> for
+language identification tags, ISO 639 <a href="#ISO639">[ISO 639]</a>
+for language name codes, and ISO 3166 <a href="#ISO3166">[ISO 3166]</a> for
+country name codes), provides all the information necessary to
+understand XML Version 1.1 and construct computer
+programs to process it.</p><p>This version of the XML specification may be distributed freely, as long as
+all text and legal notices remain intact.</p></div><div class="div2"> <h3><a name="sec-terminology" id="sec-terminology" />1.2 Terminology</h3><p>The terminology used to describe XML documents is defined in the body of
+this specification. <span class="mustard">The key words <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">SHALL</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">SHALL NOT</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD NOT</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">RECOMMENDED</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>, and <em class="rfc2119" title="Keyword in RFC 2119 context">OPTIONAL</em>, when <em class="rfc2119" title="Keyword in RFC 2119 context">EMPHASIZED</em>, are to be interpreted as described in <a href="#rfc2119">[IETF RFC 2119]</a>. In addition, </span>the terms defined in the following list are used in building
+those definitions and in describing the actions of an XML processor:</p><dl><dt class="label">error</dt><dd><p>[<a name="dt-error" id="dt-error" title="Error">Definition</a>: A violation of the rules of this specification;
+results are undefined. <span class="mustard">Unless otherwise specified, failure to observe a prescription of this specification indicated by one of the keywords <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em>, <em class="rfc2119" title="Keyword in RFC 2119 context">SHALL</em> and <em class="rfc2119" title="Keyword in RFC 2119 context">SHALL NOT</em> is an error.</span>  Conforming software <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> detect and report an error
+and <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> recover from it.]</p></dd><dt class="label">fatal error</dt><dd><p>[<a name="dt-fatal" id="dt-fatal" title="Fatal Error">Definition</a>: An error which a conforming <a title="XML Processor" href="#dt-xml-proc">XML processor</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> detect and report to the application.
+After encountering a fatal error, the processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> continue processing the
+data to search for further errors and <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> report such errors to the application.
+In order to support correction of errors, the processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> make unprocessed
+data from the document (with intermingled character data and markup) available
+to the application. Once a fatal error is detected, however, the processor
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> continue normal processing (i.e., it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> continue to pass character
+data and information about the document's logical structure to the application
+in the normal way).]</p></dd><dt class="label">at user option</dt><dd><p>[<a name="dt-atuseroption" id="dt-atuseroption" title="At user option">Definition</a>: Conforming software
+<em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> or <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> (depending on the modal verb in the sentence) behave as described;
+if it does, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> provide users a means to enable or disable the behavior
+described.]</p></dd><dt class="label">validity constraint</dt><dd><p>[<a name="dt-vc" id="dt-vc" title="Validity constraint">Definition</a>: A rule which applies to
+all <a title="Validity" href="#dt-valid">valid</a> XML documents. Violations of validity
+constraints are errors; they <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>, at user option, be reported by <a title="Validating Processor" href="#dt-validating">validating XML processors</a>.]</p></dd><dt class="label">well-formedness constraint</dt><dd><p>[<a name="dt-wfc" id="dt-wfc" title="Well-formedness constraint">Definition</a>: A rule which applies
+to all <a title="Well-Formed" href="#dt-wellformed">well-formed</a> XML documents. Violations
+of well-formedness constraints are <a title="Fatal Error" href="#dt-fatal">fatal errors</a>.]</p></dd><dt class="label">match</dt><dd><p>[<a name="dt-match" id="dt-match" title="match">Definition</a>: (Of strings or names:) Two strings
+or names being compared <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be identical. Characters with multiple possible
+representations in Unicode (e.g. characters with both precomposed and
+base+diacritic forms) match only if they have the same representation in both
+strings. No
+case folding is performed. (Of strings and rules in the grammar:) A string
+matches a grammatical production if it belongs to the language generated by
+that production. (Of content and content models:) An element matches its declaration
+when it conforms in the fashion described in the constraint <b>[VC: <a href="#elementvalid">Element Valid</a>]</b>.]</p></dd><dt class="label">for compatibility</dt><dd><p>[<a name="dt-compat" id="dt-compat" title="For Compatibility">Definition</a>: Marks
+a sentence describing a feature of XML included solely to ensure
+that XML remains compatible with SGML.]</p></dd><dt class="label">for interoperability</dt><dd><p>[<a name="dt-interop" id="dt-interop" title="For interoperability">Definition</a>: Marks
+a sentence describing a non-binding recommendation included to increase
+the chances that XML documents can be processed by the existing installed
+base of SGML processors which predate the WebSGML Adaptations Annex to ISO 8879.]</p></dd></dl><p></p></div><div class="div2"> <h3><a name="sec-xml11" id="sec-xml11" />1.3 Rationale and list of changes for XML 1.1</h3><p>The W3C's XML 1.0 Recommendation was first issued in 1998, and
+despite the issuance of many errata culminating in a Third Edition
+of 2004, has remained (by intention) unchanged with respect to what
+is well-formed XML and what is not. This stability has been
+extremely useful for interoperability. However, the Unicode
+Standard on which XML 1.0 relies for character specifications has
+not remained static, evolving from version 2.0 to version 4.0 and
+beyond. Characters not present in Unicode 2.0 may already be used
+in XML 1.0 character data. However, they are not allowed in XML
+names such as element type names, attribute names, enumerated
+attribute values, processing instruction targets, and so on. In
+addition, some characters that should have been permitted in XML
+names were not, due to oversights and inconsistencies in Unicode
+2.0.</p><p>The overall philosophy of names has changed since XML 1.0.
+Whereas XML 1.0 provided a rigid definition of names, wherein
+everything that was not permitted was forbidden, XML 1.1 names are
+designed so that everything that is not forbidden (for a specific
+reason) is permitted. Since Unicode will continue to grow past
+version 4.0, further changes to XML can be avoided by allowing
+almost any character, including those not yet assigned, in
+names.</p><p>In addition, XML 1.0 attempts to adapt to the line-end
+conventions of various modern operating systems, but discriminates
+against the conventions used on IBM and IBM-compatible mainframes.
+As a result, XML documents on mainframes are not plain text files
+according to the local conventions. XML 1.0 documents generated on
+mainframes must either violate the local line-end conventions, or
+employ otherwise unnecessary translation phases before parsing and
+after generation. Allowing straightforward interoperability is
+particularly important when data stores are shared between
+mainframe and non-mainframe systems (as opposed to being copied
+from one to the other). Therefore XML 1.1 adds NEL (#x85) to the
+list of line-end characters. For completeness, the Unicode line
+separator character, #x2028, is also supported.
+</p><p>Finally, there is considerable demand to define a standard representation
+of arbitrary Unicode characters in XML documents. Therefore, XML 1.1
+allows the use of character references to the control characters #x1 through
+#x1F, most of which are forbidden in XML 1.0. For reasons of robustness,
+however, these characters still cannot be used directly in documents. In
+order to improve the robustness of character encoding detection, the additional
+control characters #x7F through #x9F, which were freely allowed in XML 1.0
+documents, now must also appear only as character references. (Whitespace
+characters are of course exempt.) The minor sacrifice of backward compatibility
+is considered not significant. Due to potential problems with APIs,
+#x0 is still forbidden both directly and as a character reference.
+</p><p>Finally, XML 1.1 defines a set of constraints called "full
+normalization" on XML documents, which document creators
+<em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> adhere to, and document processors
+<em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> verify.  Using fully normalized documents
+ensures that identity comparisons of names, attribute values, and
+character content can be made correctly by simple binary comparison of
+Unicode strings.</p><p>A new XML version, rather than a set of errata to XML 1.0, is
+being created because the changes affect the definition of
+well-formed documents. XML 1.0 processors must continue to reject
+documents that contain new characters in XML names, new line-end
+conventions, and references to control characters. The distinction between XML 1.0 and XML 1.1 documents
+is indicated by the version number information in the XML
+declaration at the start of each document.
+</p></div></div><div class="div1"> <h2><a name="sec-documents" id="sec-documents" />2 Documents</h2><p>[<a name="dt-xml-doc" id="dt-xml-doc" title="XML Document">Definition</a>:  A data object is an <b>XML
+document</b> if it is <a title="Well-Formed" href="#dt-wellformed">well-formed</a>,
+as defined in this specification. A well-formed XML document <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> in addition
+be <a title="Validity" href="#dt-valid">valid</a> if it meets certain further constraints.]</p><p>Each XML document has both a logical and a physical structure. Physically,
+the document is composed of units called <a title="Entity" href="#dt-entity">entities</a>.
+An entity <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> <a title="Entity Reference" href="#dt-entref">refer</a> to other entities to
+cause their inclusion in the document. A document begins in a "root"
+or <a title="Document Entity" href="#dt-docent">document entity</a>. Logically, the document
+is composed of declarations, elements, comments, character references, and
+processing instructions, all of which are indicated in the document by explicit
+markup. The logical and physical structures <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> nest properly, as described
+in <a href="#wf-entities"><b>4.3.2 Well-Formed Parsed Entities</b></a>.</p><div class="div2"> <h3><a name="sec-well-formed" id="sec-well-formed" />2.1 Well-Formed XML Documents</h3><p>[<a name="dt-wellformed" id="dt-wellformed" title="Well-Formed">Definition</a>:  A textual object is a <b>well-formed</b>
+XML document if:]</p><ol type="1"><li><p>Taken as a whole, it matches the production labeled <a href="#NT-document">document</a>.</p></li><li><p>It meets all the well-formedness constraints given in this specification.</p></li><li><p>Each of the <a title="Text Entity" href="#dt-parsedent">parsed entities</a>
+which is referenced directly or indirectly within the document is <a
+title="Well-Formed"
+href="#dt-wellformed">well-formed</a>.</p></li></ol> <h5><a
+name="document" id="document" />Document</h5><table class="scrap"
+summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-document"
+id="NT-document"
+/>[1]   </td><td><code>document</code></td><td>   ::=   </td><td><code><a
+href="#NT-prolog">prolog</a> <a href="#NT-element">element</a> <a
+href="#NT-Misc">Misc</a>* - <a href="#NT-Char">Char</a>* <a
+href="#NT-RestrictedChar">RestrictedChar</a> <a href="#NT-Char">Char</a>*</code></td></tr></tbody></table><p>Matching the <a href="#NT-document">document</a> production implies that:</p><ol type="1"><li><p>It contains one or more <a title="Element" href="#dt-element">elements</a>.</p></li><li><p>[<a name="dt-root" id="dt-root" title="Root Element">Definition</a>: There is exactly one element,
+called the <b>root</b>, or document element, no part of which appears
+in the <a title="Content" href="#dt-content">content</a> of any other element.] For
+all other elements, if the <a title="Start-Tag" href="#dt-stag">start-tag</a> is in
+the content of another element, the <a title="End Tag" href="#dt-etag">end-tag</a>
+is in the content of the same element. More simply stated, the elements,
+delimited by start- and end-tags, nest properly within each other.</p></li></ol><p>[<a name="dt-parentchild" id="dt-parentchild" title="Parent/Child">Definition</a>: As a consequence of this,
+for each non-root element <code>C</code> in the document, there is one other element <code>P</code>
+in the document such that <code>C</code> is in the content of <code>P</code>, but
+is not in the content of any other element that is in the content of <code>P</code>. <code>P</code>
+is referred to as the <b>parent</b> of <code>C</code>, and <code>C</code> as
+a <b>child</b> of <code>P</code>.]</p></div><div class="div2"> <h3><a name="charsets" id="charsets" />2.2 Characters</h3><p>[<a name="dt-text" id="dt-text" title="Text">Definition</a>: A parsed entity contains <b>text</b>,
+a sequence of <a title="Character" href="#dt-character">characters</a>, which may
+represent markup or character data.] [<a name="dt-character" id="dt-character" title="Character">Definition</a>: A <b>character</b>
+is an atomic unit of text as specified by <span>ISO/IEC 10646 <a href="#ISO10646">[ISO/IEC 10646]</a></span>. Legal characters are tab, carriage
+return, line feed, and the legal characters
+of Unicode and ISO/IEC 10646. The
+versions of these standards cited in <a href="#sec-existing-stds"><b>A.1 Normative References</b></a> were
+current at the time this document was prepared. New characters may be added
+to these standards by amendments or new editions. Consequently, XML processors
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> accept any character in the range specified for <a href="#NT-Char">Char</a>.]</p> <h5><a name="char32" id="char32" />Character Range</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-Char" id="NT-Char" />[2]   </td><td><code>Char</code></td><td>   ::=   </td><td><code>[#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]</code></td><td><i>/* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */</i></td></tr><tr valign="baseline"><td><a name="NT-RestrictedChar" id="NT-RestrictedChar" />[2a]   </td><td><code>RestrictedChar</code></td><td>   ::=   </td><td><code>[#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]</code></td></tr></tbody></table><p>The mechanism for encoding character code points into bit patterns <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>
+vary from entity to entity. All XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> accept the UTF-8 and UTF-16
+encodings of <span> Unicode
+<a href="#Unicode">[Unicode]</a></span>;
+the mechanisms for signaling which of the two is in use,
+or for bringing other encodings into play, are discussed later, in <a href="#charencoding"><b>4.3.3 Character Encoding in Entities</b></a>.</p><div class="note"><p class="prefix"><b>Note:</b></p><p>Document authors are encouraged to avoid
+"compatibility characters", as defined
+in Unicode <a href="#Unicode">[Unicode]</a>.
+The characters defined in the following ranges are also
+discouraged. They are either control characters or permanently undefined Unicode
+characters:</p><div class="exampleInner"><pre>
+[#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF],
+[#1FFFE-#x1FFFF], [#2FFFE-#x2FFFF], [#3FFFE-#x3FFFF],
+[#4FFFE-#x4FFFF], [#5FFFE-#x5FFFF], [#6FFFE-#x6FFFF],
+[#7FFFE-#x7FFFF], [#8FFFE-#x8FFFF], [#9FFFE-#x9FFFF],
+[#AFFFE-#xAFFFF], [#BFFFE-#xBFFFF], [#CFFFE-#xCFFFF],
+[#DFFFE-#xDFFFF], [#EFFFE-#xEFFFF], [#FFFFE-#xFFFFF],
+[#10FFFE-#x10FFFF].</pre></div></div></div><div class="div2"> <h3><a name="sec-common-syn" id="sec-common-syn" />2.3 Common Syntactic Constructs</h3><p>This section defines some symbols used widely in the grammar.</p><p><a href="#NT-S">S</a> (white space) consists of one or more space (#x20)
+characters, carriage returns, line feeds, or tabs.</p> <h5><a name="white" id="white" />White Space</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-S" id="NT-S" />[3]   </td><td><code>S</code></td><td>   ::=   </td><td><code>(#x20 | #x9 | #xD | #xA)+</code></td></tr></tbody></table><div class="note"><p class="prefix"><b>Note:</b></p><p>The presence of #xD in the above production is
+maintained purely for backward compatibility with the
+<a href="http://www.w3.org/TR/1998/REC-xml-19980210">First Edition</a>.
+As explained in <a href="#sec-line-ends"><b>2.11 End-of-Line Handling</b></a>,
+all #xD characters literally present in an XML document
+are either removed or replaced by #xA characters before
+any other processing is done. The only way to get a #xD character to match this production is to
+use a character reference in an entity value literal.</p></div><p>[<a name="dt-name" id="dt-name" title="Name">Definition</a>: A <b>Name</b> is a token beginning
+with a letter or one of a few punctuation characters, and continuing with
+letters, digits, hyphens, underscores, colons, or full stops, together known
+as name characters.] Names beginning with the string "<code>xml</code>",
+or <span>with</span> any string which would match <code>(('X'|'x') ('M'|'m') ('L'|'l'))</code>,
+are reserved for standardization in this or future versions of this specification.</p><div class="note"><p class="prefix"><b>Note:</b></p><p>The
+Namespaces in XML Recommendation <a href="#xml-names">[XML Names]</a> assigns a meaning
+to names containing colon characters. Therefore, authors should not use the
+colon in XML names except for namespace purposes, but XML processors must
+accept the colon as a name character.</p></div><p>An <a href="#NT-Nmtoken">Nmtoken</a> (name token) is any mixture of name
+characters.</p><p>The first character of a Name <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be a NameStartChar, and any
+other characters <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be NameChars; this mechanism is used to
+prevent names from beginning with European (ASCII) digits or with
+basic combining characters. Almost all characters are permitted in
+names, except those which either are or reasonably could be used as
+delimiters. The intention is to be inclusive rather than exclusive,
+so that writing systems not yet encoded in Unicode can be used in
+XML names. See <a href="#sec-suggested-names"><b>I Suggestions for XML Names</b></a> for suggestions on the creation of
+names.</p><p>Document authors are encouraged to use names which are
+meaningful words or combinations of words in natural languages, and
+to avoid symbolic or white space characters in names. Note that
+COLON, HYPHEN-MINUS, FULL STOP (period), LOW LINE (underscore), and
+MIDDLE DOT are explicitly permitted.</p><p>The ASCII symbols and punctuation marks, along with a fairly
+large group of Unicode symbol characters, are excluded from names
+because they are more useful as delimiters in contexts where XML
+names are used outside XML documents; providing this group gives
+those contexts hard guarantees about what <em>cannot</em> be part of
+an XML name. The character #x037E, GREEK QUESTION MARK, is excluded
+because when normalized it becomes a semicolon, which could change
+the meaning of entity references.</p> <h5><a name="IDABN1S" id="IDABN1S" />Names and Tokens</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-NameStartChar" id="NT-NameStartChar" />[4]   </td><td><code>NameStartChar</code></td><td>   ::=   </td><td><code>":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-NameChar" id="NT-NameChar" />[4a]   </td><td><code>NameChar</code></td><td>   ::=   </td><td><code><a href="#NT-NameStartChar">NameStartChar</a> | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-Name" id="NT-Name" />[5]   </td><td><code>Name</code></td><td>   ::=   </td><td><code><a href="#NT-NameStartChar">NameStartChar</a> (<a href="#NT-NameChar">NameChar</a>)*</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-Names" id="NT-Names" />[6]   </td><td><code>Names</code></td><td>   ::=   </td><td><code><a href="#NT-Name">Name</a> (#x20 <a href="#NT-Name">Name</a>)*</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-Nmtoken" id="NT-Nmtoken" />[7]   </td><td><code>Nmtoken</code></td><td>   ::=   </td><td><code>(<a href="#NT-NameChar">NameChar</a>)+</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-Nmtokens" id="NT-Nmtokens" />[8]   </td><td><code>Nmtokens</code></td><td>   ::=   </td><td><code><a href="#NT-Nmtoken">Nmtoken</a> (#x20 <a href="#NT-Nmtoken">Nmtoken</a>)*</code></td></tr></tbody></table><div class="note"><p class="prefix"><b>Note:</b></p><p>The <a href="#NT-Names">Names</a>
+and <a href="#NT-Nmtokens">Nmtokens</a> productions are used to define the validity
+of tokenized attribute values after normalization (see <a href="#sec-attribute-types"><b>3.3.1 Attribute Types</b></a>).</p></div><p>Literal data is any quoted string not containing the quotation mark used
+as a delimiter for that string. Literals are used for specifying the content
+of internal entities (<a href="#NT-EntityValue">EntityValue</a>), the values
+of attributes (<a href="#NT-AttValue">AttValue</a>), and external identifiers
+(<a href="#NT-SystemLiteral">SystemLiteral</a>). Note that a <a href="#NT-SystemLiteral">SystemLiteral</a>
+can be parsed without scanning for markup.</p> <h5><a name="IDAFR1S" id="IDAFR1S" />Literals</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-EntityValue" id="NT-EntityValue" />[9]   </td><td><code>EntityValue</code></td><td>   ::=   </td><td><code>'"' ([^%&amp;"] | <a href="#NT-PEReference">PEReference</a>
+| <a href="#NT-Reference">Reference</a>)* '"' </code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>|  "'" ([^%&amp;'] | <a href="#NT-PEReference">PEReference</a> | <a href="#NT-Reference">Reference</a>)* "'"</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-AttValue" id="NT-AttValue" />[10]   </td><td><code>AttValue</code></td><td>   ::=   </td><td><code>'"' ([^&lt;&amp;"] | <a href="#NT-Reference">Reference</a>)*
+'"' </code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>|  "'" ([^&lt;&amp;'] | <a href="#NT-Reference">Reference</a>)*
+"'"</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-SystemLiteral" id="NT-SystemLiteral" />[11]   </td><td><code>SystemLiteral</code></td><td>   ::=   </td><td><code>('"' [^"]* '"') | ("'" [^']* "'") </code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-PubidLiteral" id="NT-PubidLiteral" />[12]   </td><td><code>PubidLiteral</code></td><td>   ::=   </td><td><code>'"' <a href="#NT-PubidChar">PubidChar</a>* '"'
+| "'" (<a href="#NT-PubidChar">PubidChar</a> - "'")* "'"</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-PubidChar" id="NT-PubidChar" />[13]   </td><td><code>PubidChar</code></td><td>   ::=   </td><td><code>#x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]</code></td></tr></tbody></table><div class="note"><p class="prefix"><b>Note:</b></p><p>Although
+the <a href="#NT-EntityValue">EntityValue</a> production allows the definition
+of a general entity consisting of a single explicit <code>&lt;</code> in the literal
+(e.g., <code>&lt;!ENTITY mylt "&lt;"&gt;</code>), it is strongly advised to avoid
+this practice since any reference to that entity will cause a well-formedness
+error.</p></div></div><div class="div2"> <h3><a name="syntax" id="syntax" />2.4 Character Data and Markup</h3><p><a title="Text" href="#dt-text">Text</a> consists of intermingled <a title="Character Data" href="#dt-chardata">character data</a> and markup. [<a name="dt-markup" id="dt-markup" title="Markup">Definition</a>: <b>Markup</b> takes the form of <a title="Start-Tag" href="#dt-stag">start-tags</a>, <a title="End Tag" href="#dt-etag">end-tags</a>, <a title="Empty" href="#dt-empty">empty-element tags</a>, <a title="Entity Reference" href="#dt-entref">entity references</a>, <a title="Character Reference" href="#dt-charref">character
+references</a>, <a title="Comment" href="#dt-comment">comments</a>, <a title="CDATA Section" href="#dt-cdsection">CDATA section</a> delimiters, <a title="Document Type Declaration" href="#dt-doctype">document
+type declarations</a>, <a title="Processing instruction" href="#dt-pi">processing instructions</a>, <a href="#NT-XMLDecl">XML declarations</a>, <a href="#NT-TextDecl">text declarations</a>,
+and any white space that is at the top level of the document entity (that
+is, outside the document element and not inside any other markup).]</p><p>[<a name="dt-chardata" id="dt-chardata" title="Character Data">Definition</a>: All text that is not markup
+constitutes the <b>character data</b> of the document.]</p><p>The ampersand character (&amp;) and the left angle bracket (&lt;) <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> appear
+in their literal form<span class="mustard">, except</span> when used as markup delimiters, or
+within a <a title="Comment" href="#dt-comment">comment</a>, a <a title="Processing instruction" href="#dt-pi">processing
+instruction</a>, or a <a title="CDATA Section" href="#dt-cdsection">CDATA section</a>.
+If they are needed elsewhere, they <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be <a title="escape" href="#dt-escape">escaped</a>
+using either <a title="Character Reference" href="#dt-charref">numeric character references</a>
+or the strings "<code>&amp;amp;</code>" and "<code>&amp;lt;</code>"
+respectively. The right angle bracket (&gt;) <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be represented using the string "<code>&amp;gt;</code>",
+and <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>, <a title="For Compatibility" href="#dt-compat">for compatibility</a>, be escaped
+using <span>either</span> "<code>&amp;gt;</code>" or a character reference when it
+appears in the string "<code>]]&gt;</code>" in content, when
+that string is not marking the end of a <a title="CDATA Section" href="#dt-cdsection">CDATA
+section</a>.</p><p>In the content of elements, character data is any string of characters
+which does not contain the start-delimiter of any markup or the
+CDATA-section-close delimiter,
+"<code>]]&gt;</code>".
+In a CDATA section,
+character data is any string of characters not including the CDATA-section-close
+delimiter.</p><p>To allow attribute values to contain both single and double quotes, the
+apostrophe or single-quote character (') <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be represented as "<code>&amp;apos;</code>",
+and the double-quote character (") as "<code>&amp;quot;</code>".</p> <h5><a name="IDASZ1S" id="IDASZ1S" />Character Data</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-CharData" id="NT-CharData" />[14]   </td><td><code>CharData</code></td><td>   ::=   </td><td><code>[^&lt;&amp;]* - ([^&lt;&amp;]* ']]&gt;' [^&lt;&amp;]*)</code></td></tr></tbody></table></div><div class="div2"> <h3><a name="sec-comments" id="sec-comments" />2.5 Comments</h3><p>[<a name="dt-comment" id="dt-comment" title="Comment">Definition</a>: <b>Comments</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> appear
+anywhere in a document outside other <a title="Markup" href="#dt-markup">markup</a>;
+in addition, they <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> appear within the document type declaration at places
+allowed by the grammar. They are not part of the document's <a title="Character Data" href="#dt-chardata">character
+data</a>; an XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>, but need not, make it possible for an
+application to retrieve the text of comments. <a title="For Compatibility" href="#dt-compat">For
+compatibility</a>, the string "<code>--</code>" (double-hyphen)
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> occur within comments.] Parameter
+entity references <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> be</span> recognized within comments.</p> <h5><a name="IDAL11S" id="IDAL11S" />Comments</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-Comment" id="NT-Comment" />[15]   </td><td><code>Comment</code></td><td>   ::=   </td><td><code>'&lt;!--' ((<a href="#NT-Char">Char</a> - '-') | ('-'
+(<a href="#NT-Char">Char</a> - '-')))* '--&gt;'</code></td></tr></tbody></table><p>An example of a comment:</p><div class="exampleInner"><pre>&lt;!-- declarations for &lt;head&gt; &amp; &lt;body&gt; --&gt;</pre></div><p>Note
+that the grammar does not allow a comment ending in <code>---&gt;</code>. The
+following example is <em>not</em> well-formed.</p><div class="exampleInner"><pre>&lt;!-- B+, B, or B---&gt;</pre></div></div><div class="div2"> <h3><a name="sec-pi" id="sec-pi" />2.6 Processing Instructions</h3><p>[<a name="dt-pi" id="dt-pi" title="Processing instruction">Definition</a>: <b>Processing instructions</b>
+(PIs) allow documents to contain instructions for applications.]</p> <h5><a name="IDAD31S" id="IDAD31S" />Processing Instructions</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-PI" id="NT-PI" />[16]   </td><td><code>PI</code></td><td>   ::=   </td><td><code>'&lt;?' <a href="#NT-PITarget">PITarget</a> (<a href="#NT-S">S</a>
+(<a href="#NT-Char">Char</a>* - (<a href="#NT-Char">Char</a>* '?&gt;' <a href="#NT-Char">Char</a>*)))? '?&gt;'</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-PITarget" id="NT-PITarget" />[17]   </td><td><code>PITarget</code></td><td>   ::=   </td><td><code><a href="#NT-Name">Name</a> - (('X' | 'x') ('M' |
+'m') ('L' | 'l'))</code></td></tr></tbody></table><p>PIs are not part of the document's <a title="Character Data" href="#dt-chardata">character
+data</a>, but <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be passed through to the application. The PI begins
+with a target (<a href="#NT-PITarget">PITarget</a>) used to identify the application
+to which the instruction is directed. The target names "<code>XML</code>", "<code>xml</code>",
+and so on are reserved for standardization in this or future versions of this
+specification. The XML <a title="Notation" href="#dt-notation">Notation</a> mechanism
+<em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be used for formal declaration of PI targets. Parameter
+entity references <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> be</span> recognized within processing instructions.</p></div><div class="div2"> <h3><a name="sec-cdata-sect" id="sec-cdata-sect" />2.7 CDATA Sections</h3><p>[<a name="dt-cdsection" id="dt-cdsection" title="CDATA Section">Definition</a>: <b>CDATA sections</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> occur anywhere character data may occur; they are used to escape blocks
+of text containing characters which would otherwise be recognized as markup.
+CDATA sections begin with the string "<code>&lt;![CDATA[</code>"
+and end with the string "<code>]]&gt;</code>":]</p> <h5><a name="IDAOA2S" id="IDAOA2S" />CDATA Sections</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-CDSect" id="NT-CDSect" />[18]   </td><td><code>CDSect</code></td><td>   ::=   </td><td><code><a href="#NT-CDStart">CDStart</a> <a href="#NT-CData">CData</a> <a href="#NT-CDEnd">CDEnd</a></code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-CDStart" id="NT-CDStart" />[19]   </td><td><code>CDStart</code></td><td>   ::=   </td><td><code>'&lt;![CDATA['</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-CData" id="NT-CData" />[20]   </td><td><code>CData</code></td><td>   ::=   </td><td><code>(<a href="#NT-Char">Char</a>* - (<a href="#NT-Char">Char</a>*
+']]&gt;' <a href="#NT-Char">Char</a>*)) </code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-CDEnd" id="NT-CDEnd" />[21]   </td><td><code>CDEnd</code></td><td>   ::=   </td><td><code>']]&gt;'</code></td></tr></tbody></table><p>Within a CDATA section, only the <a href="#NT-CDEnd">CDEnd</a> string is
+recognized as markup, so that left angle brackets and ampersands may occur
+in their literal form; they need not (and cannot) be escaped using "<code>&amp;lt;</code>"
+and "<code>&amp;amp;</code>". CDATA sections cannot nest.</p><p>An example of a CDATA section, in which "<code>&lt;greeting&gt;</code>"
+and "<code>&lt;/greeting&gt;</code>" are recognized as <a title="Character Data" href="#dt-chardata">character data</a>, not <a title="Markup" href="#dt-markup">markup</a>:</p><div class="exampleInner"><pre>&lt;![CDATA[&lt;greeting&gt;Hello, world!&lt;/greeting&gt;]]&gt; </pre></div></div><div class="div2"> <h3><a name="sec-prolog-dtd" id="sec-prolog-dtd" />2.8 Prolog and Document Type Declaration</h3><p>[<a name="dt-xmldecl" id="dt-xmldecl" title="XML Declaration">Definition</a>: XML 1.1 documents <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+begin with an <b>XML declaration</b> which specifies the version of
+XML being used.] For example, the following is a complete XML 1.1 document, <a title="Well-Formed" href="#dt-wellformed">well-formed</a> but not <a title="Validity" href="#dt-valid">valid</a>:</p><div class="exampleInner"><pre>&lt;?xml version="1.1"?&gt;
+&lt;greeting&gt;Hello, world!&lt;/greeting&gt; </pre></div><p>but the following is an XML 1.0 document because it
+does not have an XML declaration:</p><div class="exampleInner"><pre>&lt;greeting&gt;Hello, world!&lt;/greeting&gt;</pre></div><p>The function of the markup in an XML document is to describe its storage and
+logical structure and to associate <span>attribute
+name-value</span> pairs with its logical structures. XML provides a mechanism, the
+<a title="Document Type Declaration" href="#dt-doctype">document
+type declaration</a>, to define constraints on the logical structure
+and to support the use of predefined storage units. [<a name="dt-valid" id="dt-valid" title="Validity">Definition</a>: An XML document is <b>valid</b> if it has an associated
+document type declaration and if the document complies with the constraints
+expressed in it.]</p><p>The document type declaration <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> appear before the first <a title="Element" href="#dt-element">element</a>
+in the document.</p> <h5><a name="xmldoc" id="xmldoc" />Prolog</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-prolog" id="NT-prolog" />[22]   </td><td><code>prolog</code></td><td>   ::=   </td><td><code><a href="#NT-XMLDecl">XMLDecl</a> <a href="#NT-Misc">Misc</a>*
+(<a href="#NT-doctypedecl">doctypedecl</a> <a href="#NT-Misc">Misc</a>*)?</code></td></tr><tr valign="baseline"><td><a name="NT-XMLDecl" id="NT-XMLDecl" />[23]   </td><td><code>XMLDecl</code></td><td>   ::=   </td><td><code>'&lt;?xml' <a href="#NT-VersionInfo">VersionInfo</a> <a href="#NT-EncodingDecl">EncodingDecl</a>? <a href="#NT-SDDecl">SDDecl</a>? <a href="#NT-S">S</a>?'?&gt;'</code></td></tr><tr valign="baseline"><td><a name="NT-VersionInfo" id="NT-VersionInfo" />[24]   </td><td><code>VersionInfo</code></td><td>   ::=   </td><td><code><a href="#NT-S">S</a> 'version' <a href="#NT-Eq">Eq</a>
+("'" <a href="#NT-VersionNum">VersionNum</a> "'" | '"' <a href="#NT-VersionNum">VersionNum</a>
+'"')</code></td></tr><tr valign="baseline"><td><a name="NT-Eq" id="NT-Eq" />[25]   </td><td><code>Eq</code></td><td>   ::=   </td><td><code><a href="#NT-S">S</a>? '=' <a href="#NT-S">S</a>?</code></td></tr><tr valign="baseline"><td><a name="NT-VersionNum" id="NT-VersionNum" />[26]   </td><td><code>VersionNum</code></td><td>   ::=   </td><td><code>'1.1'</code></td></tr><tr valign="baseline"><td><a name="NT-Misc" id="NT-Misc" />[27]   </td><td><code>Misc</code></td><td>   ::=   </td><td><code><a href="#NT-Comment">Comment</a> | <a href="#NT-PI">PI</a>
+| <a href="#NT-S">S</a></code></td></tr></tbody></table><p>[<a name="dt-doctype" id="dt-doctype" title="Document Type Declaration">Definition</a>: The XML <b>document
+type declaration</b> contains or points to <a title="markup declaration" href="#dt-markupdecl">markup
+declarations</a> that provide a grammar for a class of documents. This
+grammar is known as a document type definition, or <b>DTD</b>. The document
+type declaration can point to an external subset (a special kind of <a title="External Entity" href="#dt-extent">external entity</a>) containing markup declarations,
+or can contain the markup declarations directly in an internal subset, or
+can do both. The DTD for a document consists of both subsets taken together.]</p><p>[<a name="dt-markupdecl" id="dt-markupdecl" title="markup declaration">Definition</a>:  A <b>markup declaration</b>
+is an <a title="Element Type declaration" href="#dt-eldecl">element type declaration</a>, an <a title="Attribute-List Declaration" href="#dt-attdecl">attribute-list declaration</a>, an <a title="entity declaration" href="#dt-entdecl">entity
+declaration</a>, or a <a title="Notation Declaration" href="#dt-notdecl">notation declaration</a>.]
+These declarations <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be contained in whole or in part within <a title="Parameter entity" href="#dt-PE">parameter
+entities</a>, as described in the well-formedness and validity constraints
+below. For further
+information, see <a href="#sec-physical-struct"><b>4 Physical Structures</b></a>.</p> <h5><a name="dtd" id="dtd" />Document Type Definition</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-doctypedecl" id="NT-doctypedecl" />[28]   </td><td><code>doctypedecl</code></td><td>   ::=   </td><td><code>'&lt;!DOCTYPE' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a>
+(<a href="#NT-S">S</a> <a href="#NT-ExternalID">ExternalID</a>)? <a href="#NT-S">S</a>?
+('[' <a href="#NT-intSubset">intSubset</a> ']' <a href="#NT-S">S</a>?)? '&gt;'</code></td><td><a href="#vc-roottype">[VC: Root Element Type]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#ExtSubset">[WFC: External Subset]</a></td></tr><tr valign="baseline"><td><a name="NT-DeclSep" id="NT-DeclSep" />[28a]   </td><td><code>DeclSep</code></td><td>   ::=   </td><td><code><a href="#NT-PEReference">PEReference</a> | <a href="#NT-S">S</a></code></td><td><a href="#PE-between-Decls">[WFC: PE Between Declarations]</a></td></tr><tr valign="baseline"><td><a name="NT-intSubset" id="NT-intSubset" />[28b]   </td><td><code>intSubset</code></td><td>   ::=   </td><td><code>(<a href="#NT-markupdecl">markupdecl</a> | <a href="#NT-DeclSep">DeclSep</a>)*</code></td></tr><tr valign="baseline"><td><a name="NT-markupdecl" id="NT-markupdecl" />[29]   </td><td><code>markupdecl</code></td><td>   ::=   </td><td><code><a href="#NT-elementdecl">elementdecl</a> | <a href="#NT-AttlistDecl">AttlistDecl</a> | <a href="#NT-EntityDecl">EntityDecl</a>
+| <a href="#NT-NotationDecl">NotationDecl</a> | <a href="#NT-PI">PI</a> | <a href="#NT-Comment">Comment</a></code></td><td><a href="#vc-PEinMarkupDecl">[VC: Proper Declaration/PE Nesting]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#wfc-PEinInternalSubset">[WFC: PEs in Internal Subset]</a></td></tr></tbody></table><p>Note
+that it is possible to construct a well-formed document containing a <a href="#NT-doctypedecl">doctypedecl</a>
+that neither points to an external subset nor contains an internal subset.</p><p>The markup declarations <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be made up in whole or in part of the <a title="Replacement Text" href="#dt-repltext">replacement text</a> of <a title="Parameter entity" href="#dt-PE">parameter
+entities</a>. The productions later in this specification for individual
+nonterminals (<a href="#NT-elementdecl">elementdecl</a>, <a href="#NT-AttlistDecl">AttlistDecl</a>,
+and so on) describe the declarations <em>after</em> all the parameter
+entities have been <a title="Include" href="#dt-include">included</a>.</p><p>Parameter
+entity references are recognized anywhere in the DTD (internal and external
+subsets and external parameter entities), except in literals, processing instructions,
+comments, and the contents of ignored conditional sections (see <a href="#sec-condition-sect"><b>3.4 Conditional Sections</b></a>).
+They are also recognized in entity value literals. The use of parameter entities
+in the internal subset is restricted as described below.</p><div class="constraint"><p class="prefix"><a name="vc-roottype" id="vc-roottype" /><b>Validity constraint: Root Element Type</b></p><p>The <a href="#NT-Name">Name</a>
+in the document type declaration <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the element type of the <a title="Root Element" href="#dt-root">root element</a>.</p></div><div class="constraint"><p class="prefix"><a name="vc-PEinMarkupDecl" id="vc-PEinMarkupDecl" /><b>Validity constraint: Proper Declaration/PE Nesting</b></p><p>Parameter-entity <a title="Replacement Text" href="#dt-repltext">replacement text</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be properly nested with markup declarations. That is to say, if either
+the first character or the last character of a markup declaration (<a href="#NT-markupdecl">markupdecl</a>
+above) is contained in the replacement text for a <a title="Parameter-entity reference" href="#dt-PERef">parameter-entity
+reference</a>, both <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be contained in the same replacement text.</p></div><div class="constraint"><p class="prefix"><a name="wfc-PEinInternalSubset" id="wfc-PEinInternalSubset" /><b>Well-formedness constraint: PEs in Internal Subset</b></p><p>In
+the internal DTD subset, <a title="Parameter-entity reference" href="#dt-PERef">parameter-entity references</a> <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> occur within markup declarations; they <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> occur where markup declarations can occur</span>.
+(This does not apply to references that occur in external parameter entities
+or to the external subset.)</p></div><div class="constraint"><p class="prefix"><a name="ExtSubset" id="ExtSubset" /><b>Well-formedness constraint: External Subset</b></p><p>The external subset, if any, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the production for <a href="#NT-extSubset">extSubset</a>.</p></div><div class="constraint"><p class="prefix"><a name="PE-between-Decls" id="PE-between-Decls" /><b>Well-formedness constraint: PE Between Declarations</b></p><p>The replacement text of a parameter entity reference
+in a <a href="#NT-DeclSep">DeclSep</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the production <a href="#NT-extSubsetDecl">extSubsetDecl</a>.</p></div><p>Like the internal subset, the external subset and any external parameter
+entities referenced
+in a <a href="#NT-DeclSep">DeclSep</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> consist of a series of
+complete markup declarations of the types allowed by the non-terminal symbol <a href="#NT-markupdecl">markupdecl</a>, interspersed with white space or <a title="Parameter-entity reference" href="#dt-PERef">parameter-entity references</a>. However, portions of
+the contents of the external subset or of these
+external parameter entities <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> conditionally be ignored by using the <a title="conditional section" href="#dt-cond-section">conditional section</a> construct; this is not
+allowed in the internal subset<span> but is
+allowed in external parameter entities referenced in the internal subset</span>.</p> <h5><a name="ext-Subset" id="ext-Subset" />External Subset</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-extSubset" id="NT-extSubset" />[30]   </td><td><code>extSubset</code></td><td>   ::=   </td><td><code><a href="#NT-TextDecl">TextDecl</a>? <a href="#NT-extSubsetDecl">extSubsetDecl</a></code></td></tr><tr valign="baseline"><td><a name="NT-extSubsetDecl" id="NT-extSubsetDecl" />[31]   </td><td><code>extSubsetDecl</code></td><td>   ::=   </td><td><code>( <a href="#NT-markupdecl">markupdecl</a> | <a href="#NT-conditionalSect">conditionalSect</a> | <a href="#NT-DeclSep">DeclSep</a>)*</code></td></tr></tbody></table><p>The external subset and external parameter entities also differ from the
+internal subset in that in them, <a title="Parameter-entity reference" href="#dt-PERef">parameter-entity
+references</a> are permitted <em>within</em> markup declarations,
+not only <em>between</em> markup declarations.</p><p>An example of an XML document with a document type declaration:</p><div class="exampleInner"><pre>&lt;?xml version="1.1"?&gt;
+&lt;!DOCTYPE greeting SYSTEM "hello.dtd"&gt;
+&lt;greeting&gt;Hello, world!&lt;/greeting&gt; </pre></div><p>The <a title="System Identifier" href="#dt-sysid">system identifier</a> "<code>hello.dtd</code>"
+gives the address (a URI reference) of a DTD for the document.</p><p>The declarations can also be given locally, as in this example:</p><div class="exampleInner"><pre>&lt;?xml version="1.1" encoding="UTF-8" ?&gt;
+&lt;!DOCTYPE greeting [
+&lt;!ELEMENT greeting (#PCDATA)&gt;
+]&gt;
+&lt;greeting&gt;Hello, world!&lt;/greeting&gt;</pre></div><p>If both the external and internal subsets are used, the internal subset
+<span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> considered to occur before the external subset. 
+This has the effect that entity and attribute-list declarations in the internal
+subset take precedence over those in the external subset.</p><p>XML 1.1 processors <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> accept XML 1.0
+documents as well. If a document is well-formed or valid XML 1.0, and provided it
+does not contain any control characters
+in the range [#x7F-#x9F] other than as character escapes, it may be
+made well-formed or valid XML 1.1 respectively simply by changing the
+version number.</p></div><div class="div2"> <h3><a name="sec-rmd" id="sec-rmd" />2.9 Standalone Document Declaration</h3><p>Markup declarations can affect the content of the document, as passed from
+an <a title="XML Processor" href="#dt-xml-proc">XML processor</a> to an application; examples
+are attribute defaults and entity declarations. The standalone document declaration,
+which <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> appear as a component of the XML declaration, signals whether or
+not there are such declarations which appear external to the <a title="Document Entity" href="#dt-docent">document
+entity</a>
+or in parameter entities. [<a name="dt-extmkpdecl" id="dt-extmkpdecl" title="External Markup Declaration">Definition</a>: An <b>external
+markup declaration</b> is defined as a markup declaration occurring in
+the external subset or in a parameter entity (external or internal, the latter
+being included because non-validating processors are not required to read
+them).]</p> <h5><a name="fulldtd" id="fulldtd" />Standalone Document Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-SDDecl" id="NT-SDDecl" />[32]   </td><td><code>SDDecl</code></td><td>   ::=   </td><td><code>#x20+ 'standalone' <a href="#NT-Eq">Eq</a>
+(("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"')) </code></td><td><a href="#vc-check-rmd">[VC: Standalone Document Declaration]</a></td></tr></tbody></table><p>In a standalone document declaration, the value "yes" indicates
+that there are no <a title="External Markup Declaration" href="#dt-extmkpdecl">external markup declarations</a> which
+affect the information passed from the XML processor to the application. The
+value "no" indicates that there are or may be such external
+markup declarations. Note that the standalone document declaration only denotes
+the presence of external <em>declarations</em>; the presence, in a document,
+of references to external <em>entities</em>, when those entities are internally
+declared, does not change its standalone status.</p><p>If there are no external markup declarations, the standalone document declaration
+has no meaning. If there are external markup declarations but there is no
+standalone document declaration, the value "no" is assumed.</p><p>Any XML document for which <code>standalone="no"</code> holds can be converted
+algorithmically to a standalone document, which may be desirable for some
+network delivery applications.</p><div class="constraint"><p class="prefix"><a name="vc-check-rmd" id="vc-check-rmd" /><b>Validity constraint: Standalone Document Declaration</b></p><p>The
+standalone document declaration <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> have the value "no" if
+any external markup declarations contain declarations of:</p><ul><li><p>attributes with <a title="Attribute Default" href="#dt-default">default</a> values,
+if elements to which these attributes apply appear in the document without
+specifications of values for these attributes, or</p></li><li><p>entities (other than <code>amp</code>,
+<code>lt</code>,
+<code>gt</code>,
+<code>apos</code>,
+<code>quot</code>), if <a title="Entity Reference" href="#dt-entref">references</a>
+to those entities appear in the document, or</p></li><li><p>attributes with
+tokenized types, where the
+attribute appears in the document with a value such that
+<a href="#AVNormalize"><cite>normalization</cite></a>
+will produce a different value from that which would be produced
+in the absence of the declaration, or</p></li><li><p>element types with <a title="Element content" href="#dt-elemcontent">element content</a>,
+if white space occurs directly within any instance of those types.</p></li></ul></div><p>An example XML declaration with a standalone document declaration:</p><div class="exampleInner"><pre>&lt;?xml version="1.1" standalone='yes'?&gt;</pre></div></div><div class="div2"> <h3><a name="sec-white-space" id="sec-white-space" />2.10 White Space Handling</h3><p>In editing XML documents, it is often convenient to use "white space"
+(spaces, tabs, and blank lines)
+to set apart the markup for greater readability. Such white space is typically
+not intended for inclusion in the delivered version of the document. On the
+other hand, "significant" white space that should be preserved
+in the delivered version is common, for example in poetry and source code.</p><p>An <a title="XML Processor" href="#dt-xml-proc">XML processor</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> always pass
+all characters in a document that are not markup through to the application.
+A <a title="Validating Processor" href="#dt-validating"> validating XML processor</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> also
+inform the application which of these characters constitute white space appearing
+in <a title="Element content" href="#dt-elemcontent">element content</a>.</p><p>A special <a title="Attribute" href="#dt-attr">attribute</a> named <code>xml:space</code> <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be attached to an element to signal an intention that in that element,
+white space should be preserved by applications. In valid documents, this
+attribute, like any other, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be <a title="Attribute-List Declaration" href="#dt-attdecl">declared</a>
+if it is used. When declared, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be given as an <a title="Enumerated Attribute&#xA;Values" href="#dt-enumerated">enumerated
+type</a> whose values
+are one or both of "default" and "preserve".
+For example:</p><div class="exampleInner"><pre>&lt;!ATTLIST poem  xml:space (default|preserve) 'preserve'&gt;
+&lt;!ATTLIST pre xml:space (preserve) #FIXED 'preserve'&gt;</pre></div><p>The value "default" signals that applications' default white-space
+processing modes are acceptable for this element; the value "preserve"
+indicates the intent that applications preserve all the white space. This
+declared intent is considered to apply to all elements within the content
+of the element where it is specified, unless <span>overridden</span> with
+another instance of the <code>xml:space</code> attribute. <span>This specification does not give meaning to any value of <code>xml:space</code> other than "default" and "preserve". It is an error for other values to be specified; the XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> report the error or <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> recover by ignoring the attribute specification or by reporting the (erroneous) value to the application. Applications may ignore or reject erroneous values.</span></p><p>The <a title="Root Element" href="#dt-root">root element</a> of any document is considered
+to have signaled no intentions as regards application space handling, unless
+it provides a value for this attribute or the attribute is declared with a
+default value.</p></div><div class="div2"> <h3><a name="sec-line-ends" id="sec-line-ends" />2.11 End-of-Line Handling</h3><p>XML <a title="Text Entity" href="#dt-parsedent">parsed entities</a> are often stored
+in computer files which, for editing convenience, are organized into lines.
+These lines are typically separated by some combination of the characters
+CARRIAGE RETURN (#xD) and LINE FEED (#xA).</p><p>To
+simplify the tasks of <a title="Application" href="#dt-app">applications</a>, the
+<span><a title="XML Processor" href="#dt-xml-proc">XML
+processor</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> behave as if it</span> normalized all line breaks in external parsed
+entities (including the document entity) on input, before parsing, by translating
+<span>all of the following to a single #xA character:</span></p><ol type="1"><li><p>the two-character sequence #xD #xA</p></li><li><p>the two-character sequence #xD #x85</p></li><li><p>the single character #x85</p></li><li><p>the single character #x2028</p></li><li><p>any #xD character that is not immediately followed by #xA or #x85.</p></li></ol><p>  The characters #x85 and #x2028 cannot be reliably recognized and
+translated until an entity's encoding declaration (if present) has
+been read.  Therefore, it is a fatal error to use them within the XML
+declaration or text declaration.
+</p></div><div class="div2"> <h3><a name="sec-lang-tag" id="sec-lang-tag" />2.12 Language Identification</h3><p>In document processing, it is often useful to identify the natural or formal
+language in which the content is written. A special <a title="Attribute" href="#dt-attr">attribute</a>
+named <code>xml:lang</code> <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be inserted in documents to specify the language
+used in the contents and attribute values of any element in an XML document.
+In valid documents, this attribute, like any other, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be <a title="Attribute-List Declaration" href="#dt-attdecl">declared</a>
+if it is used. The
+values of the attribute are language identifiers as defined by <a href="#RFC1766">[IETF RFC 3066]</a>, <cite>Tags
+for the Identification of Languages</cite>, or its successor<span>; in addition, the empty string <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be specified</span>.</p><p>(Productions 33 through 38 have been removed.)</p><p>For example:</p><div class="exampleInner"><pre>&lt;p xml:lang="en"&gt;The quick brown fox jumps over the lazy dog.&lt;/p&gt;
+&lt;p xml:lang="en-GB"&gt;What colour is it?&lt;/p&gt;
+&lt;p xml:lang="en-US"&gt;What color is it?&lt;/p&gt;
+&lt;sp who="Faust" desc='leise' xml:lang="de"&gt;
+&lt;l&gt;Habe nun, ach! Philosophie,&lt;/l&gt;
+&lt;l&gt;Juristerei, und Medizin&lt;/l&gt;
+&lt;l&gt;und leider auch Theologie&lt;/l&gt;
+&lt;l&gt;durchaus studiert mit hei&amp;#xDF;em Bem&amp;#xFC;h'n.&lt;/l&gt;
+&lt;/sp&gt;</pre></div><p>The intent declared with <code>xml:lang</code> is considered to apply to
+all attributes and content of the element where it is specified, unless overridden
+with an instance of <code>xml:lang</code> on another element within that content. <span>In particular, the empty value of <code>xml:lang</code> is used on an element B to override a specification of <code>xml:lang</code> on an enclosing element A, without specifying another language. Within B, it is considered that there is no language information available, just as if <code>xml:lang</code> had not been specified on B or any of its ancestors.</span></p><div class="note"><p class="prefix"><b>Note:</b></p><p>Language information may also be provided by external transport protocols (e.g. HTTP or
+MIME). When available, this information may be used by XML applications, but the more local
+information provided by <code>xml:lang</code> should be considered to override it.
+</p></div><p>A simple declaration for <code>xml:lang</code> might take the form</p><div class="exampleInner"><pre>xml:lang <span>CDATA</span> #IMPLIED</pre></div><p>but specific default values <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> also be given, if appropriate. In a collection
+of French poems for English students, with glosses and notes in English, the <code>xml:lang</code>
+attribute might be declared this way:</p><div class="exampleInner"><pre>&lt;!ATTLIST poem   xml:lang <span>CDATA</span> 'fr'&gt;
+&lt;!ATTLIST gloss  xml:lang <span>CDATA</span> 'en'&gt;
+&lt;!ATTLIST note   xml:lang <span>CDATA</span> 'en'&gt;</pre></div></div><div class="div2"> <h3><a name="sec-normalization-checking" id="sec-normalization-checking" />2.13 Normalization Checking</h3><p>All XML <a title="Text Entity" href="#dt-parsedent"> parsed
+entities</a> (including <a title="Document Entity" href="#dt-docent"> document
+entities</a>) <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be <a title="fully normalized" href="#dt-fullnorm">fully
+normalized</a> as per the definition of
+<a href="#sec-CharNorm"><b>B Definitions for Character Normalization</b></a> supplemented by the following definitions of
+<em><a name="dt-relconst" id="dt-relconst" />relevant constructs</em> for XML:</p><ol type="1"><li><p>The <a title="Replacement Text" href="#dt-repltext">
+replacement text</a> of all <a title="Text Entity" href="#dt-parsedent">parsed
+entities</a></p></li><li><p>All text matching, in context, one of the following
+productions:</p><ol type="a"><li><p><a href="#NT-CData">
+CData</a></p></li><li><p><a href="#NT-CharData">
+CharData</a></p></li><li><p><a href="#NT-content">
+content</a></p></li><li><p><a href="#NT-Name"> Name</a></p></li><li><p><a href="#NT-Nmtoken">
+Nmtoken</a></p></li></ol></li></ol><p>However, a document is still well-formed even if it is not
+<a title="fully normalized" href="#dt-fullnorm">fully normalized</a>.
+XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> provide a user option to verify that the document being
+processed is in <a title="fully normalized" href="#dt-fullnorm">fully normalized</a> form, and report to the application whether
+it is or not. The option to not verify <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be chosen only when the
+input text is <a title="certified" href="#dt-certified">certified</a>,
+as defined by <a href="#sec-CharNorm"><b>B Definitions for Character Normalization</b></a>.</p><p>The verification of full normalization <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be carried out as if by
+first verifying that the entity is in <a title="include-normalized" href="#dt-inclnorm">include-normalized</a>
+form as defined by <a href="#sec-CharNorm"><b>B Definitions for Character Normalization</b></a> and by then verifying that none of the relevant
+constructs listed above begins (after character references are
+expanded) with a <a title="composing character" href="#dt-compchar">composing character</a> as defined by
+<a href="#sec-CharNorm"><b>B Definitions for Character Normalization</b></a>.
+Non-validating processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> ignore possible
+denormalizations that would be caused by inclusion of external
+entities that they do not read.</p><div class="note"><p class="prefix"><b>Note:</b></p><p>The <a title="composing character" href="#dt-compchar">composing character</a> are all
+Unicode characters of non-zero combining class, plus a small number
+of class-zero characters that nevertheless take part as a
+non-initial character in certain Unicode canonical
+decompositions.  Since these characters are meant to follow
+base characters, restricting relevant constructs (including
+content) from beginning with a <a title="composing character" href="#dt-compchar">composing character</a> does not
+meaningfully diminish the expressiveness of XML.</p></div><p>If, while verifying full normalization, a processor encounters
+characters for which it cannot determine the normalization
+properties (i.e., characters introduced in a version of Unicode <a href="#Unicode">[Unicode]</a>
+later than the one used in the implementation of the processor),
+then the processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>, at user option, ignore any possible
+denormalizations caused by these characters. The option to ignore
+those denormalizations <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD NOT</em> be chosen by applications when
+reliability or security are critical.</p><p> XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> transform the input to be in
+<a title="fully normalized" href="#dt-fullnorm">fully normalized</a> form.
+XML applications that create XML 1.1 output
+from either XML 1.1 or XML 1.0 input <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> ensure that the output
+is <a title="fully normalized" href="#dt-fullnorm">fully normalized</a>; it is not necessary for internal processing
+forms to be <a title="fully normalized" href="#dt-fullnorm">fully normalized</a>.</p><p>The purpose of this section is to strongly encourage XML
+processors to ensure that the creators of XML documents have
+properly normalized them, so that XML applications can make tests
+such as identity comparisons of strings without having to worry
+about the different possible "spellings" of strings which
+Unicode allows.
+</p><p>When entities are in a non-Unicode encoding, if the processor
+transcodes them to Unicode, it <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> use a normalizing transcoder.
+</p></div></div><div class="div1"> <h2><a name="sec-logical-struct" id="sec-logical-struct" />3 Logical Structures</h2><p>[<a name="dt-element" id="dt-element" title="Element">Definition</a>: Each <a title="XML Document" href="#dt-xml-doc">XML
+document</a> contains one or more <b>elements</b>, the boundaries
+of which are either delimited by <a title="Start-Tag" href="#dt-stag">start-tags</a>
+and <a title="End Tag" href="#dt-etag">end-tags</a>, or, for <a title="Empty" href="#dt-empty">empty</a>
+elements, by an <a title="empty-element tag" href="#dt-eetag">empty-element tag</a>. Each
+element has a type, identified by name, sometimes called its "generic
+identifier" (GI), and <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> have a set of attribute specifications.]
+Each attribute specification has a <a title="Attribute Name" href="#dt-attrname">name</a>
+and a <a title="Attribute Value" href="#dt-attrval">value</a>.</p> <h5><a name="IDATJ3S" id="IDATJ3S" />Element</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-element" id="NT-element" />[39]   </td><td><code>element</code></td><td>   ::=   </td><td><code><a href="#NT-EmptyElemTag">EmptyElemTag</a></code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| <a href="#NT-STag">STag</a> <a href="#NT-content">content</a> <a href="#NT-ETag">ETag</a></code></td><td><a href="#GIMatch">[WFC: Element Type Match]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#elementvalid">[VC: Element Valid]</a></td></tr></tbody></table><p>This specification does not constrain the semantics, use, or (beyond syntax)
+names of the element types and attributes, except that names beginning with
+a match to <code>(('X'|'x')('M'|'m')('L'|'l'))</code> are reserved for standardization
+in this or future versions of this specification.</p><div class="constraint"><p class="prefix"><a name="GIMatch" id="GIMatch" /><b>Well-formedness constraint: Element Type Match</b></p><p>The <a href="#NT-Name">Name</a>
+in an element's end-tag <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the element type in the start-tag.</p></div><div class="constraint"><p class="prefix"><a name="elementvalid" id="elementvalid" /><b>Validity constraint: Element Valid</b></p><p>An element is valid
+if there is a declaration matching <a href="#NT-elementdecl">elementdecl</a>
+where the <a href="#NT-Name">Name</a> matches the element type, and one of
+the following holds:</p><ol type="1"><li><p>The declaration matches <b>EMPTY</b> and the element has no <a title="Content" href="#dt-content">content</a> <span>(not even entity
+references, comments, PIs or white space)</span>.</p></li><li><p>The declaration matches <a href="#NT-children">children</a> and the
+sequence of <a title="Parent/Child" href="#dt-parentchild">child elements</a> belongs
+to the language generated by the regular expression in the content model,
+with optional white space<span>, comments and
+PIs (i.e. markup matching production [27] <a href="#NT-Misc">Misc</a>)</span> between the
+start-tag and the first child element, between child elements, or between
+the last child element and the end-tag. Note that a CDATA section containing
+only white space <span>or a reference
+to an entity whose replacement text is character references expanding to white
+space</span> <span>do</span> not
+match the nonterminal <a href="#NT-S">S</a>, and
+hence cannot appear in these positions<span>; however, a
+reference to an internal entity with a literal value consisting of character
+references expanding to white space does match <a href="#NT-S">S</a>, since its
+replacement text is the white space resulting from expansion of the character
+references</span>.</p></li><li><p>The declaration matches <a href="#NT-Mixed">Mixed</a> and the content
+<span>(after replacing
+any entity references with their replacement text)</span> consists of
+<a title="Character Data" href="#dt-chardata">character data</a><span>,
+<a title="Comment" href="#dt-comment">comments</a>, <a title="Processing instruction" href="#dt-pi">PIs</a></span> and <a title="Parent/Child" href="#dt-parentchild">child elements</a> whose types match names in the
+content model.</p></li><li><p>The declaration matches <b>ANY</b>, and the
+<span>content
+<span>(after replacing
+any entity references with their replacement text)</span>
+consists of character data and <a title="Parent/Child" href="#dt-parentchild">child elements</a>
+whose types</span>
+have been declared.</p></li></ol></div><div class="div2"> <h3><a name="sec-starttags" id="sec-starttags" />3.1 Start-Tags, End-Tags, and Empty-Element Tags</h3><p>[<a name="dt-stag" id="dt-stag" title="Start-Tag">Definition</a>: The beginning of every non-empty
+XML element is marked by a <b>start-tag</b>.]</p> <h5><a name="IDA3O3S" id="IDA3O3S" />Start-tag</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-STag" id="NT-STag" />[40]   </td><td><code>STag</code></td><td>   ::=   </td><td><code>'&lt;' <a href="#NT-Name">Name</a> (<a href="#NT-S">S</a> <a href="#NT-Attribute">Attribute</a>)* <a href="#NT-S">S</a>? '&gt;'</code></td><td><a href="#uniqattspec">[WFC: Unique Att Spec]</a></td></tr><tr valign="baseline"><td><a name="NT-Attribute" id="NT-Attribute" />[41]   </td><td><code>Attribute</code></td><td>   ::=   </td><td><code><a href="#NT-Name">Name</a> <a href="#NT-Eq">Eq</a> <a href="#NT-AttValue">AttValue</a></code></td><td><a href="#ValueType">[VC: Attribute Value Type]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#NoExternalRefs">[WFC: No External Entity References]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#CleanAttrVals">[WFC: No &lt; in Attribute Values]</a></td></tr></tbody></table><p>The <a href="#NT-Name">Name</a> in the start- and end-tags gives the element's <b>type</b>. [<a name="dt-attr" id="dt-attr" title="Attribute">Definition</a>:  The <a href="#NT-Name">Name</a>-<a href="#NT-AttValue">AttValue</a>
+pairs are referred to as the <b>attribute specifications</b> of the
+element], [<a name="dt-attrname" id="dt-attrname" title="Attribute Name">Definition</a>: with the <a href="#NT-Name">Name</a> in each pair referred to as the <b>attribute name</b>]
+and [<a name="dt-attrval" id="dt-attrval" title="Attribute Value">Definition</a>: the content of the <a href="#NT-AttValue">AttValue</a> (the text between the <code>'</code> or <code>"</code>
+delimiters) as the <b>attribute value</b>.]  Note
+that the order of attribute specifications in a start-tag or empty-element
+tag is not significant.</p><div class="constraint"><p class="prefix"><a name="uniqattspec" id="uniqattspec" /><b>Well-formedness constraint: Unique Att Spec</b></p><p><span class="mustard">An attribute name
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> appear more than once in the same start-tag or empty-element tag.</p></div><div class="constraint"><p class="prefix"><a name="ValueType" id="ValueType" /><b>Validity constraint: Attribute Value Type</b></p><p>The attribute <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+have been declared; the value <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be of the type declared for it. (For attribute
+types, see <a href="#attdecls"><b>3.3 Attribute-List Declarations</b></a>.)</p></div><div class="constraint"><p class="prefix"><a name="NoExternalRefs" id="NoExternalRefs" /><b>Well-formedness constraint: No External Entity References</b></p><p>Attribute
+values <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> contain direct or indirect entity references to external entities.</p></div><div class="constraint"><p class="prefix"><a name="CleanAttrVals" id="CleanAttrVals" /><b>Well-formedness constraint: No <code>&lt;</code> in Attribute Values</b></p><p>The <a title="Replacement Text" href="#dt-repltext">replacement text</a> of any entity
+referred to directly or indirectly in an attribute value <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> contain a <code>&lt;</code>.</p></div><p>An example of a start-tag:</p><div class="exampleInner"><pre>&lt;termdef id="dt-dog" term="dog"&gt;</pre></div><p>[<a name="dt-etag" id="dt-etag" title="End Tag">Definition</a>: The end of every element that begins
+with a start-tag <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be marked by an <b>end-tag</b> containing a name
+that echoes the element's type as given in the start-tag:]</p> <h5><a name="IDA3U3S" id="IDA3U3S" />End-tag</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-ETag" id="NT-ETag" />[42]   </td><td><code>ETag</code></td><td>   ::=   </td><td><code>'&lt;/' <a href="#NT-Name">Name</a> <a href="#NT-S">S</a>?
+'&gt;'</code></td></tr></tbody></table><p>An example of an end-tag:</p><div class="exampleInner"><pre>&lt;/termdef&gt;</pre></div><p>[<a name="dt-content" id="dt-content" title="Content">Definition</a>: The <a title="Text" href="#dt-text">text</a>
+between the start-tag and end-tag is called the element's <b>content</b>:]</p> <h5><a name="IDAKW3S" id="IDAKW3S" />Content of Elements</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-content" id="NT-content" />[43]   </td><td><code>content</code></td><td>   ::=   </td><td><code><a href="#NT-CharData">CharData</a>? ((<a href="#NT-element">element</a>
+| <a href="#NT-Reference">Reference</a> | <a href="#NT-CDSect">CDSect</a>
+| <a href="#NT-PI">PI</a> | <a href="#NT-Comment">Comment</a>) <a href="#NT-CharData">CharData</a>?)*</code></td></tr></tbody></table><p>[<a name="dt-empty" id="dt-empty" title="Empty">Definition</a>: An element
+with no <a href="#NT-content">content</a> is said to be <b>empty</b>.] The representation
+of an empty element is either a start-tag immediately followed by an end-tag,
+or an empty-element tag. [<a name="dt-eetag" id="dt-eetag" title="empty-element tag">Definition</a>: An <b>empty-element
+tag</b> takes a special form:]</p> <h5><a name="IDARY3S" id="IDARY3S" />Tags for Empty Elements</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-EmptyElemTag" id="NT-EmptyElemTag" />[44]   </td><td><code>EmptyElemTag</code></td><td>   ::=   </td><td><code>'&lt;' <a href="#NT-Name">Name</a> (<a href="#NT-S">S</a> <a href="#NT-Attribute">Attribute</a>)* <a href="#NT-S">S</a>? '/&gt;'</code></td><td><a href="#uniqattspec">[WFC: Unique Att Spec]</a></td></tr></tbody></table><p>Empty-element tags <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be used for any element which has no content, whether
+or not it is declared using the keyword <b>EMPTY</b>. <a title="For interoperability" href="#dt-interop">For
+interoperability</a>, the empty-element tag <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em>
+be used, and <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> only be used, for elements which are declared
+EMPTY.</p><p>Examples of empty elements:</p><div class="exampleInner"><pre>&lt;IMG align="left"
+src="http://www.w3.org/Icons/WWW/w3c_home" /&gt;
+&lt;br&gt;&lt;/br&gt;
+&lt;br/&gt;</pre></div></div><div class="div2"> <h3><a name="elemdecls" id="elemdecls" />3.2 Element Type Declarations</h3><p>The <a title="Element" href="#dt-element">element</a> structure of an <a title="XML Document" href="#dt-xml-doc">XML document</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>, for <a title="Validity" href="#dt-valid">validation</a>
+purposes, be constrained using element type and attribute-list declarations.
+An element type declaration constrains the element's <a title="Content" href="#dt-content">content</a>.</p><p>Element type declarations often constrain which element types can appear
+as <a title="Parent/Child" href="#dt-parentchild">children</a> of the element. At user
+option, an XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> issue a warning when a declaration mentions an
+element type for which no declaration is provided, but this is not an error.</p><p>[<a name="dt-eldecl" id="dt-eldecl" title="Element Type declaration">Definition</a>: An <b>element
+type declaration</b> takes the form:]</p> <h5><a name="IDAV13S" id="IDAV13S" />Element Type Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-elementdecl" id="NT-elementdecl" />[45]   </td><td><code>elementdecl</code></td><td>   ::=   </td><td><code>'&lt;!ELEMENT' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-S">S</a> <a href="#NT-contentspec">contentspec</a> <a href="#NT-S">S</a>?
+'&gt;'</code></td><td><a href="#EDUnique">[VC: Unique Element Type Declaration]</a></td></tr><tr valign="baseline"><td><a name="NT-contentspec" id="NT-contentspec" />[46]   </td><td><code>contentspec</code></td><td>   ::=   </td><td><code>'EMPTY' | 'ANY' | <a href="#NT-Mixed">Mixed</a>
+| <a href="#NT-children">children</a></code></td></tr></tbody></table><p>where the <a href="#NT-Name">Name</a> gives the element type being declared.</p><div class="constraint"><p class="prefix"><a name="EDUnique" id="EDUnique" /><b>Validity constraint: Unique Element Type Declaration</b></p><p><span class="mustard">An element
+type <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> be declared more than once.</p></div><p>Examples of element type declarations:</p><div class="exampleInner"><pre>&lt;!ELEMENT br EMPTY&gt;
+&lt;!ELEMENT p (#PCDATA|emph)* &gt;
+&lt;!ELEMENT %name.para; %content.para; &gt;
+&lt;!ELEMENT container ANY&gt;</pre></div><div class="div3"> <h4><a name="sec-element-content" id="sec-element-content" />3.2.1 Element Content</h4><p>[<a name="dt-elemcontent" id="dt-elemcontent" title="Element content">Definition</a>: An element <a title="Start-Tag" href="#dt-stag">type</a> has <b>element content</b> when elements
+of that type <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> contain only <a title="Parent/Child" href="#dt-parentchild">child</a>
+elements (no character data), optionally separated by white space (characters
+matching the nonterminal <a href="#NT-S">S</a>).] [<a name="dt-content-model" id="dt-content-model" title="Content model">Definition</a>: In this case, the constraint includes a <b>content
+model</b>, a simple grammar governing the allowed types of the
+child elements and the order in which they are allowed to appear.]
+The grammar is built on content particles (<a href="#NT-cp">cp</a>s), which
+consist of names, choice lists of content particles, or sequence lists of
+content particles:</p> <h5><a name="IDAP53S" id="IDAP53S" />Element-content Models</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-children" id="NT-children" />[47]   </td><td><code>children</code></td><td>   ::=   </td><td><code>(<a href="#NT-choice">choice</a> | <a href="#NT-seq">seq</a>)
+('?' | '*' | '+')?</code></td></tr><tr valign="baseline"><td><a name="NT-cp" id="NT-cp" />[48]   </td><td><code>cp</code></td><td>   ::=   </td><td><code>(<a href="#NT-Name">Name</a> | <a href="#NT-choice">choice</a>
+| <a href="#NT-seq">seq</a>) ('?' | '*' | '+')?</code></td></tr><tr valign="baseline"><td><a name="NT-choice" id="NT-choice" />[49]   </td><td><code>choice</code></td><td>   ::=   </td><td><code>'(' <a href="#NT-S">S</a>? <a href="#NT-cp">cp</a> ( <a href="#NT-S">S</a>? '|' <a href="#NT-S">S</a>? <a href="#NT-cp">cp</a> )+ <a href="#NT-S">S</a>? ')'</code></td><td><a href="#vc-PEinGroup">[VC: Proper Group/PE Nesting]</a></td></tr><tr valign="baseline"><td><a name="NT-seq" id="NT-seq" />[50]   </td><td><code>seq</code></td><td>   ::=   </td><td><code>'(' <a href="#NT-S">S</a>? <a href="#NT-cp">cp</a> ( <a href="#NT-S">S</a>? ',' <a href="#NT-S">S</a>? <a href="#NT-cp">cp</a> )* <a href="#NT-S">S</a>? ')'</code></td><td><a href="#vc-PEinGroup">[VC: Proper Group/PE Nesting]</a></td></tr></tbody></table><p>where each <a href="#NT-Name">Name</a> is the type of an element which
+<em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> appear as a <a title="Parent/Child" href="#dt-parentchild">child</a>. Any content
+particle in a choice list <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> appear in the <a title="Element content" href="#dt-elemcontent">element
+content</a> at the location where the choice list appears in the grammar;
+content particles occurring in a sequence list <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> each appear in the <a title="Element content" href="#dt-elemcontent">element content</a> in the order given in the list.
+The optional character following a name or list governs whether the element
+or the content particles in the list may occur one or more (<code>+</code>),
+zero or more (<code>*</code>), or zero or one times (<code>?</code>). The
+absence of such an operator means that the element or content particle <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+appear exactly once. This syntax and meaning are identical to those used in
+the productions in this specification.</p><p>The content of an element matches a content model if and only if it is
+possible to trace out a path through the content model, obeying the sequence,
+choice, and repetition operators and matching each element in the content
+against an element type in the content model. <a title="For Compatibility" href="#dt-compat">For
+compatibility</a>, it is an error if <span>the content model
+allows an element to match more than one occurrence of an element type in the
+content model</span>. For more information, see <a href="#determinism"><b>D Deterministic Content Models</b></a>.</p><div class="constraint"><p class="prefix"><a name="vc-PEinGroup" id="vc-PEinGroup" /><b>Validity constraint: Proper Group/PE Nesting</b></p><p>Parameter-entity <a title="Replacement Text" href="#dt-repltext">replacement text</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be properly nested with parenthesized
+groups. That is to say, if either of the opening or closing parentheses in
+a <a href="#NT-choice">choice</a>, <a href="#NT-seq">seq</a>, or <a href="#NT-Mixed">Mixed</a>
+construct is contained in the replacement text for a <a title="Parameter-entity reference" href="#dt-PERef">parameter
+entity</a>, both <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be contained in the same replacement text.</p><p><a title="For interoperability" href="#dt-interop">For interoperability</a>, if a parameter-entity reference
+appears in a <a href="#NT-choice">choice</a>, <a href="#NT-seq">seq</a>, or <a href="#NT-Mixed">Mixed</a> construct, its replacement text <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> contain at
+least one non-blank character, and neither the first nor last non-blank character
+of the replacement text <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be a connector (<code>|</code> or <code>,</code>).</p></div><p>Examples of element-content models:</p><div class="exampleInner"><pre>&lt;!ELEMENT spec (front, body, back?)&gt;
+&lt;!ELEMENT div1 (head, (p | list | note)*, div2*)&gt;
+&lt;!ELEMENT dictionary-body (%div.mix; | %dict.mix;)*&gt;</pre></div></div><div class="div3"> <h4><a name="sec-mixed-content" id="sec-mixed-content" />3.2.2 Mixed Content</h4><p>[<a name="dt-mixed" id="dt-mixed" title="Mixed Content">Definition</a>: An element <a title="Start-Tag" href="#dt-stag">type</a>
+has <b>mixed content</b> when elements of that type <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> contain character
+data, optionally interspersed with <a title="Parent/Child" href="#dt-parentchild">child</a>
+elements.] In this case, the types of the child elements <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be constrained,
+but not their order or their number of occurrences:</p> <h5><a name="IDAUHCU" id="IDAUHCU" />Mixed-content Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-Mixed" id="NT-Mixed" />[51]   </td><td><code>Mixed</code></td><td>   ::=   </td><td><code>'(' <a href="#NT-S">S</a>? '#PCDATA' (<a href="#NT-S">S</a>?
+'|' <a href="#NT-S">S</a>? <a href="#NT-Name">Name</a>)* <a href="#NT-S">S</a>?
+')*' </code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| '(' <a href="#NT-S">S</a>? '#PCDATA' <a href="#NT-S">S</a>? ')' </code></td><td><a href="#vc-PEinGroup">[VC: Proper Group/PE Nesting]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#vc-MixedChildrenUnique">[VC: No Duplicate Types]</a></td></tr></tbody></table><p>where the <a href="#NT-Name">Name</a>s give the types of elements that
+may appear as children. The
+keyword <b>#PCDATA</b> derives historically from the term "parsed
+character data."</p><div class="constraint"><p class="prefix"><a name="vc-MixedChildrenUnique" id="vc-MixedChildrenUnique" /><b>Validity constraint: No Duplicate Types</b></p><p>The
+same name <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> appear more than once in a single mixed-content declaration.</p></div><p>Examples of mixed content declarations:</p><div class="exampleInner"><pre>&lt;!ELEMENT p (#PCDATA|a|ul|b|i|em)*&gt;
+&lt;!ELEMENT p (#PCDATA | %font; | %phrase; | %special; | %form;)* &gt;
+&lt;!ELEMENT b (#PCDATA)&gt;</pre></div></div></div><div class="div2"> <h3><a name="attdecls" id="attdecls" />3.3 Attribute-List Declarations</h3><p><a title="Attribute" href="#dt-attr">Attributes</a> are used to associate name-value
+pairs with <a title="Element" href="#dt-element">elements</a>. Attribute specifications
+<span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> appear outside of</span> <a title="Start-Tag" href="#dt-stag">start-tags</a> and <a title="empty-element tag" href="#dt-eetag">empty-element tags</a>; thus, the productions used to
+recognize them appear in <a href="#sec-starttags"><b>3.1 Start-Tags, End-Tags, and Empty-Element Tags</b></a>. Attribute-list declarations
+<em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be used:</p><ul><li><p>To define the set of attributes pertaining to a given element type.</p></li><li><p>To establish type constraints for these attributes.</p></li><li><p>To provide <a title="Attribute Default" href="#dt-default">default values</a> for
+attributes.</p></li></ul><p>[<a name="dt-attdecl" id="dt-attdecl" title="Attribute-List Declaration">Definition</a>: <b>Attribute-list
+declarations</b> specify the name, data type, and default value (if any)
+of each attribute associated with a given element type:]</p> <h5><a name="IDADMCU" id="IDADMCU" />Attribute-list Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-AttlistDecl" id="NT-AttlistDecl" />[52]   </td><td><code>AttlistDecl</code></td><td>   ::=   </td><td><code>'&lt;!ATTLIST' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-AttDef">AttDef</a>* <a href="#NT-S">S</a>? '&gt;'</code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-AttDef" id="NT-AttDef" />[53]   </td><td><code>AttDef</code></td><td>   ::=   </td><td><code><a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-S">S</a> <a href="#NT-AttType">AttType</a> <a href="#NT-S">S</a> <a href="#NT-DefaultDecl">DefaultDecl</a></code></td></tr></tbody></table><p>The <a href="#NT-Name">Name</a> in the <a href="#NT-AttlistDecl">AttlistDecl</a>
+rule is the type of an element. At user option, an XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> issue
+a warning if attributes are declared for an element type not itself declared,
+but this is not an error. The <a href="#NT-Name">Name</a> in the <a href="#NT-AttDef">AttDef</a>
+rule is the name of the attribute.</p><p>When more than one <a href="#NT-AttlistDecl">AttlistDecl</a> is provided
+for a given element type, the contents of all those provided are merged. When
+more than one definition is provided for the same attribute of a given element
+type, the first declaration is binding and later declarations are ignored. <a title="For interoperability" href="#dt-interop">For interoperability,</a> writers of DTDs <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> choose
+to provide at most one attribute-list declaration for a given element type,
+at most one attribute definition for a given attribute name in an attribute-list
+declaration, and at least one attribute definition in each attribute-list
+declaration. For interoperability, an XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> at user option
+issue a warning when more than one attribute-list declaration is provided
+for a given element type, or more than one attribute definition is provided
+for a given attribute, but this is not an error.</p><div class="div3"> <h4><a name="sec-attribute-types" id="sec-attribute-types" />3.3.1 Attribute Types</h4><p>XML attribute types are of three kinds: a string type, a set of tokenized
+types, and enumerated types. The string type may take any literal string as
+a value; the tokenized types have varying lexical and semantic constraints.
+The validity constraints noted in the grammar are applied after the attribute
+value has been normalized as described in <span><a href="#AVNormalize"><b>3.3.3 Attribute-Value Normalization</b></a></span>.</p> <h5><a name="IDAPPCU" id="IDAPPCU" />Attribute Types</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-AttType" id="NT-AttType" />[54]   </td><td><code>AttType</code></td><td>   ::=   </td><td><code><a href="#NT-StringType">StringType</a> | <a href="#NT-TokenizedType">TokenizedType</a>
+| <a href="#NT-EnumeratedType">EnumeratedType</a></code></td></tr><tr valign="baseline"><td><a name="NT-StringType" id="NT-StringType" />[55]   </td><td><code>StringType</code></td><td>   ::=   </td><td><code>'CDATA'</code></td></tr><tr valign="baseline"><td><a name="NT-TokenizedType" id="NT-TokenizedType" />[56]   </td><td><code>TokenizedType</code></td><td>   ::=   </td><td><code>'ID'</code></td><td><a href="#id">[VC: ID]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#one-id-per-el">[VC: One ID per Element Type]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#id-default">[VC: ID Attribute Default]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'IDREF'</code></td><td><a href="#idref">[VC: IDREF]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'IDREFS'</code></td><td><a href="#idref">[VC: IDREF]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'ENTITY'</code></td><td><a href="#entname">[VC: Entity Name]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'ENTITIES'</code></td><td><a href="#entname">[VC: Entity Name]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'NMTOKEN'</code></td><td><a href="#nmtok">[VC: Name Token]</a></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'NMTOKENS'</code></td><td><a href="#nmtok">[VC: Name Token]</a></td></tr></tbody></table><div class="constraint"><p class="prefix"><a name="id" id="id" /><b>Validity constraint: ID</b></p><p>Values of type <b>ID</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the <a href="#NT-Name">Name</a> production. A name <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> appear more than once
+in an XML document as a value of this type; i.e., ID values <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> uniquely
+identify the elements which bear them.</p></div><div class="constraint"><p class="prefix"><a name="one-id-per-el" id="one-id-per-el" /><b>Validity constraint: One ID per Element Type</b></p><p><span class="mustard">An element
+type <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> have more than one ID attribute specified.</p></div><div class="constraint"><p class="prefix"><a name="id-default" id="id-default" /><b>Validity constraint: ID Attribute Default</b></p><p>An ID attribute
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> have a declared default of <b>#IMPLIED</b> or <b>#REQUIRED</b>.</p></div><div class="constraint"><p class="prefix"><a name="idref" id="idref" /><b>Validity constraint: IDREF</b></p><p>Values of type <b>IDREF</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+match the <a href="#NT-Name">Name</a> production, and values of type <b>IDREFS</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match <a href="#NT-Names">Names</a>; each <a href="#NT-Name">Name</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the value of an ID attribute on some element in the XML document;
+i.e. <b>IDREF</b> values <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the value of some ID attribute.</p></div><div class="constraint"><p class="prefix"><a name="entname" id="entname" /><b>Validity constraint: Entity Name</b></p><p>Values of type <b>ENTITY</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the <a href="#NT-Name">Name</a> production, values of type <b>ENTITIES</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match <a href="#NT-Names">Names</a>; each <a href="#NT-Name">Name</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the name of an <a title="Unparsed Entity" href="#dt-unparsed">unparsed entity</a>
+declared in the <a title="Document Type Declaration" href="#dt-doctype">DTD</a>.</p></div><div class="constraint"><p class="prefix"><a name="nmtok" id="nmtok" /><b>Validity constraint: Name Token</b></p><p>Values of type <b>NMTOKEN</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the <a href="#NT-Nmtoken">Nmtoken</a> production; values of type <b>NMTOKENS</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match <a href="#NT-Nmtokens">Nmtokens</a>.</p></div><p>[<a name="dt-enumerated" id="dt-enumerated" title="Enumerated Attribute&#xA;Values">Definition</a>: <b>Enumerated attributes</b> <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em></span> take one of a list of values
+provided in the declaration]. There are two kinds of enumerated types:</p> <h5><a name="IDAHXCU" id="IDAHXCU" />Enumerated Attribute Types</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-EnumeratedType" id="NT-EnumeratedType" />[57]   </td><td><code>EnumeratedType</code></td><td>   ::=   </td><td><code><a href="#NT-NotationType">NotationType</a>
+| <a href="#NT-Enumeration">Enumeration</a></code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-NotationType" id="NT-NotationType" />[58]   </td><td><code>NotationType</code></td><td>   ::=   </td><td><code>'NOTATION' <a href="#NT-S">S</a> '(' <a href="#NT-S">S</a>? <a href="#NT-Name">Name</a> (<a href="#NT-S">S</a>? '|' <a href="#NT-S">S</a>? <a href="#NT-Name">Name</a>)* <a href="#NT-S">S</a>? ')' </code></td><td><a href="#notatn">[VC: Notation Attributes]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#OneNotationPer">[VC: One Notation Per Element Type]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#NoNotationEmpty">[VC: No Notation on Empty Element]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#NoDuplicateTokens">[VC: No Duplicate
+Tokens]</a></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-Enumeration" id="NT-Enumeration" />[59]   </td><td><code>Enumeration</code></td><td>   ::=   </td><td><code>'(' <a href="#NT-S">S</a>? <a href="#NT-Nmtoken">Nmtoken</a>
+(<a href="#NT-S">S</a>? '|' <a href="#NT-S">S</a>? <a href="#NT-Nmtoken">Nmtoken</a>)* <a href="#NT-S">S</a>? ')'</code></td><td><a href="#enum">[VC: Enumeration]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#NoDuplicateTokens">[VC: No Duplicate
+Tokens]</a></td></tr></tbody></table><p>A <b>NOTATION</b> attribute identifies a <a title="Notation" href="#dt-notation">notation</a>,
+declared in the DTD with associated system and/or public identifiers, to be
+used in interpreting the element to which the attribute is attached.</p><div class="constraint"><p class="prefix"><a name="notatn" id="notatn" /><b>Validity constraint: Notation Attributes</b></p><p>Values of this type
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match one of the <a href="#Notations"><cite>notation</cite></a> names
+included in the declaration; all notation names in the declaration <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be
+declared.</p></div><div class="constraint"><p class="prefix"><a name="OneNotationPer" id="OneNotationPer" /><b>Validity constraint: One Notation Per Element Type</b></p><p><span class="mustard">An element type <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> have more than one <b>NOTATION</b>
+attribute specified.</p></div><div class="constraint"><p class="prefix"><a name="NoNotationEmpty" id="NoNotationEmpty" /><b>Validity constraint: No Notation on Empty Element</b></p><p><a title="For Compatibility" href="#dt-compat">For compatibility</a>,
+an attribute of type <b>NOTATION</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> be declared on an element
+declared <b>EMPTY</b>.</p></div><div class="constraint"><p class="prefix"><a name="NoDuplicateTokens" id="NoDuplicateTokens" /><b>Validity constraint: No Duplicate
+Tokens</b></p><p>The notation names in a single <a href="#NT-NotationType">NotationType</a>
+attribute declaration, as well as the <a href="#NT-Nmtoken">NmToken</a>s in a single
+<a href="#NT-Enumeration">Enumeration</a> attribute declaration, <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> all be distinct.</p></div><div class="constraint"><p class="prefix"><a name="enum" id="enum" /><b>Validity constraint: Enumeration</b></p><p>Values of this type <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match
+one of the <a href="#NT-Nmtoken">Nmtoken</a> tokens in the declaration.</p></div><p><a title="For interoperability" href="#dt-interop">For interoperability,</a> the same <a href="#NT-Nmtoken">Nmtoken</a> <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD NOT</em> occur more than once in the enumerated
+attribute types of a single element type.</p></div><div class="div3"> <h4><a name="sec-attr-defaults" id="sec-attr-defaults" />3.3.2 Attribute Defaults</h4><p>An <a title="Attribute-List Declaration" href="#dt-attdecl">attribute declaration</a> provides information
+on whether the attribute's presence is <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em>, and if not, how an XML processor
+<span>is
+to</span> react if a declared attribute is absent in a document.</p> <h5><a name="IDAR4CU" id="IDAR4CU" />Attribute Defaults</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-DefaultDecl" id="NT-DefaultDecl" />[60]   </td><td><code>DefaultDecl</code></td><td>   ::=   </td><td><code>'#REQUIRED' | '#IMPLIED' </code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| (('#FIXED' S)? <a href="#NT-AttValue">AttValue</a>)</code></td><td><a href="#RequiredAttr">[VC: Required Attribute]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#defattrvalid">[VC: Attribute
+Default Value Syntactically Correct]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#CleanAttrVals">[WFC: No &lt; in Attribute Values]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#FixedAttr">[VC: Fixed Attribute Default]</a></td></tr></tbody></table><p>In an attribute declaration, <b>#REQUIRED</b> means that the attribute
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> always be provided, <b>#IMPLIED</b> that no default value is provided.
+[<a name="dt-default" id="dt-default" title="Attribute Default">Definition</a>: If
+the declaration is neither <b>#REQUIRED</b> nor <b>#IMPLIED</b>, then
+the <a href="#NT-AttValue">AttValue</a> value contains the declared <b>default</b>
+value; the <b>#FIXED</b> keyword states that the attribute <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> always have
+the default value.
+When an XML processor encounters
+an <span>element
+without a specification for an attribute for which it has read a default
+value declaration, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> report the attribute with the declared default
+value to the application</span>.]</p><div class="constraint"><p class="prefix"><a name="RequiredAttr" id="RequiredAttr" /><b>Validity constraint: Required Attribute</b></p><p>If the default
+declaration is the keyword <b>#REQUIRED</b>, then the attribute <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be
+specified for all elements of the type in the attribute-list declaration.</p></div><div class="constraint"><p class="prefix"><a name="defattrvalid" id="defattrvalid" /><b>Validity constraint: <span>Attribute
+Default Value Syntactically Correct</span></b></p><p>The declared default value <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> meet the <span>syntactic</span>
+constraints of the declared attribute type.</p><p>Note that only the
+syntactic constraints of the type are required here; other constraints (e.g.
+that the value be the name of a declared unparsed entity, for an attribute of
+type ENTITY) may come into play if the declared default value is actually used
+(an element without a specification for this attribute occurs).</p></div><div class="constraint"><p class="prefix"><a name="FixedAttr" id="FixedAttr" /><b>Validity constraint: Fixed Attribute Default</b></p><p>If an attribute
+has a default value declared with the <b>#FIXED</b> keyword, instances of
+that attribute <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the default value.</p></div><p>Examples of attribute-list declarations:</p><div class="exampleInner"><pre>&lt;!ATTLIST termdef
+id      ID      #REQUIRED
+name    CDATA   #IMPLIED&gt;
+&lt;!ATTLIST list
+type    (bullets|ordered|glossary)  "ordered"&gt;
+&lt;!ATTLIST form
+method  CDATA   #FIXED "POST"&gt;</pre></div></div><div class="div3"> <h4><a name="AVNormalize" id="AVNormalize" />3.3.3 Attribute-Value Normalization</h4><p>Before the value of an attribute is passed to the application or checked
+for validity, the XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> normalize the attribute value by applying
+the algorithm below, or by using some other method such that the value passed
+to the application is the same as that produced by the algorithm.</p><ol type="1"><li><p>All line breaks <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> have been normalized on input to #xA as described
+in <a href="#sec-line-ends"><b>2.11 End-of-Line Handling</b></a>, so the rest of this algorithm operates
+on text normalized in this way.</p></li><li><p>Begin with a normalized value consisting of the empty string.</p></li><li><p>For each character, entity reference, or character reference in the
+unnormalized attribute value, beginning with the first and continuing to the
+last, do the following:</p><ul><li><p>For a character reference, append the referenced character to the
+normalized value.</p></li><li><p>For an entity reference, recursively apply step 3 of this algorithm
+to the replacement text of the entity.</p></li><li><p>For a white space character (#x20, #xD, #xA, #x9), append a space
+character (#x20) to the normalized value.</p></li><li><p>For another character, append the character to the normalized value.</p></li></ul></li></ol><p>If the attribute type is not CDATA, then the XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> further
+process the normalized attribute value by discarding any leading and trailing
+space (#x20) characters, and by replacing sequences of space (#x20) characters
+by a single space (#x20) character.</p><p>Note that if the unnormalized attribute value contains a character reference
+to a white space character other than space (#x20), the normalized value contains
+the referenced character itself (#xD, #xA or #x9). This contrasts with the
+case where the unnormalized value contains a white space character (not a
+reference), which is replaced with a space character (#x20) in the normalized
+value and also contrasts with the case where the unnormalized value contains
+an entity reference whose replacement text contains a white space character;
+being recursively processed, the white space character is replaced with a
+space character (#x20) in the normalized value.</p><p>All attributes for which no declaration has been read <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be treated
+by a non-validating processor as if declared <b>CDATA</b>.</p><p>It
+is an error if an
+<span><a title="Attribute Value" href="#dt-attrval">attribute
+value</a> contains a <a title="Entity Reference" href="#dt-entref">reference</a> to an
+entity for which no declaration has been read.</span></p><p>Following are examples of attribute normalization. Given the following
+declarations:</p><div class="exampleInner"><pre>&lt;!ENTITY d "&amp;#xD;"&gt;
+&lt;!ENTITY a "&amp;#xA;"&gt;
+&lt;!ENTITY da "&amp;#xD;&amp;#xA;"&gt;</pre></div><p>the attribute specifications in the left column below would be normalized
+to the character sequences of the middle column if the attribute <code>a</code>
+is declared <b>NMTOKENS</b> and to those of the right columns if <code>a</code>
+is declared <b>CDATA</b>.</p><table border="1" frame="border" summary="Attribute normalization summary"><thead><tr><th rowspan="1" colspan="1">Attribute specification</th><th rowspan="1" colspan="1">a is NMTOKENS</th><th rowspan="1" colspan="1">a is CDATA</th></tr></thead><tbody><tr><td rowspan="1" colspan="1"><div class="exampleInner"><pre>a="
+xyz"</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>x y z</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>#x20 #x20 x y z</pre></div></td></tr><tr><td rowspan="1" colspan="1"><div class="exampleInner"><pre>a="&amp;d;&amp;d;A&amp;a;<span>&amp;#x20;</span>&amp;a;B&amp;da;"</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>A #x20 B</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>#x20 #x20 A #x20 <span>#x20</span> #x20 B #x20 #x20</pre></div></td></tr><tr><td rowspan="1" colspan="1"><div class="exampleInner"><pre>a=
+"&amp;#xd;&amp;#xd;A&amp;#xa;&amp;#xa;B&amp;#xd;&amp;#xa;"</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>#xD #xD A #xA #xA B #xD #xA</pre></div></td><td rowspan="1" colspan="1"><div class="exampleInner"><pre>#xD #xD A #xA #xA B #xD #xA</pre></div></td></tr></tbody></table><p>Note that the last example is invalid (but well-formed) if <code>a</code>
+is declared to be of type <b>NMTOKENS</b>.</p></div></div><div class="div2"> <h3><a name="sec-condition-sect" id="sec-condition-sect" />3.4 Conditional Sections</h3><p>[<a name="dt-cond-section" id="dt-cond-section" title="conditional section">Definition</a>: <b>Conditional
+sections</b> are portions of the <a title="Document Type Declaration" href="#dt-doctype">document type
+declaration external subset</a> <span>or
+of external parameter entities </span>which are included in, or excluded from,
+the logical structure of the DTD based on the keyword which governs them.]</p> <h5><a name="IDAMHDU" id="IDAMHDU" />Conditional Section</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-conditionalSect" id="NT-conditionalSect" />[61]   </td><td><code>conditionalSect</code></td><td>   ::=   </td><td><code><a href="#NT-includeSect">includeSect</a> | <a href="#NT-ignoreSect">ignoreSect</a></code></td></tr><tr valign="baseline"><td><a name="NT-includeSect" id="NT-includeSect" />[62]   </td><td><code>includeSect</code></td><td>   ::=   </td><td><code>'&lt;![' S? 'INCLUDE' S? '[' <a href="#NT-extSubsetDecl">extSubsetDecl</a>
+']]&gt;' </code></td><td><a href="#condsec-nesting">[VC: Proper Conditional Section/PE Nesting]</a></td></tr><tr valign="baseline"><td><a name="NT-ignoreSect" id="NT-ignoreSect" />[63]   </td><td><code>ignoreSect</code></td><td>   ::=   </td><td><code>'&lt;![' S? 'IGNORE' S? '[' <a href="#NT-ignoreSectContents">ignoreSectContents</a>*
+']]&gt;'</code></td><td><a href="#condsec-nesting">[VC: Proper Conditional Section/PE Nesting]</a></td></tr><tr valign="baseline"><td><a name="NT-ignoreSectContents" id="NT-ignoreSectContents" />[64]   </td><td><code>ignoreSectContents</code></td><td>   ::=   </td><td><code><a href="#NT-Ignore">Ignore</a> ('&lt;![' <a href="#NT-ignoreSectContents">ignoreSectContents</a> ']]&gt;' <a href="#NT-Ignore">Ignore</a>)*</code></td></tr><tr valign="baseline"><td><a name="NT-Ignore" id="NT-Ignore" />[65]   </td><td><code>Ignore</code></td><td>   ::=   </td><td><code><a href="#NT-Char">Char</a>* - (<a href="#NT-Char">Char</a>*
+('&lt;![' | ']]&gt;') <a href="#NT-Char">Char</a>*) </code></td></tr></tbody></table><div class="constraint"><p class="prefix"><a name="condsec-nesting" id="condsec-nesting" /><b>Validity constraint: Proper Conditional Section/PE Nesting</b></p><p>If any of the "<code>&lt;![</code>",
+"<code>[</code>", or "<code>]]&gt;</code>" of a conditional section is contained
+in the replacement text for a parameter-entity reference, all of them <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+be contained in the same replacement text.</p></div><p>Like the internal and external DTD subsets, a conditional section may contain
+one or more complete declarations, comments, processing instructions, or nested
+conditional sections, intermingled with white space.</p><p>If the keyword of the conditional section is <b>INCLUDE</b>, then the
+contents of the conditional section <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be considered</span> part of the DTD. If the keyword of
+the conditional section is <b>IGNORE</b>, then the contents of the conditional
+section <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be considered as</span> not logically part of the DTD.
+If a conditional section with a keyword of <b>INCLUDE</b> occurs within
+a larger conditional section with a keyword of <b>IGNORE</b>, both the outer
+and the inner conditional sections <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> ignored. The contents
+of an ignored conditional section <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> parsed by ignoring all characters after
+the "<code>[</code>" following the keyword, except conditional section starts
+"<code>&lt;![</code>" and ends "<code>]]&gt;</code>", until the matching conditional
+section end is found. Parameter entity references <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> be</span> recognized in this
+process.</p><p>If the keyword of the conditional section is a parameter-entity reference,
+the parameter entity <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be replaced by its content before the processor
+decides whether to include or ignore the conditional section.</p><p>An example:</p><div class="exampleInner"><pre>&lt;!ENTITY % draft 'INCLUDE' &gt;
+&lt;!ENTITY % final 'IGNORE' &gt;
+&lt;![%draft;[
+&lt;!ELEMENT book (comments*, title, body, supplements?)&gt;
+]]&gt;
+&lt;![%final;[
+&lt;!ELEMENT book (title, body, supplements?)&gt;
+]]&gt;</pre></div></div></div><div class="div1"> <h2><a name="sec-physical-struct" id="sec-physical-struct" />4 Physical Structures</h2><p>[<a name="dt-entity" id="dt-entity" title="Entity">Definition</a>: An XML document may consist of one
+or many storage units. These
+are called <b>entities</b>; they all have <b>content</b> and are
+all (except for the <a title="Document Entity" href="#dt-docent">document entity</a> and
+the <a title="Document Type Declaration" href="#dt-doctype">external DTD subset</a>) identified by
+entity <b>name</b>.] Each XML document has one entity
+called the <a title="Document Entity" href="#dt-docent">document entity</a>, which serves
+as the starting point for the <a title="XML Processor" href="#dt-xml-proc">XML processor</a>
+and may contain the whole document.</p><p>Entities may be either parsed or unparsed. [<a name="dt-parsedent" id="dt-parsedent" title="Text Entity">Definition</a>: The contents of a <b>parsed
+entity</b> are referred to as its <a title="Replacement Text" href="#dt-repltext">replacement
+text</a>; this <a title="Text" href="#dt-text">text</a> is considered an
+integral part of the document.]</p><p>[<a name="dt-unparsed" id="dt-unparsed" title="Unparsed Entity">Definition</a>: An <b>unparsed entity</b>
+is a resource whose contents may or may not be <a title="Text" href="#dt-text">text</a>,
+and if text, may
+be other than XML. Each unparsed entity has an associated <a title="Notation" href="#dt-notation">notation</a>, identified by name. Beyond a requirement
+that an XML processor make the identifiers for the entity and notation available
+to the application, XML places no constraints on the contents of unparsed
+entities.]</p><p>Parsed entities are invoked by name using entity references; unparsed entities
+by name, given in the value of <b>ENTITY</b> or <b>ENTITIES</b> attributes.</p><p>[<a name="gen-entity" id="gen-entity" title="general entity">Definition</a>: <b>General entities</b>
+are entities for use within the document content. In this specification, general
+entities are sometimes referred to with the unqualified term <em>entity</em>
+when this leads to no ambiguity.] [<a name="dt-PE" id="dt-PE" title="Parameter entity">Definition</a>: <b>Parameter
+entities</b> are parsed entities for use within the DTD.]
+These two types of entities use different forms of reference and are recognized
+in different contexts. Furthermore, they occupy different namespaces; a parameter
+entity and a general entity with the same name are two distinct entities.</p><div class="div2"> <h3><a name="sec-references" id="sec-references" />4.1 Character and Entity References</h3><p>[<a name="dt-charref" id="dt-charref" title="Character Reference">Definition</a>:  A <b>character
+reference</b> refers to a specific character in the ISO/IEC 10646 character
+set, for example one not directly accessible from available input devices.]</p> <h5><a name="IDAFYDU" id="IDAFYDU" />Character Reference</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-CharRef" id="NT-CharRef" />[66]   </td><td><code>CharRef</code></td><td>   ::=   </td><td><code>'&amp;#' [0-9]+ ';' </code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| '&amp;#x' [0-9a-fA-F]+ ';'</code></td><td><a href="#wf-Legalchar">[WFC: Legal Character]</a></td></tr></tbody></table><div class="constraint"><p class="prefix"><a name="wf-Legalchar" id="wf-Legalchar" /><b>Well-formedness constraint: Legal Character</b></p><p>Characters referred
+to using character references <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the production for <a href="#NT-Char">Char</a>.</p></div><p>If the character reference begins with "<code>&amp;#x</code>",
+the digits and letters up to the terminating <code>;</code> provide a hexadecimal
+representation of the character's code point in ISO/IEC 10646. If it begins
+just with "<code>&amp;#</code>", the digits up to the terminating <code>;</code>
+provide a decimal representation of the character's code point.</p><p>[<a name="dt-entref" id="dt-entref" title="Entity Reference">Definition</a>: An <b>entity reference</b>
+refers to the content of a named entity.] [<a name="dt-GERef" id="dt-GERef" title="General Entity Reference">Definition</a>: References to parsed general entities use
+ampersand (<code>&amp;</code>) and semicolon (<code>;</code>) as delimiters.] [<a name="dt-PERef" id="dt-PERef" title="Parameter-entity reference">Definition</a>: <b>Parameter-entity references</b>
+use percent-sign (<code>%</code>) and semicolon (<code>;</code>) as delimiters.]</p> <h5><a name="IDAS0DU" id="IDAS0DU" />Entity Reference</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-Reference" id="NT-Reference" />[67]   </td><td><code>Reference</code></td><td>   ::=   </td><td><code><a href="#NT-EntityRef">EntityRef</a> | <a href="#NT-CharRef">CharRef</a></code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-EntityRef" id="NT-EntityRef" />[68]   </td><td><code>EntityRef</code></td><td>   ::=   </td><td><code>'&amp;' <a href="#NT-Name">Name</a> ';'</code></td><td><a href="#wf-entdeclared">[WFC: Entity Declared]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#vc-entdeclared">[VC: Entity Declared]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#textent">[WFC: Parsed Entity]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#norecursion">[WFC: No Recursion]</a></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-PEReference" id="NT-PEReference" />[69]   </td><td><code>PEReference</code></td><td>   ::=   </td><td><code>'%' <a href="#NT-Name">Name</a> ';'</code></td><td><a href="#vc-entdeclared">[VC: Entity Declared]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#norecursion">[WFC: No Recursion]</a></td></tr><tr valign="baseline"><td /><td /><td /><td /><td><a href="#indtd">[WFC: In DTD]</a></td></tr></tbody></table><div class="constraint"><p class="prefix"><a name="wf-entdeclared" id="wf-entdeclared" /><b>Well-formedness constraint: Entity Declared</b></p><p>In a document
+without any DTD, a document with only an internal DTD subset which contains
+no parameter entity references, or a document with "<code>standalone='yes'</code>", for
+an entity reference that does not occur within the external subset or a parameter
+entity, the <a href="#NT-Name">Name</a> given in the entity reference <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> <a title="match" href="#dt-match">match</a> that in an <a href="#sec-entity-decl"><cite>entity
+declaration</cite></a> that does not occur within the external subset or a
+parameter entity, except that well-formed documents need not declare
+any of the following entities: <code>amp</code>,
+<code>lt</code>,
+<code>gt</code>,
+<code>apos</code>,
+<code>quot</code>. The
+declaration of a general entity <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> precede any reference to it which appears
+in a default value in an attribute-list declaration.</p><p><span>Note
+that non-validating processors are <a href="#include-if-valid"><cite>not
+obligated to</cite></a> to read and process entity declarations occurring in parameter entities or in
+the external subset</span>; for such documents,
+the rule that an entity must be declared is a well-formedness constraint only
+if <a href="#sec-rmd"><cite>standalone='yes'</cite></a>.</p></div><div class="constraint"><p class="prefix"><a name="vc-entdeclared" id="vc-entdeclared" /><b>Validity constraint: Entity Declared</b></p><p>In a document with
+an external subset or external parameter entities with "<code>standalone='no'</code>",
+the <a href="#NT-Name">Name</a> given in the entity reference <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> <a title="match" href="#dt-match">match</a> that in an <a href="#sec-entity-decl"><cite>entity
+declaration</cite></a>. For interoperability, valid documents <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> declare
+the entities <code>amp</code>,
+<code>lt</code>,
+<code>gt</code>,
+<code>apos</code>,
+<code>quot</code>, in the form specified in <a href="#sec-predefined-ent"><b>4.6 Predefined Entities</b></a>.
+The declaration of a parameter entity <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> precede any reference to it. Similarly,
+the declaration of a general entity <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> precede any attribute-list
+declaration containing a default value with a direct or indirect reference
+to that general entity.</p></div><div class="constraint"><p class="prefix"><a name="textent" id="textent" /><b>Well-formedness constraint: Parsed Entity</b></p><p>An entity reference <em class="rfc2119" title="Keyword in RFC 2119 context">MUST
+NOT</em> contain the name of an <a title="Unparsed Entity" href="#dt-unparsed">unparsed entity</a>.
+Unparsed entities may be referred to only in <a title="Attribute Value" href="#dt-attrval">attribute
+values</a> declared to be of type <b>ENTITY</b> or <b>ENTITIES</b>.</p></div><div class="constraint"><p class="prefix"><a name="norecursion" id="norecursion" /><b>Well-formedness constraint: No Recursion</b></p><p>A parsed entity <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> contain a recursive reference to itself, either directly or indirectly.</p></div><div class="constraint"><p class="prefix"><a name="indtd" id="indtd" /><b>Well-formedness constraint: In DTD</b></p><p>Parameter-entity references <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> appear outside</span>
+the <a title="Document Type Declaration" href="#dt-doctype">DTD</a>.</p></div><p>Examples of character and entity references:</p><div class="exampleInner"><pre>Type &lt;key&gt;less-than&lt;/key&gt; (&amp;#x3C;) to save options.
+This document was prepared on &amp;docdate; and
+is classified &amp;security-level;.</pre></div><p>Example of a parameter-entity reference:</p><div class="exampleInner"><pre>&lt;!-- declare the parameter entity "ISOLat2"... --&gt;
+&lt;!ENTITY % ISOLat2
+SYSTEM "http://www.xml.com/iso/isolat2-xml.entities" &gt;
+&lt;!-- ... now reference it. --&gt;
+%ISOLat2;</pre></div></div><div class="div2"> <h3><a name="sec-entity-decl" id="sec-entity-decl" />4.2 Entity Declarations</h3><p>[<a name="dt-entdecl" id="dt-entdecl" title="entity declaration">Definition</a>:  Entities are declared
+thus:]</p> <h5><a name="IDAECEU" id="IDAECEU" />Entity Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-EntityDecl" id="NT-EntityDecl" />[70]   </td><td><code>EntityDecl</code></td><td>   ::=   </td><td><code><a href="#NT-GEDecl">GEDecl</a> | <a href="#NT-PEDecl">PEDecl</a></code></td></tr><tr valign="baseline"><td><a name="NT-GEDecl" id="NT-GEDecl" />[71]   </td><td><code>GEDecl</code></td><td>   ::=   </td><td><code>'&lt;!ENTITY' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-S">S</a> <a href="#NT-EntityDef">EntityDef</a> <a href="#NT-S">S</a>?
+'&gt;'</code></td></tr><tr valign="baseline"><td><a name="NT-PEDecl" id="NT-PEDecl" />[72]   </td><td><code>PEDecl</code></td><td>   ::=   </td><td><code>'&lt;!ENTITY' <a href="#NT-S">S</a> '%' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-S">S</a> <a href="#NT-PEDef">PEDef</a> <a href="#NT-S">S</a>? '&gt;'</code></td></tr><tr valign="baseline"><td><a name="NT-EntityDef" id="NT-EntityDef" />[73]   </td><td><code>EntityDef</code></td><td>   ::=   </td><td><code><a href="#NT-EntityValue">EntityValue</a>| (<a href="#NT-ExternalID">ExternalID</a> <a href="#NT-NDataDecl">NDataDecl</a>?)</code></td></tr><tr valign="baseline"><td><a name="NT-PEDef" id="NT-PEDef" />[74]   </td><td><code>PEDef</code></td><td>   ::=   </td><td><code><a href="#NT-EntityValue">EntityValue</a> | <a href="#NT-ExternalID">ExternalID</a></code></td></tr></tbody></table><p>The <a href="#NT-Name">Name</a> identifies the entity in an <a title="Entity Reference" href="#dt-entref">entity
+reference</a> or, in the case of an unparsed entity, in the value of
+an <b>ENTITY</b> or <b>ENTITIES</b> attribute. If the same entity is declared
+more than once, the first declaration encountered is binding; at user option,
+an XML processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> issue a warning if entities are declared multiple times.</p><div class="div3"> <h4><a name="sec-internal-ent" id="sec-internal-ent" />4.2.1 Internal Entities</h4><p>[<a name="dt-internent" id="dt-internent" title="Internal Entity Replacement Text">Definition</a>: If the
+entity definition is an <a href="#NT-EntityValue">EntityValue</a>, the defined
+entity is called an <b>internal entity</b>. There is no separate physical
+storage object, and the content of the entity is given in the declaration.]
+Note that some processing of entity and character references in the <a title="Literal Entity Value" href="#dt-litentval">literal entity value</a> may be required to produce
+the correct <a title="Replacement Text" href="#dt-repltext">replacement text</a>: see <a href="#intern-replacement"><b>4.5 Construction of Entity Replacement Text</b></a>.</p><p>An internal entity is a <a title="Text Entity" href="#dt-parsedent">parsed entity</a>.</p><p>Example of an internal entity declaration:</p><div class="exampleInner"><pre>&lt;!ENTITY Pub-Status "This is a pre-release of the
+specification."&gt;</pre></div></div><div class="div3"> <h4><a name="sec-external-ent" id="sec-external-ent" />4.2.2 External Entities</h4><p>[<a name="dt-extent" id="dt-extent" title="External Entity">Definition</a>: If the entity is not internal,
+it is an <b>external entity</b>, declared as follows:]</p> <h5><a name="IDAUIEU" id="IDAUIEU" />External Entity Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-ExternalID" id="NT-ExternalID" />[75]   </td><td><code>ExternalID</code></td><td>   ::=   </td><td><code>'SYSTEM' <a href="#NT-S">S</a> <a href="#NT-SystemLiteral">SystemLiteral</a></code></td></tr><tr valign="baseline"><td /><td /><td /><td><code>| 'PUBLIC' <a href="#NT-S">S</a> <a href="#NT-PubidLiteral">PubidLiteral</a> <a href="#NT-S">S</a> <a href="#NT-SystemLiteral">SystemLiteral</a></code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-NDataDecl" id="NT-NDataDecl" />[76]   </td><td><code>NDataDecl</code></td><td>   ::=   </td><td><code><a href="#NT-S">S</a> 'NDATA' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a></code></td><td><a href="#not-declared">[VC: Notation Declared]</a></td></tr></tbody></table><p>If the <a href="#NT-NDataDecl">NDataDecl</a> is present, this is a general <a title="Unparsed Entity" href="#dt-unparsed">unparsed entity</a>; otherwise it is a parsed entity.</p><div class="constraint"><p class="prefix"><a name="not-declared" id="not-declared" /><b>Validity constraint: Notation Declared</b></p><p>The <a href="#NT-Name">Name</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> match the declared name of a <a title="Notation" href="#dt-notation">notation</a>.</p></div><p>[<a name="dt-sysid" id="dt-sysid" title="System Identifier">Definition</a>: The <a href="#NT-SystemLiteral">SystemLiteral</a> is called the entity's <b>system
+identifier</b>. It is <span>meant to be
+converted to</span> a URI reference
+(as defined in <a href="#rfc2396">[IETF RFC 2396]</a>, updated by <a href="#rfc2732">[IETF RFC 2732]</a>),
+<span>as part of the
+process of dereferencing it</span> to obtain input for the XML processor to construct the
+entity's replacement text.] It is an error for a fragment identifier
+(beginning with a <code>#</code> character) to be part of a system identifier.
+Unless otherwise provided by information outside the scope of this specification
+(e.g. a special XML element type defined by a particular DTD, or a processing
+instruction defined by a particular application specification), relative URIs
+are relative to the location of the resource within which the entity declaration
+occurs. <span>This is defined to
+be the external entity containing the '&lt;' which starts the declaration, at the
+point when it is parsed as a declaration.</span>
+A URI might thus be relative to the <a title="Document Entity" href="#dt-docent">document
+entity</a>, to the entity containing the <a title="Document Type Declaration" href="#dt-doctype">external
+DTD subset</a>, or to some other <a title="External Entity" href="#dt-extent">external parameter
+entity</a>. <span>Attempts to
+retrieve the resource identified by a URI <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be redirected at the parser
+level (for example, in an entity resolver) or below (at the protocol level,
+for example, via an HTTP <code>Location:</code> header). In the absence of additional
+information outside the scope of this specification within the resource,
+the base URI of a resource is always the URI of the actual resource returned.
+In other words, it is the URI of the resource retrieved after all redirection
+has occurred.</span></p><p>System
+identifiers (and other XML strings meant to be used as URI references) <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> contain
+characters that, according to <a href="#rfc2396">[IETF RFC 2396]</a> and <a href="#rfc2732">[IETF RFC 2732]</a>,
+must be escaped before a URI can be used to retrieve the referenced resource. The
+characters to be escaped are the control characters #x0 to #x1F and #x7F (most of
+which cannot appear in XML), space #x20, the delimiters '&lt;' #x3C, '&gt;' #x3E and
+'"' #x22, the <em>unwise</em> characters '{' #x7B, '}' #x7D, '|' #x7C, '\' #x5C, '^' #x5E and
+'`' #x60, as well as all characters above #x7F. Since escaping is not always a fully
+reversible process, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be performed only when absolutely necessary and as late
+as possible in a processing chain. In particular, neither the process of converting
+a relative URI to an absolute one nor the process of passing a URI reference to a
+process or software component responsible for dereferencing it <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> trigger escaping.
+When escaping does occur, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be performed as follows:</p><ol type="1"><li><p>Each
+character <span>to be escaped</span>
+is <span>represented in</span>
+UTF-8 <span><a href="#Unicode">[Unicode]</a></span>
+as one or more bytes.</p></li><li><p><span>The resulting bytes</span>
+are escaped with
+the URI escaping mechanism (that is, converted to <code>%</code><var>HH</var>,
+where HH is the hexadecimal notation of the byte value).</p></li><li><p>The original character is replaced by the resulting character sequence.</p></li></ol><p>[<a name="dt-pubid" id="dt-pubid" title="Public identifier">Definition</a>:  In addition to a system
+identifier, an external identifier <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> include a <b>public identifier</b>.]
+An XML processor attempting to retrieve the entity's content <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> use
+<span>any combination of
+the public and system identifiers as well as additional information outside the
+scope of this specification</span> to try to generate an alternative URI reference.
+If the processor is unable to do so, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> use the URI
+reference specified in the system literal. Before a match is attempted,
+all strings of white space in the public identifier <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be normalized to
+single space characters (#x20), and leading and trailing white space <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+be removed.</p><p>Examples of external entity declarations:</p><div class="exampleInner"><pre>&lt;!ENTITY open-hatch
+SYSTEM "http://www.textuality.com/boilerplate/OpenHatch.xml"&gt;
+&lt;!ENTITY open-hatch
+PUBLIC "-//Textuality//TEXT Standard open-hatch boilerplate//EN"
+"http://www.textuality.com/boilerplate/OpenHatch.xml"&gt;
+&lt;!ENTITY hatch-pic
+SYSTEM "../grafix/OpenHatch.gif"
+NDATA gif &gt;</pre></div></div></div><div class="div2"> <h3><a name="TextEntities" id="TextEntities" />4.3 Parsed Entities</h3><div class="div3"> <h4><a name="sec-TextDecl" id="sec-TextDecl" />4.3.1 The Text Declaration</h4><p>External parsed entities <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> each begin with a <b>text declaration</b>.</p> <h5><a name="IDAUPEU" id="IDAUPEU" />Text Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-TextDecl" id="NT-TextDecl" />[77]   </td><td><code>TextDecl</code></td><td>   ::=   </td><td><code>'&lt;?xml' <a href="#NT-VersionInfo">VersionInfo</a>? <a href="#NT-EncodingDecl">EncodingDecl</a> <a href="#NT-S">S</a>? '?&gt;'</code></td></tr></tbody></table><p>The text declaration <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be provided literally, not by reference
+to a parsed entity. <span class="mustard">The</span> text declaration
+<span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> appear at any
+position other than the beginning of an external parsed entity. The text declaration
+in an external parsed entity is not considered part of its <a title="Replacement Text" href="#dt-repltext">replacement text</a>.</p></div><div class="div3"> <h4><a name="wf-entities" id="wf-entities" />4.3.2 Well-Formed Parsed Entities</h4><p>The document entity is well-formed if it matches the production labeled <a href="#NT-document">document</a>. An external general parsed entity is well-formed
+if it matches the production labeled <a href="#NT-extParsedEnt">extParsedEnt</a>. All
+external parameter entities are well-formed by definition.</p> <h5><a name="IDA2REU" id="IDA2REU" />Well-Formed External Parsed Entity</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-extParsedEnt" id="NT-extParsedEnt" />[78]   </td><td><code>extParsedEnt</code></td><td>   ::=   </td><td><code><a href="#NT-TextDecl">TextDecl</a>? <a href="#NT-content">content</a> - <a href="#NT-Char">Char</a>* <a href="#NT-RestrictedChar">RestrictedChar</a> <a href="#NT-Char">Char</a>*</code></td></tr></tbody></table><p>An internal general parsed entity is well-formed if its replacement text
+matches the production labeled <a href="#NT-content">content</a>. All internal
+parameter entities are well-formed by definition.</p><p>A consequence of well-formedness in <span>general</span>
+entities is that the logical and physical
+structures in an XML document are properly nested; no <a title="Start-Tag" href="#dt-stag">start-tag</a>, <a title="End Tag" href="#dt-etag">end-tag</a>, <a title="Empty" href="#dt-empty">empty-element tag</a>, <a title="Element" href="#dt-element">element</a>, <a title="Comment" href="#dt-comment">comment</a>, <a title="Processing instruction" href="#dt-pi">processing instruction</a>, <a title="Character Reference" href="#dt-charref">character
+reference</a>, or <a title="Entity Reference" href="#dt-entref">entity reference</a>
+can begin in one entity and end in another.</p></div><div class="div3"> <h4><a name="charencoding" id="charencoding" />4.3.3 Character Encoding in Entities</h4><p>Each external parsed entity in an XML document <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> use a different encoding
+for its characters. All XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be able to read entities in both
+the UTF-8 and UTF-16 encodings. The terms "UTF-8"
+and "UTF-16" in this specification do not apply to character
+encodings with any other labels, even if the encodings or labels are very
+similar to UTF-8 or UTF-16.</p><p>Entities encoded in UTF-16 <span><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em></span> <span>and entities
+encoded in UTF-8 <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em></span> begin with the Byte Order Mark described in
+ISO/IEC 10646 <a href="#ISO10646">[ISO/IEC 10646]</a> or Unicode <a href="#Unicode">[Unicode]</a>
+(the ZERO WIDTH NO-BREAK SPACE character, #xFEFF). This is an encoding signature,
+not part of either the markup or the character data of the XML document. XML
+processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be able to use this character to differentiate between UTF-8
+and UTF-16 encoded documents.</p><p>Although an XML processor is required to read only entities in the UTF-8
+and UTF-16 encodings, it is recognized that other encodings are used around
+the world, and it may be desired for XML processors to read entities that
+use them. In
+the absence of external character encoding information (such as MIME headers),
+parsed entities which are stored in an encoding other than UTF-8 or UTF-16
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> begin with a text declaration (see <a href="#sec-TextDecl"><b>4.3.1 The Text Declaration</b></a>) containing
+an encoding declaration:</p> <h5><a name="IDARVEU" id="IDARVEU" />Encoding Declaration</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-EncodingDecl" id="NT-EncodingDecl" />[80]   </td><td><code>EncodingDecl</code></td><td>   ::=   </td><td><code><a href="#NT-S">S</a> 'encoding' <a href="#NT-Eq">Eq</a>
+('"' <a href="#NT-EncName">EncName</a> '"' | "'" <a href="#NT-EncName">EncName</a>
+"'" ) </code></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-EncName" id="NT-EncName" />[81]   </td><td><code>EncName</code></td><td>   ::=   </td><td><code>[A-Za-z] ([A-Za-z0-9._] | '-')*</code></td><td><i>/* Encoding
+name contains only Latin characters */</i></td></tr></tbody></table><p>In the <a title="Document Entity" href="#dt-docent">document entity</a>, the encoding
+declaration is part of the <a title="XML Declaration" href="#dt-xmldecl">XML declaration</a>.
+The <a href="#NT-EncName">EncName</a> is the name of the encoding used.</p><p>In an encoding declaration, the values "<code>UTF-8</code>", "<code>UTF-16</code>",
+"<code>ISO-10646-UCS-2</code>", and "<code>ISO-10646-UCS-4</code>" <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be used
+for the various encodings and transformations of Unicode / ISO/IEC 10646,
+the values "<code>ISO-8859-1</code>", "<code>ISO-8859-2</code>",
+... "<code>ISO-8859-</code><var>n</var>" (where <var>n</var>
+is the part number) <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be used for the parts of ISO 8859, and
+the values "<code>ISO-2022-JP</code>", "<code>Shift_JIS</code>",
+and "<code>EUC-JP</code>" <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> be used for the various encoded
+forms of JIS X-0208-1997. It
+is <em class="rfc2119" title="Keyword in RFC 2119 context">RECOMMENDED</em> that character encodings registered (as <em>charset</em>s)
+with the Internet Assigned Numbers Authority <a href="#IANA">[IANA-CHARSETS]</a>,
+other than those just listed, be referred to using their registered names;
+other encodings <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> use names starting with an "x-" prefix.
+XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> match character encoding names in a case-insensitive
+way and <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> either interpret an IANA-registered name as the encoding registered
+at IANA for that name or treat it as unknown (processors are, of course, not
+required to support all IANA-registered encodings).</p><p>In the absence of information provided by an external transport protocol
+(e.g. HTTP or MIME), it is a <a title="Fatal Error" href="#dt-fatal">fatal error</a> for
+an entity including an encoding declaration to be presented to the XML processor
+in an encoding other than that named in the declaration, or for an entity which
+begins with neither a Byte Order Mark
+nor an encoding declaration to use an encoding other than UTF-8. Note that
+since ASCII is a subset of UTF-8, ordinary ASCII entities do not strictly
+need an encoding declaration.</p><p>It is a <a title="Fatal Error" href="#dt-fatal">fatal error</a> for a <a href="#NT-TextDecl">TextDecl</a> to occur other
+than at the beginning of an external entity.</p><p>It is a <a title="Fatal Error" href="#dt-fatal">fatal error</a> when an XML processor
+encounters an entity with an encoding that it is unable to process. It
+is a <a title="Fatal Error" href="#dt-fatal">fatal error</a> if an XML entity is determined (via default, encoding declaration,
+or higher-level protocol) to be in a certain encoding but contains <span>byte</span>
+sequences that are not legal in that encoding. <span>Specifically, it is a
+fatal error if an entity encoded in UTF-8 contains any irregular code unit sequences,
+as defined in Unicode <a href="#Unicode">[Unicode]</a>.</span> <span>Unless an encoding
+is determined by a higher-level protocol, </span>it is also a <a title="Fatal Error" href="#dt-fatal">fatal error</a> if an XML entity
+contains no encoding declaration and its content is not legal UTF-8 or UTF-16.</p><p>Examples of text declarations containing encoding declarations:</p><div class="exampleInner"><pre>&lt;?xml encoding='UTF-8'?&gt;
+&lt;?xml encoding='EUC-JP'?&gt;</pre></div></div><div class="div3"> <h4><a name="sec-version-info" id="sec-version-info" />4.3.4 Version Information in Entities</h4><p>Each entity, including the <a title="Document Entity" href="#dt-docent">document entity</a>,
+can be separately
+declared as XML 1.0 or XML 1.1. The version declaration appearing
+in the document entity determines the version of the document as a
+whole. An XML 1.1 document may invoke XML 1.0 external entities, so
+that otherwise duplicated versions of external entities,
+particularly DTD external subsets, need not be maintained. However,
+in such a case the rules of XML 1.1 are applied to the entire
+document.</p><p> If an entity (including the document entity) is not labeled
+with a version number, it is treated as if labeled as version
+1.0.</p></div></div><div class="div2"> <h3><a name="entproc" id="entproc" />4.4 XML Processor Treatment of Entities and References</h3><p>The table below summarizes the contexts in which character references,
+entity references, and invocations of unparsed entities might appear and the
+<em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em> behavior of an <a title="XML Processor" href="#dt-xml-proc">XML processor</a>
+in each case. The labels in the leftmost column describe the recognition context: </p><dl><dt class="label">Reference in Content</dt><dd><p>as a reference anywhere after the <a title="Start-Tag" href="#dt-stag">start-tag</a>
+and before the <a title="End Tag" href="#dt-etag">end-tag</a> of an element; corresponds
+to the nonterminal <a href="#NT-content">content</a>.</p></dd><dt class="label">Reference in Attribute Value</dt><dd><p>as a reference within either the value of an attribute in a <a title="Start-Tag" href="#dt-stag">start-tag</a>,
+or a default value in an <a title="Attribute-List Declaration" href="#dt-attdecl">attribute declaration</a>;
+corresponds to the nonterminal <a href="#NT-AttValue">AttValue</a>.</p></dd><dt class="label">Occurs as Attribute Value</dt><dd><p>as a <a href="#NT-Name">Name</a>, not a reference, appearing either as
+the value of an attribute which has been declared as type <b>ENTITY</b>,
+or as one of the space-separated tokens in the value of an attribute which
+has been declared as type <b>ENTITIES</b>.</p></dd><dt class="label">Reference in Entity Value</dt><dd><p>as a reference within a parameter or internal entity's <a title="Literal Entity Value" href="#dt-litentval">literal
+entity value</a> in the entity's declaration; corresponds to the nonterminal <a href="#NT-EntityValue">EntityValue</a>.</p></dd><dt class="label">Reference in DTD</dt><dd><p>as a reference within either the internal or external subsets of the <a title="Document Type Declaration" href="#dt-doctype">DTD</a>, but outside of an <a href="#NT-EntityValue">EntityValue</a>, <a href="#NT-AttValue">AttValue</a>, <a href="#NT-PI">PI</a>, <a href="#NT-Comment">Comment</a>, <a href="#NT-SystemLiteral">SystemLiteral</a>, <a href="#NT-PubidLiteral">PubidLiteral</a>,
+or the contents of an ignored conditional section (see <a href="#sec-condition-sect"><b>3.4 Conditional Sections</b></a>).</p><p>.</p></dd></dl><p></p><table border="1" frame="border" cellpadding="7" summary="Entity type/reference matrix"><tbody align="center"><tr><td rowspan="2" colspan="1"></td><td colspan="4" align="center" valign="bottom" rowspan="1">Entity
+Type</td><td rowspan="2" align="center" colspan="1">Character</td></tr><tr align="center" valign="bottom"><td rowspan="1" colspan="1">Parameter</td><td rowspan="1" colspan="1">Internal General</td><td rowspan="1" colspan="1">External Parsed
+General</td><td rowspan="1" colspan="1">Unparsed</td></tr><tr align="center" valign="middle"><td align="right" rowspan="1" colspan="1">Reference
+in Content</td><td rowspan="1" colspan="1"><a href="#not-recognized"><cite>Not recognized</cite></a></td><td rowspan="1" colspan="1"><a href="#included"><cite>Included</cite></a></td><td rowspan="1" colspan="1"><a href="#include-if-valid"><cite>Included
+if validating</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#included"><cite>Included</cite></a></td></tr><tr align="center" valign="middle"><td align="right" rowspan="1" colspan="1">Reference in Attribute Value</td><td rowspan="1" colspan="1"><a href="#not-recognized"><cite>Not recognized</cite></a></td><td rowspan="1" colspan="1"><a href="#inliteral"><cite>Included
+in literal</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#included"><cite>Included</cite></a></td></tr><tr align="center" valign="middle"><td align="right" rowspan="1" colspan="1">Occurs as Attribute
+Value</td><td rowspan="1" colspan="1"><a href="#not-recognized"><cite>Not recognized</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#notify"><cite>Notify</cite></a></td><td rowspan="1" colspan="1"><a href="#not-recognized"><cite>Not recognized</cite></a></td></tr><tr align="center" valign="middle"><td align="right" rowspan="1" colspan="1">Reference in EntityValue</td><td rowspan="1" colspan="1"><a href="#inliteral"><cite>Included in literal</cite></a></td><td rowspan="1" colspan="1"><a href="#bypass"><cite>Bypassed</cite></a></td><td rowspan="1" colspan="1"><a href="#bypass"><cite>Bypassed</cite></a></td><td rowspan="1" colspan="1"><a href="#error"><cite><span>Error</span></cite></a></td><td rowspan="1" colspan="1"><a href="#included"><cite>Included</cite></a></td></tr><tr align="center" valign="middle"><td align="right" rowspan="1" colspan="1">Reference in DTD</td><td rowspan="1" colspan="1"><a href="#as-PE"><cite>Included as PE</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td><td rowspan="1" colspan="1"><a href="#forbidden"><cite>Forbidden</cite></a></td></tr></tbody></table><div class="div3"> <h4><a name="not-recognized" id="not-recognized" />4.4.1 Not Recognized</h4><p>Outside the DTD, the <code>%</code> character has no special significance;
+thus, what would be parameter entity references in the DTD are not recognized
+as markup in <a href="#NT-content">content</a>. Similarly, the names of unparsed
+entities are not recognized except when they appear in the value of an appropriately
+declared attribute.</p></div><div class="div3"> <h4><a name="included" id="included" />4.4.2 Included</h4><p>[<a name="dt-include" id="dt-include" title="Include">Definition</a>: An entity is <b>included</b>
+when its <a title="Replacement Text" href="#dt-repltext">replacement text</a> is retrieved
+and processed, in place of the reference itself, as though it were part of
+the document at the location the reference was recognized.] The replacement
+text <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> contain both <a title="Character Data" href="#dt-chardata">character data</a>
+and (except for parameter entities) <a title="Markup" href="#dt-markup">markup</a>,
+which <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be recognized in the usual way. (The string "<code>AT&amp;amp;T;</code>"
+expands to "<code>AT&amp;T;</code>" and the remaining ampersand
+is not recognized as an entity-reference delimiter.) A character reference
+is <b>included</b> when the indicated character is processed in place
+of the reference itself. </p></div><div class="div3"> <h4><a name="include-if-valid" id="include-if-valid" />4.4.3 Included If Validating</h4><p>When an XML processor recognizes a reference to a parsed entity, in order
+to <a title="Validity" href="#dt-valid">validate</a> the document, the processor
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> <a title="Include" href="#dt-include">include</a> its replacement text. If
+the entity is external, and the processor is not attempting to validate the
+XML document, the processor <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>, but need
+not, include the entity's replacement text. If a non-validating processor
+does not include the replacement text, it <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> inform the application that
+it recognized, but did not read, the entity.</p><p>This rule is based on the recognition that the automatic inclusion provided
+by the SGML and XML entity mechanism, primarily designed to support modularity
+in authoring, is not necessarily appropriate for other applications, in particular
+document browsing. Browsers, for example, when encountering an external parsed
+entity reference, might choose to provide a visual indication of the entity's
+presence and retrieve it for display only on demand.</p></div><div class="div3"> <h4><a name="forbidden" id="forbidden" />4.4.4 Forbidden</h4><p>The following are forbidden, and constitute <a title="Fatal Error" href="#dt-fatal">fatal
+errors</a>:</p><ul><li><p>the appearance of a reference to an <a title="Unparsed Entity" href="#dt-unparsed">unparsed
+entity</a><span>, except in the
+<a href="#NT-EntityValue">EntityValue</a> in an entity declaration</span>.</p></li><li><p>the appearance of any character or general-entity reference in the
+DTD except within an <a href="#NT-EntityValue">EntityValue</a> or <a href="#NT-AttValue">AttValue</a>.</p></li><li><p>a reference to an external entity in an attribute value.</p></li></ul></div><div class="div3"> <h4><a name="inliteral" id="inliteral" />4.4.5 Included in Literal</h4><p>When an <a title="Entity Reference" href="#dt-entref">entity reference</a> appears in
+an attribute value, or a parameter entity reference appears in a literal entity
+value, its <a title="Replacement Text" href="#dt-repltext">replacement text</a> <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> processed
+in place of the reference itself as though it were part of the document at
+the location the reference was recognized, except that a single or double
+quote character in the replacement text <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> always be</span> treated as a normal data
+character and <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> terminate the literal. For example, this is well-formed:</p><div class="exampleInner"><pre>&lt;!ENTITY % YN '"Yes"' &gt;
+&lt;!ENTITY WhatHeSaid "He said %YN;" &gt;</pre></div><p>while this is not:</p><div class="exampleInner"><pre>&lt;!ENTITY EndAttr "27'" &gt;
+&lt;element attribute='a-&amp;EndAttr;&gt;</pre></div></div><div class="div3"> <h4><a name="notify" id="notify" />4.4.6 Notify</h4><p>When the name of an <a title="Unparsed Entity" href="#dt-unparsed">unparsed entity</a>
+appears as a token in the value of an attribute of declared type <b>ENTITY</b>
+or <b>ENTITIES</b>, a validating processor <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> inform the application of
+the <a title="System Identifier" href="#dt-sysid">system</a> and <a title="Public identifier" href="#dt-pubid">public</a>
+(if any) identifiers for both the entity and its associated <a title="Notation" href="#dt-notation">notation</a>.</p></div><div class="div3"> <h4><a name="bypass" id="bypass" />4.4.7 Bypassed</h4><p>When a general entity reference appears in the <a href="#NT-EntityValue">EntityValue</a>
+in an entity declaration, it <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> bypassed and left as is.</p></div><div class="div3"> <h4><a name="as-PE" id="as-PE" />4.4.8 Included as PE</h4><p>Just as with external parsed entities, parameter entities need only be <a href="#include-if-valid"><cite>included if validating</cite></a>. When a parameter-entity
+reference is recognized in the DTD and included, its <a title="Replacement Text" href="#dt-repltext">replacement
+text</a> <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be</span> enlarged by the attachment of one leading and one following
+space (#x20) character; the intent is to constrain the replacement text of
+parameter entities to contain an integral number of grammatical tokens in
+the DTD. This
+behavior <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em></span> apply to parameter entity references within entity values;
+these are described in <a href="#inliteral"><b>4.4.5 Included in Literal</b></a>.</p></div><div class="div3"> <h4><a name="error" id="error" />4.4.9 Error</h4><p>It is an <a title="Error" href="#dt-error">error</a> for a reference to
+an unparsed entity to appear in the <a href="#NT-EntityValue">EntityValue</a> in an
+entity declaration.</p></div></div><div class="div2"> <h3><a name="intern-replacement" id="intern-replacement" />4.5 Construction of Entity Replacement Text</h3><p>In discussing the treatment of entities, it is useful to distinguish
+two forms of the entity's value.
+[<a name="dt-litentval" id="dt-litentval" title="Literal Entity Value">Definition</a>: <span>For an
+internal entity, </span>the <b>literal
+entity value</b> is the quoted string actually present in the entity declaration,
+corresponding to the non-terminal <a href="#NT-EntityValue">EntityValue</a>.] [<a name="dt-extlitentval" id="dt-extlitentval" title="Literal Entity Value">Definition</a>: For an external entity, the <b>literal
+entity value</b> is the exact text contained in the entity.] [<a name="dt-repltext" id="dt-repltext" title="Replacement Text">Definition</a>: <span>For an
+internal entity, </span>the <b>replacement text</b>
+is the content of the entity, after replacement of character references and
+parameter-entity references.] [<a name="dt-extrepltext" id="dt-extrepltext" title="Replacement Text">Definition</a>: For
+an external entity, the <b>replacement text</b> is the content of the entity,
+after stripping the text declaration (leaving any surrounding white space) if there
+is one but without any replacement of character references or parameter-entity
+references.]</p><p>The literal entity value as given in an internal entity declaration (<a href="#NT-EntityValue">EntityValue</a>) <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> contain character, parameter-entity,
+and general-entity references. Such references <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be contained entirely
+within the literal entity value. The actual replacement text that is <a title="Include" href="#dt-include">included</a><span> (or <a title="" href="#inliteral">included in literal</a>)</span> as described above
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> contain the <em>replacement
+text</em> of any parameter entities referred to, and <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> contain the character
+referred to, in place of any character references in the literal entity value;
+however, general-entity references <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be left as-is, unexpanded. For example,
+given the following declarations:</p><div class="exampleInner"><pre>&lt;!ENTITY % pub    "&amp;#xc9;ditions Gallimard" &gt;
+&lt;!ENTITY   rights "All rights reserved" &gt;
+&lt;!ENTITY   book   "La Peste: Albert Camus,
+&amp;#xA9; 1947 %pub;. &amp;rights;" &gt;</pre></div><p>then the replacement text for the entity "<code>book</code>"
+is:</p><div class="exampleInner"><pre>La Peste: Albert Camus,
+© 1947 Éditions Gallimard. &amp;rights;</pre></div><p>The general-entity reference "<code>&amp;rights;</code>" would
+be expanded should the reference "<code>&amp;book;</code>" appear
+in the document's content or an attribute value.</p><p>These simple rules may have complex interactions; for a detailed discussion
+of a difficult example, see <a href="#sec-entexpand"><b>C Expansion of Entity and Character References</b></a>.</p></div><div class="div2"> <h3><a name="sec-predefined-ent" id="sec-predefined-ent" />4.6 Predefined Entities</h3><p>[<a name="dt-escape" id="dt-escape" title="escape">Definition</a>: Entity and character references <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em>
+both be used to <b>escape</b> the left angle bracket, ampersand, and
+other delimiters. A set of general entities (<code>amp</code>,
+<code>lt</code>,
+<code>gt</code>,
+<code>apos</code>,
+<code>quot</code>) is specified for
+this purpose. Numeric character references <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> also be used; they are expanded
+immediately when recognized and <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be treated as character data, so the
+numeric character references "<code>&amp;#60;</code>" and "<code>&amp;#38;</code>" <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> be used to escape <code>&lt;</code> and <code>&amp;</code> when they occur
+in character data.]</p><p>All XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> recognize these entities whether they are declared
+or not. <a title="For interoperability" href="#dt-interop">For interoperability</a>, valid XML
+documents <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> declare these entities, like any others, before using them. If
+the entities <code>lt</code> or <code>amp</code> are declared, they <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be
+declared as internal entities whose replacement text is a character reference
+to the respective
+character (less-than sign or ampersand) being escaped; the double
+escaping is <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em> for these entities so that references to them produce
+a well-formed result. If the entities <code>gt</code>, <code>apos</code>,
+or <code>quot</code> are declared, they <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be declared as internal entities
+whose replacement text is the single character being escaped (or a character
+reference to that character; the double escaping here is <span class="mustard"><em class="rfc2119" title="Keyword in RFC 2119 context">OPTIONAL</em></span> but harmless).
+For example:</p><div class="exampleInner"><pre>&lt;!ENTITY lt     "&amp;#38;#60;"&gt;
+&lt;!ENTITY gt     "&amp;#62;"&gt;
+&lt;!ENTITY amp    "&amp;#38;#38;"&gt;
+&lt;!ENTITY apos   "&amp;#39;"&gt;
+&lt;!ENTITY quot   "&amp;#34;"&gt;</pre></div></div><div class="div2"> <h3><a name="Notations" id="Notations" />4.7 Notation Declarations</h3><p>[<a name="dt-notation" id="dt-notation" title="Notation">Definition</a>: <b>Notations</b> identify
+by name the format of <a title="External Entity" href="#dt-extent">unparsed entities</a>,
+the format of elements which bear a notation attribute, or the application
+to which a <a title="Processing instruction" href="#dt-pi">processing instruction</a> is addressed.]</p><p>[<a name="dt-notdecl" id="dt-notdecl" title="Notation Declaration">Definition</a>: <b>Notation declarations</b>
+provide a name for the notation, for use in entity and attribute-list declarations
+and in attribute specifications, and an external identifier for the notation
+which may allow an XML processor or its client application to locate a helper
+application capable of processing data in the given notation.]</p> <h5><a name="IDAYTFU" id="IDAYTFU" />Notation Declarations</h5><table class="scrap" summary="Scrap"><tbody><tr valign="baseline"><td><a name="NT-NotationDecl" id="NT-NotationDecl" />[82]   </td><td><code>NotationDecl</code></td><td>   ::=   </td><td><code>'&lt;!NOTATION' <a href="#NT-S">S</a> <a href="#NT-Name">Name</a> <a href="#NT-S">S</a> (<a href="#NT-ExternalID">ExternalID</a> | <a href="#NT-PublicID">PublicID</a>) <a href="#NT-S">S</a>? '&gt;'</code></td><td><a href="#UniqueNotationName">[VC: Unique Notation Name]</a></td></tr></tbody><tbody><tr valign="baseline"><td><a name="NT-PublicID" id="NT-PublicID" />[83]   </td><td><code>PublicID</code></td><td>   ::=   </td><td><code>'PUBLIC' <a href="#NT-S">S</a> <a href="#NT-PubidLiteral">PubidLiteral</a></code></td></tr></tbody></table><div class="constraint"><p class="prefix"><a name="UniqueNotationName" id="UniqueNotationName" /><b>Validity constraint: Unique Notation Name</b></p><p><span class="mustard">A given <a href="#NT-Name">Name</a> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> be declared in more than one notation declaration.</span></p></div><p>XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> provide applications with the name and external identifier(s)
+of any notation declared and referred to in an attribute value, attribute
+definition, or entity declaration. They <em class="rfc2119" title="Keyword in RFC 2119 context">MAY</em> additionally resolve the external
+identifier into the <a title="System Identifier" href="#dt-sysid">system identifier</a>, file
+name, or other information needed to allow the application to call a processor
+for data in the notation described. (It is not an error, however, for XML
+documents to declare and refer to notations for which notation-specific applications
+are not available on the system where the XML processor or application is
+running.)</p></div><div class="div2"> <h3><a name="sec-doc-entity" id="sec-doc-entity" />4.8 Document Entity</h3><p>[<a name="dt-docent" id="dt-docent" title="Document Entity">Definition</a>: The <b>document entity</b>
+serves as the root of the entity tree and a starting-point for an <a title="XML Processor" href="#dt-xml-proc">XML processor</a>.] This specification does
+not specify how the document entity is to be located by an XML processor;
+unlike other entities, the document entity has no name and might well appear
+on a processor input stream without any identification at all.</p></div></div><div class="div1"> <h2><a name="sec-conformance" id="sec-conformance" />5 Conformance</h2><div class="div2"> <h3><a name="proc-types" id="proc-types" />5.1 Validating and Non-Validating Processors</h3><p>Conforming <a title="XML Processor" href="#dt-xml-proc">XML processors</a> fall into
+two classes: validating and non-validating.</p><p>Validating and non-validating processors alike <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> report violations of
+this specification's well-formedness constraints in the content of the <a title="Document Entity" href="#dt-docent">document entity</a> and any other <a title="Text Entity" href="#dt-parsedent">parsed
+entities</a> that they read.</p><p>[<a name="dt-validating" id="dt-validating" title="Validating Processor">Definition</a>: <b>Validating
+processors</b> <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>,
+at user option, report violations of the constraints expressed by
+the declarations in the <a title="Document Type Declaration" href="#dt-doctype">DTD</a>, and failures
+to fulfill the validity constraints given in this specification.]
+To accomplish this, validating XML processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> read and process the entire
+DTD and all external parsed entities referenced in the document.</p><p>Non-validating processors are <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em> to check only the <a title="Document Entity" href="#dt-docent">document
+entity</a>, including the entire internal DTD subset, for well-formedness. [<a name="dt-use-mdecl" id="dt-use-mdecl" title="Process Declarations">Definition</a>:  While they are not required
+to check the document for validity, they are <em class="rfc2119" title="Keyword in RFC 2119 context">REQUIRED</em> to <b>process</b>
+all the declarations they read in the internal DTD subset and in any parameter
+entity that they read, up to the first reference to a parameter entity that
+they do <em>not</em> read; that is to say, they <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> use the information
+in those declarations to <a href="#AVNormalize"><cite>normalize</cite></a>
+attribute values, <a href="#included"><cite>include</cite></a> the replacement
+text of internal entities, and supply <a href="#sec-attr-defaults"><cite>default
+attribute values</cite></a>.] Except when <code>standalone="yes"</code>, they
+<em class="rfc2119" title="Keyword in RFC 2119 context">MUST NOT</em> <a title="Process Declarations" href="#dt-use-mdecl">process</a> <a title="entity declaration" href="#dt-entdecl">entity
+declarations</a> or <a title="Attribute-List Declaration" href="#dt-attdecl">attribute-list declarations</a>
+encountered after a reference to a parameter entity that is not read, since
+the entity may have contained overriding declarations<span>; when <code>standalone="yes"</code>, processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em>
+process these declarations</span>.</p><p>Note
+that when processing invalid documents with a non-validating
+processor the application may not be presented with consistent
+information.  For example, several requirements for uniqueness
+within the document may not be met, including more than one element
+with the same id, duplicate declarations of elements or notations
+with the same name, etc.  In these cases the behavior of the parser
+with respect to reporting such information to the application is
+undefined.</p><p>XML 1.1 processors <em class="rfc2119" title="Keyword in RFC 2119 context">MUST</em> be able to process both XML 1.0
+and XML 1.1 documents.  Programs which generate XML <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em>
+generate XML 1.0, unless one of the specific features of XML 1.1 is required.</p></div><div class="div2"> <h3><a name="safe-behavior" id="safe-behavior" />5.2 Using XML Processors</h3><p>The behavior of a validating XML processor is highly predictable; it must
+read every piece of a document and report all well-formedness and validity
+violations. Less is required of a non-validating processor; it need not read
+any part of the document other than the document entity. This has two effects
+that may be important to users of XML processors:</p><ul><li><p>Certain well-formedness errors, specifically those that require reading
+external entities, <span>may fail to</span> be detected by a non-validating processor. Examples
+include the constraints entitled <a href="#wf-entdeclared"><cite>Entity Declared</cite></a>, <a href="#textent"><cite>Parsed Entity</cite></a>, and <a href="#norecursion"><cite>No
+Recursion</cite></a>, as well as some of the cases described as <a href="#forbidden"><cite>forbidden</cite></a> in <a href="#entproc"><b>4.4 XML Processor Treatment of Entities and References</b></a>.</p></li><li><p>The information passed from the processor to the application may
+vary, depending on whether the processor reads parameter and external entities.
+For example, a non-validating processor <span>may fail to</span> <a href="#AVNormalize"><cite>normalize</cite></a>
+attribute values, <a href="#included"><cite>include</cite></a> the replacement
+text of internal entities, or supply <a href="#sec-attr-defaults"><cite>default
+attribute values</cite></a>, where doing so depends on having read declarations
+in external or parameter entities.</p></li></ul><p>For maximum reliability in interoperating between different XML processors,
+applications which use non-validating processors <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD NOT</em> rely on any behaviors
+not required of such processors.  Applications which require DTD facilities
+not related to validation (such
+as the declaration of default attributes and internal entities that are
+or may be specified in
+external entities <em class="rfc2119" title="Keyword in RFC 2119 context">SHOULD</em> use validating XML processors.</p></div></div><div class="div1"> <h2><a name="sec-notation" id="sec-notation" />6 Notation</h2><p>The formal grammar of XML is given in this specification using a simple
+Extended Backus-Naur Form (EBNF) notation. Each rule in the grammar defines
+one symbol, in the form</p><div class="exampleInner"><pre>symbol ::= expression</pre></div><p>Symbols are written with an initial capital letter if they are the
+start symbol of a regular language, otherwise with an initial lowercase
+letter. Literal strings are quoted.</p><p>Within the expression on the right-hand side of a rule, the following expressions
+are used to match strings of one or more characters: </p><dl><dt class="label"><code>#xN</code></dt><dd><p>where <code>N</code> is a hexadecimal integer, the expression matches the character
+<span>whose</span><span> number
+(code point) in</span> ISO/IEC 10646 <span>is <code>N</code></span>. The number of leading zeros in the <code>#xN</code>
+form is insignificant.</p></dd><dt class="label"><code>[a-zA-Z]</code>, <code>[#xN-#xN]</code></dt><dd><p>matches any <a href="#NT-Char">Char</a> with a value in the range(s) indicated (inclusive).</p></dd><dt class="label"><code>[abc]</code>, <code>[#xN#xN#xN]</code></dt><dd><p>matches any <a href="#NT-Char">Char</a> with a value among the characters
+enumerated. Enumerations and ranges can be mixed in one set of brackets.</p></dd><dt class="label"><code>[^a-z]</code>, <code>[^#xN-#xN]</code></dt><dd><p>matches any <a href="#NT-Char">Char</a> with a value <em>outside</em> the range
+indicated.</p></dd><dt class="label"><code>[^abc]</code>, <code>[^#xN#xN#xN]</code></dt><dd><p>matches any <a href="#NT-Char">Char</a> with a value not among the characters given. Enumerations
+and ranges of forbidden values can be mixed in one set of brackets.</p></dd><dt class="label"><code>"string"</code></dt><dd><p>matches a literal string <a title="match" href="#dt-match">matching</a> that
+given inside the double quotes.</p></dd><dt class="label"><code>'string'</code></dt><dd><p>matches a literal string <a title="match" href="#dt-match">matching</a> that
+given inside the single quotes.</p></dd></dl><p> These symbols may be combined to match more complex patterns as follows,
+where <code>A</code> and <code>B</code> represent simple expressions: </p><dl><dt class="label">(<code>expression</code>)</dt><dd><p><code>expression</code> is treated as a unit and may be combined as described
+in this list.</p></dd><dt class="label"><code>A?</code></dt><dd><p>matches <code>A</code> or nothing; optional <code>A</code>.</p></dd><dt class="label"><code>A B</code></dt><dd><p>matches <code>A</code> followed by <code>B</code>. This
+operator has higher precedence than alternation; thus <code>A B | C D</code>
+is identical to <code>(A B) | (C D)</code>.</p></dd><dt class="label"><code>A | B</code></dt><dd><p>matches <code>A</code> or <code>B</code>.</p></dd><dt class="label"><code>A - B</code></dt><dd><p>matches any string that matches <code>A</code> but does not match <code>B</code>.</p></dd><dt class="label"><code>A+</code></dt><dd><p>matches one or more occurrences of <code>A</code>. Concatenation
+has higher precedence than alternation; thus <code>A+ | B+</code> is identical
+to <code>(A+) | (B+)</code>.</p></dd><dt class="label"><code>A*</code></dt><dd><p>matches zero or more occurrences of <code>A</code>. Concatenation
+has higher precedence than alternation; thus <code>A* | B*</code> is identical
+to <code>(A*) | (B*)</code>.</p></dd></dl><p> Other notations used in the productions are: </p><dl><dt class="label"><code>/* ... */</code></dt><dd><p>comment.</p></dd><dt class="label"><code>[ wfc: ... ]</code></dt><dd><p>well-formedness constraint; this identifies by name a constraint on <a title="Well-Formed" href="#dt-wellformed">well-formed</a> documents associated with a production.</p></dd><dt class="label"><code>[ vc: ... ]</code></dt><dd><p>validity constraint; this identifies by name a constraint on <a title="Validity" href="#dt-valid">valid</a>
+documents associated with a production.</p></dd></dl><p></p></div></div><div class="back"><div class="div1"> <h2><a name="sec-bibliography" id="sec-bibliography" />A References</h2><div class="div2"> <h3><a name="sec-existing-stds" id="sec-existing-stds" />A.1 Normative References</h3><dl><dt class="label"><a name="IANA" id="IANA" />IANA-CHARSETS</dt><dd>(Internet
+Assigned Numbers Authority) <a href="http://www.iana.org/assignments/character-sets"><cite>Official Names for Character Sets</cite></a>,
+ed. Keld Simonsen et al.   (See http://www.iana.org/assignments/character-sets.)</dd><dt class="label"><a name="rfc2119" id="rfc2119" />IETF RFC 2119</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc2119.txt"><cite>RFC 2119: Key words for use in RFCs to Indicate Requirement Levels</cite></a>.
+Scott Bradner, 1997.  (See http://www.ietf.org/rfc/rfc2119.txt.)</dd><dt class="label"><a name="rfc2396" id="rfc2396" />IETF RFC 2396</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc2396.txt"><cite>RFC 2396: Uniform Resource Identifiers
+(URI): Generic Syntax</cite></a>. T. Berners-Lee, R. Fielding, L. Masinter.
+1998.  (See http://www.ietf.org/rfc/rfc2396.txt.)</dd><dt class="label"><a name="rfc2732" id="rfc2732" />IETF RFC 2732</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc2732.txt"><cite>RFC 2732: Format for Literal
+IPv6 Addresses in URL's</cite></a>. R. Hinden, B. Carpenter, L. Masinter.
+1999.  (See http://www.ietf.org/rfc/rfc2732.txt.)</dd><dt class="label"><a name="RFC1766" id="RFC1766" />IETF RFC 3066</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc3066.txt"><cite>RFC 3066: Tags for the Identification
+of Languages</cite></a>, ed. H. Alvestrand. 2001.  (See http://www.ietf.org/rfc/rfc3066.txt.)</dd><dt class="label"><a name="ISO10646" id="ISO10646" />ISO/IEC 10646</dt><dd><span>ISO (International
+Organization for Standardization). <cite>ISO/IEC 10646-1:2000. Information
+technology — Universal Multiple-Octet Coded Character Set (UCS) —
+Part 1: Architecture and Basic Multilingual Plane</cite> and <cite>ISO/IEC 10646-2:2001.
+Information technology — Universal Multiple-Octet Coded Character Set (UCS) — Part 2:
+Supplementary Planes</cite>, as, from time to time, amended, replaced by a new edition or
+expanded by the addition of new parts. [Geneva]: International Organization for Standardization.
+(See <a href="http://www.iso.ch">http://www.iso.ch</a> for the latest version.)</span></dd><dt class="label"><a name="Unicode" id="Unicode" />Unicode</dt><dd>The Unicode Consortium. <em>The Unicode
+Standard, Version 4.0.</em> Reading, Mass.: Addison-Wesley,
+2003,
+as updated from time to time by the publication of new versions. (See
+<a href="http://www.unicode.org/unicode/standard/versions">
+http://www.unicode.org/unicode/standard/versions</a> for the latest version
+and additional information on versions of the standard and of the Unicode
+Character Database).</dd><dt class="label"><a name="XML1.0" />XML-1.0</dt><dd>W3C.  <a href="http://www.w3.org/TR/REC-xml"><cite>Extensible Markup Language (XML) 1.0 (Third
+Edition)</cite></a>.  Tim Bray, Jean Paoli, C.M. Sperberg-McQueen, Eve Maler, François Yergeau
+(editors)  (See http://www.w3.org/TR/REC-xml.)</dd></dl></div><div class="div2"> <h3><a name="null" id="null" />A.2 Other References</h3><dl><dt class="label"><a name="Aho" id="Aho" />Aho/Ullman</dt><dd>Aho, Alfred V., Ravi Sethi, and Jeffrey D.
+Ullman. <cite>Compilers: Principles, Techniques, and Tools</cite>.
+Reading: Addison-Wesley, 1986, rpt. corr. 1988.</dd><dt class="label"><a name="ABK" id="ABK" />Brüggemann-Klein</dt><dd>Brüggemann-Klein,
+Anne. <a href="ftp://ftp.informatik.uni-freiburg.de/documents/papers/brueggem/habil.ps"><cite>Formal Models in Document Processing</cite></a>. Habilitationsschrift. Faculty
+of Mathematics at the University of Freiburg, 1993.  (See ftp://ftp.informatik.uni-freiburg.de/documents/papers/brueggem/habil.ps.)</dd><dt class="label"><a name="ABKDW" id="ABKDW" />Brüggemann-Klein and Wood</dt><dd>Brüggemann-Klein,
+Anne, and Derick Wood. <cite>Deterministic Regular Languages</cite>.
+Universität Freiburg, Institut für Informatik, Bericht 38, Oktober 1991. Extended
+abstract in A. Finkel, M. Jantzen, Hrsg., STACS 1992, S. 173-184. Springer-Verlag,
+Berlin 1992. Lecture Notes in Computer Science 577. Full version titled <cite>One-Unambiguous
+Regular Languages</cite> in Information and Computation 140 (2): 229-253,
+February 1998.</dd><dt class="label"><a name="Charmod" />Charmod</dt><dd>W3C Working Draft.
+<a href="http://www.w3.org/TR/2003/WD-charmod-20030822/"><cite>Character Model for the World Wide Web 1.0</cite></a>.
+Martin J. Dürst, François Yergeau, Richard Ishida, Misha Wolf, Tex Texin.  (See http://www.w3.org/TR/2003/WD-charmod-20030822/.)</dd><dt class="label"><a name="Clark" id="Clark" />Clark</dt><dd>James Clark.
+<a href="http://www.w3.org/TR/NOTE-sgml-xml-971215"><cite>Comparison of SGML and XML</cite></a>.  (See http://www.w3.org/TR/NOTE-sgml-xml-971215.)</dd><dt class="label"><a name="IANA-LANGCODES" id="IANA-LANGCODES" />IANA-LANGCODES</dt><dd>(Internet
+Assigned Numbers Authority) <a href="http://www.iana.org/assignments/language-tags"><cite>Registry of Language Tags</cite></a>,
+ed. Keld Simonsen et al.   (See http://www.iana.org/assignments/language-tags.)</dd><dt class="label"><a name="RFC2141" id="RFC2141" />IETF RFC 2141</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc2141.txt"><cite>RFC 2141: URN Syntax</cite></a>, ed.
+R. Moats. 1997.   (See http://www.ietf.org/rfc/rfc2141.txt.)</dd><dt class="label"><a name="rfc2376" id="rfc2376" />IETF RFC 3023</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc3023.txt"><cite>RFC 3023: XML Media Types</cite></a>.
+eds. M. Murata, S. St.Laurent, D. Kohn. 2001.  (See http://www.ietf.org/rfc/rfc3023.txt.)</dd><dt class="label"><a name="rfc2781" id="rfc2781" />IETF RFC 2781</dt><dd>IETF
+(Internet Engineering Task Force). <a href="http://www.ietf.org/rfc/rfc2781.txt"><cite>RFC 2781: UTF-16, an encoding
+of ISO 10646</cite></a>, ed. P. Hoffman, F. Yergeau. 2000.  (See http://www.ietf.org/rfc/rfc2781.txt.)</dd><dt class="label"><a name="ISO639" id="ISO639" />ISO 639</dt><dd>(International Organization for Standardization).
+<cite>ISO 639:1988 (E).
+Code for the representation of names of languages.</cite> [Geneva]: International
+Organization for Standardization, 1988.</dd><dt class="label"><a name="ISO3166" id="ISO3166" />ISO 3166</dt><dd>(International Organization for Standardization).
+<cite>ISO 3166-1:1997
+(E). Codes for the representation of names of countries and their subdivisions —
+Part 1: Country codes</cite> [Geneva]: International Organization for
+Standardization, 1997.</dd><dt class="label"><a name="ISO8879" id="ISO8879" />ISO 8879</dt><dd>ISO (International Organization for Standardization). <cite>ISO
+8879:1986(E). Information processing — Text and Office Systems —
+Standard Generalized Markup Language (SGML).</cite> First edition —
+1986-10-15. [Geneva]: International Organization for Standardization, 1986. </dd><dt class="label"><a name="ISO10744" id="ISO10744" />ISO/IEC 10744</dt><dd>ISO (International Organization for
+Standardization). <cite>ISO/IEC 10744-1992 (E). Information technology —
+Hypermedia/Time-based Structuring Language (HyTime). </cite> [Geneva]:
+International Organization for Standardization, 1992. <em>Extended Facilities
+Annexe.</em> [Geneva]: International Organization for Standardization, 1996. </dd><dt class="label"><a name="websgml" id="websgml" />WEBSGML</dt><dd>ISO
+(International Organization for Standardization). <a href="http://www.sgmlsource.com/8879/n0029.htm"><cite>ISO 8879:1986
+TC2. Information technology — Document Description and Processing Languages</cite></a>.
+[Geneva]: International Organization for Standardization, 1998.  (See http://www.sgmlsource.com/8879/n0029.htm.)</dd><dt class="label"><a name="xml-names" id="xml-names" />XML Names</dt><dd>Tim Bray,
+Dave Hollander, and Andrew Layman, editors. <a href="http://www.w3.org/TR/REC-xml-names/"><cite>Namespaces in XML</cite></a>.
+Textuality, Hewlett-Packard, and Microsoft. World Wide Web Consortium, 1999.  (See http://www.w3.org/TR/REC-xml-names/.)</dd></dl></div></div><div class="div1"> <h2><a name="sec-CharNorm" id="sec-CharNorm" />B Definitions for Character Normalization</h2><p>This appendix contains the necessary definitions for character normalization.
+For additional background information and examples, see <a href="#Charmod">[Charmod]</a>.</p><p>
+[<a name="dt-Uni-encform" id="dt-Uni-encform" title="Unicode encoding form">Definition</a>: Text is said to be
+in a <b>Unicode encoding form</b> if it is encoded in
+UTF-8, UTF-16 or UTF-32.]</p><p>
+[<a name="dt-legacyenc" id="dt-legacyenc" title="legacy encoding">Definition</a>: <b>Legacy encoding</b>
+is taken to mean any character encoding not based on Unicode.]</p><p>
+[<a name="dt-normtransc" id="dt-normtransc" title="normalizing transcoder">Definition</a>: A
+<b>normalizing transcoder</b> is a transcoder that converts from a
+<a title="legacy encoding" href="#dt-legacyenc">legacy encoding</a> to a
+<a title="Unicode encoding form" href="#dt-Uni-encform">Unicode encoding form</a> and
+ensures that the result is in Unicode Normalization Form C
+(see UAX #15 <a href="#Unicode">[Unicode]</a>).]</p><p>[<a name="dt-charesc" id="dt-charesc" title="character escape">Definition</a>: A <b>character escape</b>
+is a syntactic device defined in a markup or programming language that allows
+one or more of:]</p><ol type="1"><li><p>expressing syntax-significant characters while disregarding
+their significance in the syntax of the language, or</p></li><li><p>expressing characters not representable in the character encoding
+chosen for an instance of the language, or</p></li><li><p>expressing characters in general, without use of the corresponding
+character codes.</p></li></ol><p>
+[<a name="dt-certified" id="dt-certified" title="certified">Definition</a>: <b>Certified</b> text
+is text which satisfies at least one of the following conditions:]</p><ol type="1"><li><p>it has been confirmed through inspection that the text
+is in normalized form</p></li><li><p>the source text-processing component is identified
+and is known to produce only normalized text.</p></li></ol><p>
+[<a name="dt-uninorm" id="dt-uninorm" title="Unicode-normalized">Definition</a>: Text is, for the purposes of
+this specification, <b>Unicode-normalized</b> if it is in a
+<a title="Unicode encoding form" href="#dt-Uni-encform">Unicode encoding form</a> and is in
+Unicode Normalization Form C, according to a version of Unicode Standard Annex #15:
+Unicode Normalization Forms <a href="#Unicode">[Unicode]</a> at least as recent as the
+oldest version of the Unicode Standard that contains all the characters
+actually present in the text, but no earlier
+than version 3.2.]</p><p>
+[<a name="dt-inclnorm" id="dt-inclnorm" title="include-normalized">Definition</a>: Text is
+<b>include-normalized</b> if:]</p><ol type="1"><li><p>the text is <a title="Unicode-normalized" href="#dt-uninorm">Unicode-normalized</a>
+and does not contain any <a title="character escape" href="#dt-charesc">character escapes</a>
+or <a title="Include" href="#dt-include">includes</a> whose expansion would
+cause the text to become no longer <a title="Unicode-normalized" href="#dt-uninorm">Unicode-normalized</a>;
+or</p></li><li><p>the text is in a <a title="legacy encoding" href="#dt-legacyenc">legacy encoding</a> and, if it were transcoded
+to a <a title="Unicode encoding form" href="#dt-Uni-encform">Unicode encoding form</a> by a
+<a title="normalizing transcoder" href="#dt-normtransc">normalizing transcoder</a>, the resulting
+text would satisfy clause 1 above.</p></li></ol><p>
+[<a name="dt-compchar" id="dt-compchar" title="composing character">Definition</a>: A <b>composing character</b>
+is a character that is one or both of the following:]</p><ol type="1"><li><p>the second character in the canonical decomposition mapping of
+some primary composite (as defined in D3 of UAX #15 <a href="#Unicode">[Unicode]</a>), or</p></li><li><p>of non-zero canonical combining class (as defined in Unicode
+<a href="#Unicode">[Unicode]</a>).</p></li></ol><p>
+[<a name="dt-fullnorm" id="dt-fullnorm" title="fully normalized">Definition</a>: Text is
+<b>fully-normalized</b> if:]</p><ol type="1"><li><p>the text is in a <a title="Unicode encoding form" href="#dt-Uni-encform">Unicode encoding
+form</a>, is <a title="include-normalized" href="#dt-inclnorm">include-normalized</a> and
+none of the <a title="" href="#dt-relconst"><span>relevant</span>
+constructs</a> comprising the text begin with a
+<a title="composing character" href="#dt-compchar">composing character</a> or a
+character escape representing a
+<a title="composing character" href="#dt-compchar">composing character</a>; or</p></li><li><p>the text is in a <a title="legacy encoding" href="#dt-legacyenc">legacy encoding</a> and,
+if it were transcoded to a <a title="Unicode encoding form" href="#dt-Uni-encform">Unicode encoding form</a>
+by a <a title="normalizing transcoder" href="#dt-normtransc">normalizing transcoder</a>, the resulting text
+would satisfy clause 1 above.</p></li></ol></div><div class="div1"> <h2><a name="sec-entexpand" id="sec-entexpand" />C Expansion of Entity and Character References (Non-Normative)</h2><p>This appendix contains some examples illustrating the sequence of entity-
+and character-reference recognition and expansion, as specified in <a href="#entproc"><b>4.4 XML Processor Treatment of Entities and References</b></a>.</p><p>If the DTD contains the declaration</p><div class="exampleInner"><pre>&lt;!ENTITY example "&lt;p&gt;An ampersand (&amp;#38;#38;) may be escaped
+numerically (&amp;#38;#38;#38;) or with a general entity
+(&amp;amp;amp;).&lt;/p&gt;" &gt;</pre></div><p>then the XML processor will recognize the character references when it
+parses the entity declaration, and resolve them before storing the following
+string as the value of the entity "<code>example</code>":</p><div class="exampleInner"><pre>&lt;p&gt;An ampersand (&amp;#38;) may be escaped
+numerically (&amp;#38;#38;) or with a general entity
+(&amp;amp;amp;).&lt;/p&gt;</pre></div><p>A reference in the document to "<code>&amp;example;</code>"
+will cause the text to be reparsed, at which time the start- and end-tags
+of the <code>p</code> element will be recognized and the three references will
+be recognized and expanded, resulting in a <code>p</code> element with the following
+content (all data, no delimiters or markup):</p><div class="exampleInner"><pre>An ampersand (&amp;) may be escaped
+numerically (&amp;#38;) or with a general entity
+(&amp;amp;).</pre></div><p>A more complex example will illustrate the rules and their effects fully.
+In the following example, the line numbers are solely for reference.</p><div class="exampleInner"><pre>1 &lt;?xml version='1.0'?&gt;
+2 &lt;!DOCTYPE test [
+3 &lt;!ELEMENT test (#PCDATA) &gt;
+4 &lt;!ENTITY % xx '&amp;#37;zz;'&gt;
+5 &lt;!ENTITY % zz '&amp;#60;!ENTITY tricky "error-prone" &gt;' &gt;
+6 %xx;
+7 ]&gt;
+8 &lt;test&gt;This sample shows a &amp;tricky; method.&lt;/test&gt;</pre></div><p>This produces the following:</p><ul><li><p>in line 4, the reference to character 37 is expanded immediately,
+and the parameter entity "<code>xx</code>" is stored in the symbol
+table with the value "<code>%zz;</code>". Since the replacement
+text is not rescanned, the reference to parameter entity "<code>zz</code>"
+is not recognized. (And it would be an error if it were, since "<code>zz</code>"
+is not yet declared.)</p></li><li><p>in line 5, the character reference "<code>&amp;#60;</code>"
+is expanded immediately and the parameter entity "<code>zz</code>"
+is stored with the replacement text "<code>&lt;!ENTITY tricky "error-prone"
+&gt;</code>", which is a well-formed entity declaration.</p></li><li><p>in line 6, the reference to "<code>xx</code>" is recognized,
+and the replacement text of "<code>xx</code>" (namely "<code>%zz;</code>")
+is parsed. The reference to "<code>zz</code>" is recognized in
+its turn, and its replacement text ("<code>&lt;!ENTITY tricky "error-prone"
+&gt;</code>") is parsed. The general entity "<code>tricky</code>"
+has now been declared, with the replacement text "<code>error-prone</code>".</p></li><li><p>in line 8, the reference to the general entity "<code>tricky</code>"
+is recognized, and it is expanded, so the full content of the <code>test</code>
+element is the self-describing (and ungrammatical) string <em>This sample
+shows a error-prone method.</em></p></li></ul></div><div class="div1"> <h2><a name="determinism" id="determinism" />D Deterministic Content Models (Non-Normative)</h2><p>As
+noted in <a href="#sec-element-content"><b>3.2.1 Element Content</b></a>, it is required that content
+models in element type declarations be deterministic. This requirement is <a title="For Compatibility" href="#dt-compat">for compatibility</a> with SGML (which calls deterministic
+content models "unambiguous"); XML processors built
+using SGML systems may flag non-deterministic content models as errors.</p><p>For example, the content model <code>((b, c) | (b, d))</code> is non-deterministic,
+because given an initial <code>b</code> the XML processor
+cannot know which <code>b</code> in the model is being matched without looking
+ahead to see which element follows the <code>b</code>. In this case, the two references
+to <code>b</code> can be collapsed into a single reference, making the model read <code>(b,
+(c | d))</code>. An initial <code>b</code> now clearly matches only a single name
+in the content model. The processor doesn't need to look ahead to see what follows; either <code>c</code> or <code>d</code>
+would be accepted.</p><p>More formally: a finite state automaton may be constructed from the content
+model using the standard algorithms, e.g. algorithm 3.5 in section 3.9 of
+Aho, Sethi, and Ullman <a href="#Aho">[Aho/Ullman]</a>. In many such algorithms, a follow
+set is constructed for each position in the regular expression (i.e., each
+leaf node in the syntax tree for the regular expression); if any position
+has a follow set in which more than one following position is labeled with
+the same element type name, then the content model is in error and may be
+reported as an error.</p><p>Algorithms exist which allow many but not all non-deterministic content
+models to be reduced automatically to equivalent deterministic models; see
+Brüggemann-Klein 1991 <a href="#ABK">[Brüggemann-Klein]</a>.</p></div><div class="div1"> <h2><a name="sec-guessing" id="sec-guessing" />E Autodetection of Character Encodings (Non-Normative)</h2><p>The XML encoding declaration functions as an internal label on each entity,
+indicating which character encoding is in use. Before an XML processor can
+read the internal label, however, it apparently has to know what character
+encoding is in use — which is what the internal label is trying to indicate.
+In the general case, this is a hopeless situation. It is not entirely hopeless
+in XML, however, because XML limits the general case in two ways: each implementation
+is assumed to support only a finite set of character encodings, and the XML
+encoding declaration is restricted in position and content in order to make
+it feasible to autodetect the character encoding in use in each entity in
+normal cases. Also, in many cases other sources of information are available
+in addition to the XML data stream itself. Two cases may be distinguished,
+depending on whether the XML entity is presented to the processor without,
+or with, any accompanying (external) information. We consider the first case
+first.</p><div class="div2"> <h3><a name="sec-guessing-no-ext-info" id="sec-guessing-no-ext-info" />E.1 Detection Without External Encoding Information</h3><p>Because each XML entity not accompanied by external
+encoding information and not in UTF-8 or UTF-16 encoding must
+begin with an XML encoding declaration, in which the first characters must
+be '<code>&lt;?xml</code>', any conforming processor can detect, after two
+to four octets of input, which of the following cases apply. In reading this
+list, it may help to know that in UCS-4, '&lt;' is "<code>#x0000003C</code>"
+and '?' is "<code>#x0000003F</code>", and the Byte Order Mark
+required of UTF-16 data streams is "<code>#xFEFF</code>". The notation
+<var>##</var> is used to denote any byte value except that two consecutive
+<var>##</var>s cannot be both 00.</p><p>With a Byte Order Mark:</p><table border="1" frame="border" summary="Encoding detection summary"><tbody><tr><td rowspan="1" colspan="1"><code>00 00 FE
+FF</code></td><td rowspan="1" colspan="1">UCS-4, big-endian machine (1234 order)</td></tr><tr><td rowspan="1" colspan="1"><code>FF
+FE 00 00</code></td><td rowspan="1" colspan="1">UCS-4, little-endian machine (4321 order)</td></tr><tr><td rowspan="1" colspan="1"><code>00 00 FF FE</code></td><td rowspan="1" colspan="1">UCS-4, unusual octet order (2143)</td></tr><tr><td rowspan="1" colspan="1"><code>FE FF 00 00</code></td><td rowspan="1" colspan="1">UCS-4, unusual octet order (3412)</td></tr><tr><td rowspan="1" colspan="1"><code>FE FF ## ##</code></td><td rowspan="1" colspan="1">UTF-16, big-endian</td></tr><tr><td rowspan="1" colspan="1"><code>FF FE ## ##</code></td><td rowspan="1" colspan="1">UTF-16, little-endian</td></tr><tr><td rowspan="1" colspan="1"><code>EF BB BF</code></td><td rowspan="1" colspan="1">UTF-8</td></tr></tbody></table><p>Without a Byte Order Mark:</p><table border="1" frame="border" summary="Encoding detection summary"><tbody><tr><td rowspan="1" colspan="1"><code>00 00 00 3C</code></td><td rowspan="4" colspan="1">UCS-4 or other encoding with a 32-bit code unit and ASCII
+characters encoded as ASCII values, in respectively big-endian (1234), little-endian
+(4321) and two unusual byte orders (2143 and 3412). The encoding declaration
+must be read to determine which of UCS-4 or other supported 32-bit encodings
+applies.</td></tr><tr><td rowspan="1" colspan="1"><code>3C 00 00 00</code></td></tr><tr><td rowspan="1" colspan="1"><code>00 00 3C 00</code></td></tr><tr><td rowspan="1" colspan="1"><code>00 3C 00 00</code></td></tr><tr><td rowspan="1" colspan="1"><code>00 3C 00 3F</code></td><td rowspan="1" colspan="1">UTF-16BE or big-endian ISO-10646-UCS-2
+or other encoding with a 16-bit code unit in big-endian order and ASCII characters
+encoded as ASCII values (the encoding declaration must be read to determine
+which)</td></tr><tr><td rowspan="1" colspan="1"><code>3C 00 3F 00</code></td><td rowspan="1" colspan="1">UTF-16LE or little-endian
+ISO-10646-UCS-2 or other encoding with a 16-bit code unit in little-endian
+order and ASCII characters encoded as ASCII values (the encoding declaration
+must be read to determine which)</td></tr><tr><td rowspan="1" colspan="1"><code>3C 3F 78 6D</code></td><td rowspan="1" colspan="1">UTF-8, ISO 646, ASCII, some part of ISO 8859, Shift-JIS, EUC, or any other
+7-bit, 8-bit, or mixed-width encoding which ensures that the characters of
+ASCII have their normal positions, width, and values; the actual encoding
+declaration must be read to detect which of these applies, but since all of
+these encodings use the same bit patterns for the relevant ASCII characters,
+the encoding declaration itself may be read reliably</td></tr><tr><td rowspan="1" colspan="1"><code>4C
+6F A7 94</code></td><td rowspan="1" colspan="1">EBCDIC (in some flavor; the full encoding declaration
+must be read to tell which code page is in use)</td></tr><tr><td rowspan="1" colspan="1">Other</td><td rowspan="1" colspan="1">UTF-8 without an encoding declaration, or else the data stream is mislabeled
+(lacking a required encoding declaration), corrupt, fragmentary, or enclosed
+in a wrapper of some kind</td></tr></tbody></table><div class="note"><p class="prefix"><b>Note:</b></p><p>In cases above which do not require reading the encoding declaration to
+determine the encoding, section 4.3.3 still requires that the encoding declaration,
+if present, be read and that the encoding name be checked to match the actual
+encoding of the entity. Also, it is possible that new character encodings
+will be invented that will make it necessary to use the encoding declaration
+to determine the encoding, in cases where this is not required at present.</p></div><p>This level of autodetection is enough to read the XML encoding declaration
+and parse the character-encoding identifier, which is still necessary to distinguish
+the individual members of each family of encodings (e.g. to tell UTF-8 from
+8859, and the parts of 8859 from each other, or to distinguish the specific
+EBCDIC code page in use, and so on).</p><p>Because the contents of the encoding declaration are restricted to characters
+from the ASCII repertoire (however encoded),
+a processor can reliably read the entire encoding declaration as soon as it
+has detected which family of encodings is in use. Since in practice, all widely
+used character encodings fall into one of the categories above, the XML encoding
+declaration allows reasonably reliable in-band labeling of character encodings,
+even when external sources of information at the operating-system or transport-protocol
+level are unreliable. Character encodings such as UTF-7
+that make overloaded usage of ASCII-valued bytes may fail to be reliably detected.</p><p>Once the processor has detected the character encoding in use, it can act
+appropriately, whether by invoking a separate input routine for each case,
+or by calling the proper conversion function on each character of input.</p><p>Like any self-labeling system, the XML encoding declaration will not work
+if any software changes the entity's character set or encoding without updating
+the encoding declaration. Implementors of character-encoding routines should
+be careful to ensure the accuracy of the internal and external information
+used to label the entity.</p></div><div class="div2"> <h3><a name="sec-guessing-with-ext-info" id="sec-guessing-with-ext-info" />E.2 Priorities in the Presence of External Encoding Information</h3><p>The second possible case occurs when the XML entity is accompanied by encoding
+information, as in some file systems and some network protocols. When multiple
+sources of information are available, their relative priority and the preferred
+method of handling conflict should be specified as part of the higher-level
+protocol used to deliver XML. In particular, please refer
+to <a href="#rfc2376">[IETF RFC 3023]</a> or its successor, which defines the <code>text/xml</code>
+and <code>application/xml</code> MIME types and provides some useful guidance.
+In the interests of interoperability, however, the following rule is recommended.</p><ul><li><p>If an XML entity is in a file, the Byte-Order Mark and encoding declaration are used
+(if present) to determine the character encoding.</p></li></ul></div></div><div class="div1"> <h2><a name="sec-xml-wg" id="sec-xml-wg" />F W3C XML Working Group (Non-Normative)</h2><p>This specification was prepared and approved for publication by the W3C
+XML Working Group (WG). WG approval of this specification does not necessarily
+imply that all WG participants voted for its approval. The current and former members
+in the XML WG are:</p><ul><li>Jon Bosak, Sun (<i>Chair</i>) </li><li>James Clark (<i>Technical Lead</i>) </li><li>Tim Bray, Textuality and Netscape (<i>XML Co-editor</i>) </li><li>Jean Paoli, Microsoft (<i>XML
+Co-editor</i>) </li><li>C. M. Sperberg-McQueen, U. of Ill. (<i>XML Co-editor</i>) </li><li>Dan Connolly, W3C (<i>W3C Liaison</i>) </li><li>Paula Angerstein, Texcel</li><li>Steve DeRose, INSO</li><li>Dave Hollander, HP</li><li>Eliot Kimber, ISOGEN</li><li>Eve Maler, ArborText</li><li>Tom Magliery, NCSA</li><li>Murray Maloney, SoftQuad, Grif
+SA, Muzmo and Veo Systems</li><li>MURATA Makoto (FAMILY Given), Fuji
+Xerox Information Systems</li><li>Joel Nava, Adobe</li><li>Conleth O'Connell, Vignette</li><li>Peter Sharpe, SoftQuad</li><li>John Tigue, DataChannel</li></ul></div><div class="div1"> <h2><a name="sec-core-wg" id="sec-core-wg" />G W3C XML Core <span>Working</span> Group (Non-Normative)</h2><p>The present edition of this specification was prepared by the W3C XML Core
+Working Group (WG). The participants in the WG at the time of publication of this
+edition were:</p><ul><li>Leonid Arbouzov, Sun Microsystems</li><li>Mary Brady</li><li>John Cowan (<i>XML 1.1 First Edition Editor</i>) </li><li>John Evdemon, Microsoft</li><li>Andrew Fang, Arbortext</li><li>Paul Grosso, Arbortext (<i>Co-Chair</i>) </li><li>Arnaud Le Hors, IBM</li><li>Dmitry Lenkov, Oracle</li><li>Anjana Manian, Oracle</li><li>Glenn Marcy, IBM</li><li>Jonathan Marsh, Microsoft</li><li>Sandra Martinez, NIST</li><li>Liam Quin, W3C (<i>Staff Contact</i>) </li><li>Lew Shannon</li><li>Richard Tobin, University of Edinburgh</li><li>Daniel Veillard</li><li>Norman Walsh, Sun Microsystems (<i>Co-Chair</i>) </li><li>François Yergeau</li></ul></div><div class="div1"> <h2><a name="prod-notes" id="prod-notes" />H Production Notes (Non-Normative)</h2><p>This edition was encoded in a
+slightly modified version of the
+<a href="http://www.w3.org/2002/xmlspec/dtd/2.5/xmlspec.dtd">XMLspec DTD, 2.5</a>.
+The XHTML versions were produced with a combination of the
+<a href="http://www.w3.org/2002/xmlspec/xhtml/1.9/xmlspec.xsl">xmlspec.xsl</a>,
+<a href="http://www.w3.org/2002/xmlspec/xhtml/1.9/diffspec.xsl">diffspec.xsl</a>,
+and <a href="REC-xml-3e.xsl">REC-xml-3e.xsl</a>
+XSLT stylesheets.</p></div><div class="div1"> <h2><a name="sec-suggested-names" id="sec-suggested-names" />I Suggestions for XML Names (Non-Normative)</h2><p>The following suggestions define what is believed to be best
+practice in the construction of XML names used as element names,
+attribute names, processing instruction targets, entity names,
+notation names, and the values of attributes of type ID, and are
+intended as guidance for document authors and schema designers.
+All references to Unicode are understood with respect to
+a particular version of the Unicode Standard greater than or equal
+to 3.0; which version should be used is left to the discretion of
+the document author or schema designer.</p><p>The first two suggestions are directly derived from the rules
+given for identifiers in the Unicode Standard, version 3.0, and
+exclude all control characters, enclosing nonspacing marks,
+non-decimal numbers, private-use characters, punctuation characters
+(with the noted exceptions), symbol characters, unassigned
+codepoints, and white space characters. The other suggestions
+are mostly derived from <a href="#XML1.0">[XML-1.0]</a> Appendix B.</p><ol type="1"><li><p>The first character of any name should have a Unicode General
+Category of Ll, Lu, Lo, Lm, Lt, or Nl, or else be '_' #x5F.</p></li><li><p>Characters other than the first should have a Unicode General
+Category of Ll, Lu, Lo, Lm, Lt, Mc, Mn, Nl, Nd, Pc, or Cf, or else
+be one of the following: '-' #x2D, '.' #x2E, ':' #x3A or
+'·' #xB7 (middle dot). Since Cf characters are not
+directly visible, they should be employed with caution and only
+when necessary, to avoid creating names which are distinct to XML
+processors but look the same to human beings.</p></li><li><p>Ideographic characters which have a canonical decomposition
+(including those in the ranges [#xF900-#xFAFF] and
+[#x2F800-#x2FFFD], with 12 exceptions) should not be used in names.
+</p></li><li><p>Characters which have a compatibility decomposition (those with
+a "compatibility formatting tag" in field 5 of the Unicode
+Character Database -- marked by field 5 beginning with a "&lt;")
+should not be used in names.  This suggestion does not apply
+to #x0E33 THAI CHARACTER SARA AM or #x0EB3 LAO CHARACTER AM, which
+despite their compatibility decompositions are in regular use in
+those scripts.</p></li><li><p>Combining characters meant for use with symbols only (including
+those in the ranges [#x20D0-#x20EF] and [#x1D165-#x1D1AD]) should
+not be used in names.</p></li><li><p>The interlinear annotation characters ([#xFFF9-#xFFFB) should
+not be used in names.</p></li><li><p>Variation selector characters should not be used in names.</p></li><li><p>Names which are nonsensical, unpronounceable, hard to read, or
+easily confusable with other names should not be employed.</p></li></ol></div></div></body></html>
diff --git a/mkincs.sh b/mkincs.sh
new file mode 100755
index 0000000..6f72f89
--- /dev/null
+++ b/mkincs.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+cd src/bu
+rm *
+for i in ../*.h; do ln -s $i; done
diff --git a/src/archival.cpp b/src/archival.cpp
new file mode 100644
index 0000000..79c28f1
--- /dev/null
+++ b/src/archival.cpp
@@ -0,0 +1,10 @@
+#include "archival.h"
+Bu::Archival::Archival()
+{
+}
+Bu::Archival::~Archival()
+{
+}
diff --git a/src/archival.h b/src/archival.h
new file mode 100644
index 0000000..8be3308
--- /dev/null
+++ b/src/archival.h
@@ -0,0 +1,38 @@
+#ifndef BU_ARCHIVAL_H
+#define BU_ARCHIVAL_H
+namespace Bu
+{
+        /**
+         * The base class for any class you want to archive.  Simply include this as
+         * a base class, implement the purely virtual archive function and you've
+         * got an easily archiveable class.
+         *
+         * Archival: "of or pertaining to archives or valuable records; contained
+         * in or comprising such archives or records."
+         */
+        class Archival
+        {
+        public:
+                /**
+                 * Does nothing, here for completeness.
+                 */
+                Archival();
+                /**
+                 * Here to ensure the deconstructor is virtual.
+                 */
+                virtual ~Archival();
+                /**
+                 * This is the main workhorse of the archive system, just override and
+                 * you've got a archiveable class.  A reference to the Archive
+                 * used is passed in as your only parameter, query it to discover if
+                 * you are loading or saving.
+                 * @param ar A reference to the Archive object to use.
+                 */
+                virtual void archive( class Archive &ar )=0;
+        };
+}
+#endif
diff --git a/src/archive.cpp b/src/archive.cpp
new file mode 100644
index 0000000..7208bae
--- /dev/null
+++ b/src/archive.cpp
@@ -0,0 +1,386 @@
+#include "archive.h"
+Bu::Archive::Archive( Stream &rStream, bool bLoading ) :
+        bLoading( bLoading ),
+        rStream( rStream ),
+        nNextID( 1 )
+{
+}
+Bu::Archive::~Archive()
+{
+}
+void Bu::Archive::write( const void *pData, int32_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+        
+        rStream.write( (const char *)pData, nSize );
+}
+void Bu::Archive::read( void *pData, int32_t nSize )
+{
+        if( nSize == 0 || pData == NULL )
+                return;
+        rStream.read( (char *)pData, nSize );
+}
+void Bu::Archive::close()
+{
+        rStream.close();
+}
+bool Bu::Archive::isLoading()
+{
+        return bLoading;
+}
+Bu::Archive &Bu::Archive::operator<<(bool p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int8_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int16_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int32_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(int64_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint8_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint16_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint32_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(uint64_t p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(long p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(float p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(double p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator<<(long double p)
+{
+        write( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(bool &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int8_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int16_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int32_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(int64_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint8_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint16_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint32_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(uint64_t &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(long &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(float &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(double &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator>>(long double &p)
+{
+        read( &p, sizeof(p) );
+        return *this;
+}
+Bu::Archive &Bu::Archive::operator&&(bool &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(int8_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(int16_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(int32_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(int64_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(uint8_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(uint16_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(uint32_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(uint64_t &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(float &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(double &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::Archive::operator&&(long double &p)
+{
+        if (bLoading)
+        {
+                return *this >> p;
+        }
+        else
+        {
+                return *this << p;
+        }
+}
+Bu::Archive &Bu::operator<<(Bu::Archive &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+Bu::Archive &Bu::operator>>(Bu::Archive &s, Bu::Archival &p)
+{
+        p.archive( s );
+        return s;
+}
+Bu::Archive &Bu::operator<<( Bu::Archive &ar, std::string &s )
+{
+        ar << (uint32_t)s.length();
+        ar.write( s.c_str(), s.length() );
+        return ar;
+}
+Bu::Archive &Bu::operator>>( Bu::Archive &ar, std::string &s )
+{
+        uint32_t l;
+        ar >> l;
+        char *tmp = new char[l+1];
+        tmp[l] = '\0';
+        ar.read( tmp, l );
+        s = tmp;
+        delete[] tmp;
+        return ar;
+}
+uint32_t Bu::Archive::getID( const void *ptr )
+{
+        if( hPtrID.has( (int)ptr ) )
+                return hPtrID.get( (int)ptr );
+        hPtrID.insert( (int)ptr, nNextID );
+        return nNextID++;
+}
+void Bu::Archive::assocPtrID( void **ptr, uint32_t id )
+{
+        if( hPtrID.has( id ) )
+        {
+                *ptr = (void *)hPtrID.get( id );
+                return;
+        }
+        if( !hPtrDest.has( id ) )
+                hPtrDest.insert( id, List<void **>() );
+                        
+        hPtrDest[id].value().append( ptr );
+}
+void Bu::Archive::readID( const void *ptr, uint32_t id )
+{
+        hPtrID.insert( id, (int)ptr );
+        if( hPtrDest.has( id ) )
+        {
+                Bu::List<void **> &l = hPtrDest.get( id );
+                for( Bu::List<void **>::iterator i = l.begin(); i != l.end(); i++ )
+                {
+                        *(*i) = (void *)ptr;
+                }
+                hPtrDest.erase( id );
+        }
+}
diff --git a/src/archive.h b/src/archive.h
new file mode 100644
index 0000000..a2d4c8f
--- /dev/null
+++ b/src/archive.h
@@ -0,0 +1,212 @@
+#ifndef BU_ARCHIVE_H
+#define BU_ARCHIVE_H
+#include <stdint.h>
+#include <string>
+#include "bu/archival.h"
+#include "bu/stream.h"
+#include <list>
+#include "bu/hash.h"
+#include "bu/list.h"
+namespace Bu
+{
+        /**
+         * Provides a framework for serialization of objects and primitives.  The
+         * archive will handle any basic primitive, a few special types, like char *
+         * strings, as well as STL classes and anything that inherits from the
+         * Archival class.  Each Archive operates on a Stream, so you can send the
+         * data using an Archive almost anywhere.
+         *
+         * In order to use an Archive to store something to a file, try something
+         * like:
+         *@code
+     * File sOut("output", "wb"); // This is a stream subclass
+         * Archive ar( sOut, Archive::save );
+         * ar << myClass;
+         @endcode
+         * In this example myClass is any class that inherits from Archival.  When
+         * the storage operator is called, the Archival::archive() function in the
+         * myClass object is called with a reference to the Archive.  This can be
+         * handled in one of two ways:
+         *@code
+         * void MyClass::archive( Archive &ar )
+         * {
+         *      ar && sName && nAge && sJob;
+         * }
+         @endcode
+         * Here we don't worry about weather we're loading or saving by using the
+         * smart && operator.  This allows us to write very consistent, very simple
+         * archive functions that really do a lot of work.  If we wanted to do
+         * something different in the case of loading or saving we would do:
+         *@code
+         * void MyClass::archive( Archive &ar )
+         * {
+         *      if( ar.isLoading() )
+         *      {
+         *              ar >> sName >> nAge >> sJob;
+         *      } else
+         *      {
+         *              ar << sName << nAge << sJob;
+         *      }
+         * }
+         @endcode
+         * Archive currently does not provide facility to make fully portable
+         * archives.  For example, it will not convert between endianness for you,
+         * nor will it take into account differences between primitive sizes on
+         * different platforms.  This, at the moment, is up to the user to ensure.
+         * One way of dealing with the latter problem is to make sure and use
+         * explicit primitive types from the stdint.h header, i.e. int32_t.
+         */
+        class Archive
+        {
+        private:
+                bool bLoading;
+        public:
+                bool isLoading();
+                enum
+                {
+                        load    =       true,
+                        save    =       false
+                };
+                
+                Archive( Stream &rStream, bool bLoading );
+                virtual ~Archive();
+                virtual void close();
+                virtual void write(const void *, int32_t);
+                virtual void read(void *, int32_t);
+                
+                virtual Archive &operator<<(bool);
+                virtual Archive &operator<<(int8_t);
+                virtual Archive &operator<<(int16_t);
+                virtual Archive &operator<<(int32_t);
+                virtual Archive &operator<<(int64_t);
+                virtual Archive &operator<<(uint8_t);
+                virtual Archive &operator<<(uint16_t);
+                virtual Archive &operator<<(uint32_t);
+                virtual Archive &operator<<(uint64_t);
+                virtual Archive &operator<<(long);
+                virtual Archive &operator<<(float);
+                virtual Archive &operator<<(double);
+                virtual Archive &operator<<(long double);
+                virtual Archive &operator>>(bool &);
+                virtual Archive &operator>>(int8_t &);
+                virtual Archive &operator>>(int16_t &);
+                virtual Archive &operator>>(int32_t &);
+                virtual Archive &operator>>(int64_t &);
+                virtual Archive &operator>>(uint8_t &);
+                virtual Archive &operator>>(uint16_t &);
+                virtual Archive &operator>>(uint32_t &);
+                virtual Archive &operator>>(uint64_t &);
+                virtual Archive &operator>>(long &);
+                virtual Archive &operator>>(float &);
+                virtual Archive &operator>>(double &);
+                virtual Archive &operator>>(long double &);
+                
+                virtual Archive &operator&&(bool &);
+                virtual Archive &operator&&(int8_t &);
+                virtual Archive &operator&&(int16_t &);
+                virtual Archive &operator&&(int32_t &);
+                virtual Archive &operator&&(int64_t &);
+                virtual Archive &operator&&(uint8_t &);
+                virtual Archive &operator&&(uint16_t &);
+                virtual Archive &operator&&(uint32_t &);
+                virtual Archive &operator&&(uint64_t &);
+                virtual Archive &operator&&(float &);
+                virtual Archive &operator&&(double &);
+                virtual Archive &operator&&(long double &);
+                uint32_t getID( const void *ptr );
+                void assocPtrID( void **ptr, uint32_t id );
+                void readID( const void *ptr, uint32_t id );
+        private:
+                Stream &rStream;
+                uint32_t nNextID;
+                Hash<uint32_t,uint32_t> hPtrID;
+                Hash<uint32_t,List<void **> > hPtrDest;
+        };
+        Archive &operator<<(Archive &, class Bu::Archival &);
+        Archive &operator>>(Archive &, class Bu::Archival &);
+        //Archive &operator&&(Archive &s, class Bu::Archival &p);
+        Archive &operator<<(Archive &, std::string &);
+        Archive &operator>>(Archive &, std::string &);
+        //Archive &operator&&(Archive &, std::string &);
+        
+        template<typename T> Archive &operator&&( Archive &ar, T &dat )
+        {
+                if( ar.isLoading() )
+                {
+                        return ar >> dat;
+                }
+                else
+                {
+                        return ar << dat;
+                }
+        }
+        template<typename T> Archive &operator<<( Archive &ar, std::list<T> &l )
+        {
+                typename std::list<T>::size_type num = l.size();
+                ar << num;
+                for( typename std::list<T>::const_iterator i = l.begin(); i != l.end();
+                         i++ )
+                {
+                        ar << *i;
+                }
+                return ar;
+        }
+        template<typename T> Archive &operator>>( Archive &ar, std::list<T> &l )
+        {
+                typename std::list<T>::size_type num;
+                ar >> num;
+                l.resize( num );
+                for( typename std::list<T>::const_iterator i = l.begin();
+                         i != l.end(); i++ )
+                {
+                        ar >> *i;
+                }
+                return ar;
+        }
+        template<typename key, typename value>
+        Archive &operator<<( Archive &ar, Hash<key,value> &h )
+        {
+                ar << h.size();
+                for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
+                {
+                        //std::pair<key,value> p = *i;
+                        ar << (i.getKey()) << (i.getValue());
+                }
+                return ar;
+        }
+        template<typename key, typename value>
+        Archive &operator>>( Archive &ar, Hash<key,value> &h )
+        {
+                h.clear();
+                uint32_t nSize;
+                ar >> nSize;
+                for( uint32_t j = 0; j < nSize; j++ )
+                {
+                        key k; value v;
+                        ar >> k >> v;
+                        h.insert( k, v );
+                }
+                return ar;
+        }
+}
+#endif
diff --git a/src/arraylist.cpp b/src/arraylist.cpp
deleted file mode 100644
index ef21426..0000000
--- a/src/arraylist.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-#include "arraylist.h"
-#include <stdlib.h>
-#include <string.h>
-ArrayList::ArrayList( int initSize, int growByFactor )
-{
-        apData = new void *[initSize];
-        nSize = 0;
-        nCapacity = initSize;
-        nGrowByFactor = growByFactor;
-}
-ArrayList::~ArrayList(  )
-{
-        delete[] apData;
-}
-void *ArrayList::getAt( int index )
-{
-        if( index < 0 || index > nSize )
-                return NULL;
-        return apData[index];
-}
-void ArrayList::append( void *data )
-{
-        insertBefore( data, nSize );
-}
-void ArrayList::insertBefore( void *data, int pos )
-{
-        if( pos < 0 || pos > nSize )
-                return;
-        checkResize();
-        memmove( &apData[pos+1], &apData[pos], (nSize-pos)*sizeof(void*) );
-        apData[pos] = data;
-        nSize++;
-}
-int ArrayList::getSize(  )
-{
-        return nSize;
-}
-bool ArrayList::isEmpty(  )
-{
-        return nSize==0;
-}
-void ArrayList::deleteAt( int index )
-{
-        if( index < 0 || index >= nSize )
-                return;
-        memmove( &apData[index], &apData[index+1], (nSize-index-1)*sizeof(void *) );
-        nSize--;
-}
-void ArrayList::empty()
-{
-        // Probably the easiest as far as things go.
-        nSize = 0;
-}
-void ArrayList::resizeTo( int newSize )
-{
-        void **apNew = new void *[newSize];
-        memmove( apNew, apData, nSize*sizeof(void *) );
-        nCapacity = newSize;
-        delete[] apData;
-        apData = apNew;
-}
-void ArrayList::checkResize()
-{
-        if( nSize >= nCapacity )
-        {
-                resizeTo( nCapacity + nGrowByFactor );
-        }
-}
-void ArrayList::setSize( int newSize )
-{
-        if( newSize < 0 )
-                return;
-        nSize = newSize;
-        checkResize();
-}
-void ArrayList::setAt( int index, void *data )
-{
-        if( index < 0 || index >= nSize )
-                return;
-        apData[index] = data;
-}
diff --git a/src/arraylist.h b/src/arraylist.h
deleted file mode 100644
index 0fda34a..0000000
--- a/src/arraylist.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/** \file arraylist.h
- * Describes the ArrayList class.
- *@author Mike Buland
- */
-#ifndef ARRAY_LIST_H
-#define ARRAY_LIST_H
-#include "list.h"
-/** A simple list which uses an array.  This is a great choice if you won't do
-  * a lot of adding and deleting and need a fast random access list.  Otherwise
-  * use the LinkedList.
-  *@author Mike Buland
-  */
-class ArrayList : public List
-{
-public:
-        /** Creates an arraylist with some pre-defined specs spelled out.
-          *@param initSize the inital number of elements to allocate.
-          *@param growByFactor How much to increase the size of the array by
-          * each time we run out of room.
-          */
-        ArrayList( int initSize=100, int growByFactor=10 );
-        /**
-         * Destroy the ArrayList
-         */
-        virtual ~ArrayList();
-        void *getAt( int nIndex );
-        void append( void *pData );
-        void insertBefore( void *pData, int nPos = 0 );
-        int getSize(  );
-        bool isEmpty(  );
-        void deleteAt( int nIndex );
-        void empty();
-        void setSize( int nNewSize );
-        void setAt( int nIndex, void *pData );
-private:
-        /**
-         * Checks to see if the system needs to be resized, if it does, this will
-         * automatically resize based on your parameters.
-         */
-        void checkResize();
-        /**
-         * Resize the system to a specified size.  If it is larger, then all data
-         * will be retained, if smaller the elements at the end will be cut off.
-         *@param newSize The number of elements to include after resizing.
-         */
-        void resizeTo( int newSize );
-        /**
-         * Actual master array of pointers.  This is done to follow the List specs.
-         * All data transactions are performed with pointers or compatable
-         * primitive data-types.
-         */
-        void **apData;
-        /**
-         * The number of filled in elements in the array.  This is the practical
-         * real size of the ArrayList for all userspace applications.
-         */
-        int nSize;
-        /**
-         * The number of elements allocated in memory.  Not all of these have to be
-         * filled in, and it is usually larger than nSize so that adding and
-         * deleting elements is fast and easy.
-         */
-        int nCapacity;
-        /**
-         * The amount to grow by whenever the array needs resizing.
-         */
-        int nGrowByFactor;
-};
-#endif
diff --git a/src/atom.cpp b/src/atom.cpp
new file mode 100644
index 0000000..f966bfc
--- /dev/null
+++ b/src/atom.cpp
@@ -0,0 +1 @@
+#include "bu/atom.h"
diff --git a/src/atom.h b/src/atom.h
new file mode 100644
index 0000000..fad47eb
--- /dev/null
+++ b/src/atom.h
@@ -0,0 +1,107 @@
+#ifndef BU_ATOM_H
+#define BU_ATOM_H
+#include <stdint.h>
+#include <memory>
+#include "bu/exceptions.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        template <typename t, typename talloc=std::allocator<t> >
+        class Atom
+        {
+        private:
+                typedef struct Atom<t, talloc> MyType;
+        public:
+                Atom() :
+                        pData( NULL )
+                {
+                }
+                virtual ~Atom()
+                {
+                        clear();
+                }
+                bool has() const
+                {
+                        return (pData != NULL);
+                }
+                void set( const t &val )
+                {
+                        clear();
+                        pData = ta.allocate( 1 );
+                        ta.construct( pData, val );
+                }
+                t &get()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+                const t &get() const
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+                void clear()
+                {
+                        if( pData )
+                        {
+                                ta.destroy( pData );
+                                ta.deallocate( pData, 1 );
+                                pData = NULL;
+                        }
+                }
+                operator const t &() const
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+                
+                operator t &()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+                MyType &operator =( const t &oth )
+                {
+                        set( oth );
+                        return *this;
+                }
+                t *operator ->()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return pData;
+                }
+                t &operator *()
+                {
+                        if( !pData )
+                                throw Bu::ExceptionBase("Not set");
+                        return *pData;
+                }
+        private:
+                t *pData;
+                talloc ta;
+        };
+}
+#endif
diff --git a/src/bzip2.cpp b/src/bzip2.cpp
new file mode 100644
index 0000000..fbe5712
--- /dev/null
+++ b/src/bzip2.cpp
@@ -0,0 +1,196 @@
+#include "bu/bzip2.h"
+#include "bu/exceptions.h"
+using namespace Bu;
+Bu::BZip2::BZip2( Bu::Stream &rNext, int nCompression ) :
+        Bu::Filter( rNext ),
+        nCompression( nCompression )
+{
+        start();
+}
+Bu::BZip2::~BZip2()
+{
+        stop();
+}
+void Bu::BZip2::start()
+{
+        bzState.state = NULL;
+        bzState.bzalloc = NULL;
+        bzState.bzfree = NULL;
+        bzState.opaque = NULL;
+        nBufSize = 50000;
+        pBuf = new char[nBufSize];
+}
+size_t Bu::BZip2::stop()
+{
+        if( bzState.state )
+        {
+                if( bReading )
+                {
+                        BZ2_bzDecompressEnd( &bzState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        return 0;
+                }
+                else
+                {
+                        size_t sTotal = 0;
+                        for(;;)
+                        {
+                                bzState.next_in = NULL;
+                                bzState.avail_in = 0;
+                                bzState.avail_out = nBufSize;
+                                bzState.next_out = pBuf;
+                                int res = BZ2_bzCompress( &bzState, BZ_FINISH );
+                                if( bzState.avail_out < nBufSize )
+                                {
+                                        sTotal += rNext.write( pBuf, nBufSize-bzState.avail_out );
+                                }
+                                if( res == BZ_STREAM_END )
+                                        break;
+                        }
+                        BZ2_bzCompressEnd( &bzState );
+                        delete[] pBuf;
+                        pBuf = NULL;
+                        return sTotal;
+                }
+        }
+        return 0;
+}
+void Bu::BZip2::bzError( int code )
+{
+        switch( code )
+        {
+                case BZ_OK:
+                case BZ_RUN_OK:
+                case BZ_FLUSH_OK:
+                case BZ_FINISH_OK:
+                        return;
+                case BZ_CONFIG_ERROR:
+                        throw ExceptionBase("BZip2: Library configured improperly, reinstall.");
+                case BZ_SEQUENCE_ERROR:
+                        throw ExceptionBase("BZip2: Functions were called in an invalid sequence.");
+                case BZ_PARAM_ERROR:
+                        throw ExceptionBase("BZip2: Invalid parameter was passed into a function.");
+                case BZ_MEM_ERROR:
+                        throw ExceptionBase("BZip2: Couldn't allocate sufficient memory.");
+                case BZ_DATA_ERROR:
+                        throw ExceptionBase("BZip2: Data was corrupted before decompression.");
+                case BZ_DATA_ERROR_MAGIC:
+                        throw ExceptionBase("BZip2: Stream does not appear to be bzip2 data.");
+                case BZ_IO_ERROR:
+                        throw ExceptionBase("BZip2: File couldn't be read from / written to.");
+                case BZ_UNEXPECTED_EOF:
+                        throw ExceptionBase("BZip2: End of file encountered before end of stream.");
+                case BZ_OUTBUFF_FULL:
+                        throw ExceptionBase("BZip2: Buffer not large enough to accomidate data.");
+                default:
+                        throw ExceptionBase("BZip2: Unknown error encountered.");
+        
+        }
+}
+size_t Bu::BZip2::read( void *pData, size_t nBytes )
+{
+        if( !bzState.state )
+        {
+                bReading = true;
+                BZ2_bzDecompressInit( &bzState, 0, 0 );
+                bzState.next_in = pBuf;
+                bzState.avail_in = 0;
+        }
+        if( bReading == false )
+                throw ExceptionBase("This bzip2 filter is in writing mode, you can't read.");
+        int nRead = 0;
+        int nReadTotal = bzState.total_out_lo32;
+        bzState.next_out = (char *)pData;
+        bzState.avail_out = nBytes;
+        for(;;)
+        {
+                int ret = BZ2_bzDecompress( &bzState );
+        
+                nReadTotal += nRead-bzState.avail_out;
+                if( ret == BZ_STREAM_END )
+                {
+                        if( bzState.avail_in > 0 )
+                        {
+                                if( rNext.isSeekable() )
+                                {
+                                        rNext.seek( -bzState.avail_in );
+                                }
+                        }
+                        return nBytes-bzState.avail_out;
+                }
+                bzError( ret );
+                if( bzState.avail_out )
+                {
+                        if( bzState.avail_in == 0 )
+                        {
+                                nRead = rNext.read( pBuf, nBufSize );
+                                bzState.next_in = pBuf;
+                                bzState.avail_in = nRead;
+                        }
+                }
+                else
+                {
+                        return nBytes-bzState.avail_out;
+                }
+        }
+        return 0;
+}
+size_t Bu::BZip2::write( const void *pData, size_t nBytes )
+{
+        if( !bzState.state )
+        {
+                bReading = false;
+                BZ2_bzCompressInit( &bzState, nCompression, 0, 30 );
+        }
+        if( bReading == true )
+                throw ExceptionBase("This bzip2 filter is in reading mode, you can't write.");
+        size_t sTotalOut = 0;
+        bzState.next_in = (char *)pData;
+        bzState.avail_in = nBytes;
+        for(;;)
+        {
+                bzState.avail_out = nBufSize;
+                bzState.next_out = pBuf;
+                bzError( BZ2_bzCompress( &bzState, BZ_RUN ) );
+                if( bzState.avail_out < nBufSize )
+                {
+                        sTotalOut += rNext.write( pBuf, nBufSize-bzState.avail_out );
+                }
+                if( bzState.avail_in == 0 )
+                        break;
+        }
+        return sTotalOut;
+}
+bool Bu::BZip2::isOpen()
+{
+        return (bzState.state != NULL);
+}
diff --git a/src/bzip2.h b/src/bzip2.h
new file mode 100644
index 0000000..0a111e8
--- /dev/null
+++ b/src/bzip2.h
@@ -0,0 +1,37 @@
+#ifndef BU_BZIP2_H
+#define BU_BZIP2_H
+#include <stdint.h>
+#include <bzlib.h>
+#include "bu/filter.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        class BZip2 : public Bu::Filter
+        {
+        public:
+                BZip2( Bu::Stream &rNext, int nCompression=9 );
+                virtual ~BZip2();
+                virtual void start();
+                virtual size_t stop();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+                virtual bool isOpen();
+        private:
+                void bzError( int code );
+                bz_stream bzState;
+                bool bReading;
+                int nCompression;
+                char *pBuf;
+                uint32_t nBufSize;
+        };
+}
+#endif
diff --git a/src/client.cpp b/src/client.cpp
new file mode 100644
index 0000000..8077b3d
--- /dev/null
+++ b/src/client.cpp
@@ -0,0 +1,206 @@
+#include "bu/client.h"
+#include "bu/socket.h"
+#include <stdlib.h>
+#include <errno.h>
+#include "bu/exceptions.h"
+#include "bu/protocol.h"
+/** Read buffer size. */
+#define RBS             (1024*2)
+Bu::Client::Client( Bu::Socket *pSocket ) :
+        pSocket( pSocket ),
+        pProto( NULL ),
+        nRBOffset( 0 )
+{
+}
+Bu::Client::~Client()
+{
+}
+void Bu::Client::processInput()
+{
+        char buf[RBS];
+        size_t nRead, nTotal=0;
+        for(;;)
+        {
+                nRead = pSocket->read( buf, nRead );
+                if( nRead < 0  )
+                {
+                        throw Bu::ConnectionException(
+                                excodeReadError,
+                                "Read error: %s",
+                                strerror( errno )
+                                );
+                }
+                else if( nRead == 0 )
+                {
+                        break;
+                }
+                else
+                {
+                        nTotal += nRead;
+                        sReadBuf.append( buf, nRead );
+                        if( !pSocket->canRead() )
+                                break;
+                }
+        }
+        if( nTotal == 0 )
+        {
+                pSocket->close();
+        }
+        if( pProto && nTotal )
+        {
+                pProto->onNewData( this );
+        }
+}
+void Bu::Client::processOutput()
+{
+        if( sWriteBuf.getSize() > 0 )
+        {
+                pSocket->write( sWriteBuf.getStr(), sWriteBuf.getSize() );
+                sWriteBuf.clear();
+        }
+}
+void Bu::Client::setProtocol( Protocol *pProto )
+{
+        this->pProto = pProto;
+}
+Bu::Protocol *Bu::Client::getProtocol()
+{
+        return pProto;
+}
+void Bu::Client::clearProtocol()
+{
+        pProto = NULL;
+}
+Bu::FString &Bu::Client::getInput()
+{
+        return sReadBuf;
+}
+Bu::FString &Bu::Client::getOutput()
+{
+        return sWriteBuf;
+}
+bool Bu::Client::isOpen()
+{
+        if( !pSocket ) return false;
+        return pSocket->isOpen();
+}
+void Bu::Client::write( const void *pData, int nBytes )
+{
+        sWriteBuf.append( (const char *)pData, nBytes );
+}
+void Bu::Client::write( int8_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( int16_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( int32_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( int64_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( uint8_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( uint16_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( uint32_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::write( uint64_t nData )
+{
+        sWriteBuf.append( (const char *)&nData, sizeof(nData) );
+}
+void Bu::Client::read( void *pData, int nBytes )
+{
+        memcpy( pData, sReadBuf.getStr()+nRBOffset, nBytes );
+        nRBOffset += nBytes;
+        if( sReadBuf.getSize()-nRBOffset == 0 )
+        {
+                sReadBuf.clear();
+                nRBOffset = 0;
+        }
+        // This is an experimental threshold, maybe I'll make this configurable
+        // later on.
+        else if(
+                (sReadBuf.getSize() >= 1024 && nRBOffset >= sReadBuf.getSize()/2) ||
+                (nRBOffset >= sReadBuf.getSize()/4)
+                )
+        {
+                sReadBuf.trimFront( nRBOffset );
+                nRBOffset = 0;
+        }
+}
+void Bu::Client::peek( void *pData, int nBytes )
+{
+        memcpy( pData, sReadBuf.getStr()+nRBOffset, nBytes );
+}
+void Bu::Client::seek( int nBytes )
+{
+        nRBOffset += nBytes;
+        if( sReadBuf.getSize()-nRBOffset == 0 )
+        {
+                sReadBuf.clear();
+                nRBOffset = 0;
+        }
+        // This is an experimental threshold, maybe I'll make this configurable
+        // later on.
+        else if(
+                (sReadBuf.getSize() >= 1024 && nRBOffset >= sReadBuf.getSize()/2) ||
+                (nRBOffset >= sReadBuf.getSize()/4)
+                )
+        {
+                sReadBuf.trimFront( nRBOffset );
+                nRBOffset = 0;
+        }
+}
+long Bu::Client::getInputSize()
+{
+        return sReadBuf.getSize()-nRBOffset;
+}
+const Bu::Socket *Bu::Client::getSocket() const
+{
+        return pSocket;
+}
+void Bu::Client::disconnect()
+{
+}
diff --git a/src/client.h b/src/client.h
new file mode 100644
index 0000000..5947521
--- /dev/null
+++ b/src/client.h
@@ -0,0 +1,63 @@
+#ifndef BU_CLIENT_H
+#define BU_CLIENT_H
+#include <stdint.h>
+#include "bu/fstring.h"
+namespace Bu
+{
+        class Protocol;
+        class Socket;
+        /**
+         *
+         */
+        class Client
+        {
+        public:
+                Client( Bu::Socket *pSocket );
+                virtual ~Client();
+                void processInput();
+                void processOutput();
+                Bu::FString &getInput();
+                Bu::FString &getOutput();
+                void write( const void *pData, int nBytes );
+                void write( int8_t nData );
+                void write( int16_t nData );
+                void write( int32_t nData );
+                void write( int64_t nData );
+                void write( uint8_t nData );
+                void write( uint16_t nData );
+                void write( uint32_t nData );
+                void write( uint64_t nData );
+                void read( void *pData, int nBytes );
+                void peek( void *pData, int nBytes );
+                void seek( int nBytes );
+                long getInputSize();
+                void setProtocol( Protocol *pProto );
+                Bu::Protocol *getProtocol();
+                void clearProtocol();
+                bool isOpen();
+                const Bu::Socket *getSocket() const;
+                /**
+                 *@todo Make this not suck.
+                 */
+                void disconnect();
+        private:
+                Bu::Socket *pSocket;
+                Bu::Protocol *pProto;
+                Bu::FString sReadBuf;
+                int nRBOffset;
+                Bu::FString sWriteBuf;
+        };
+}
+#endif
diff --git a/src/entities/bu-class b/src/entities/bu-class
new file mode 100644
index 0000000..7b25291
--- /dev/null
+++ b/src/entities/bu-class
@@ -0,0 +1,48 @@
+<?xml version="1.1" ?>
+<entity desc="Basic cpp class, with optional parent class. (.cpp+.h)">
+        <param name="name" required="yes" desc="Name of the class"/>
+        <param name="parent" required="no" desc="Name of the parent class"/>
+        <file
+                name="header"
+                filename="{=name:%tolower}.h"
+>#ifndef {=name:%uccsplit:%toupper}_H
+#define {=name:%uccsplit:%toupper}_H
+#include &lt;stdint.h&gt;
+{?parent:"#include \"bu/{=parent:%tolower}.h\"
+"}namespace Bu
+{
+        /**
+         *
+         */
+        class {=name}{?parent:" : public {=parent}"}
+        {
+        public:
+                {=name}();
+                virtual ~{=name}();
+        private:
+        };
+}
+#endif
+</file>
+        <file
+                name="source"
+                filename="{=name:%tolower}.cpp"
+>#include "bu/{=name:%tolower}.h"
+using namespace Bu;
+Bu::{=name}::{=name}()
+{
+}
+Bu::{=name}::~{=name}()
+{
+}
+</file>
+</entity>
diff --git a/src/exceptionbase.cpp b/src/exceptionbase.cpp
index f3d22da..f6ec625 100644
--- a/src/exceptionbase.cpp
+++ b/src/exceptionbase.cpp
@@ -1,7 +1,7 @@
 #include "exceptionbase.h"
 #include <stdarg.h>
-ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
+Bu::ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
        nErrorCode( 0 ),
        sWhat( NULL )
 {
@@ -12,7 +12,7 @@ ExceptionBase::ExceptionBase( const char *lpFormat, ... ) throw() :
        va_end(ap);
 }
-ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
+Bu::ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
        nErrorCode( nCode ),
        sWhat( NULL )
 {
@@ -23,13 +23,13 @@ ExceptionBase::ExceptionBase( int nCode, const char *lpFormat, ... ) throw() :
        va_end(ap);
 }
-ExceptionBase::ExceptionBase( int nCode ) throw() :
+Bu::ExceptionBase::ExceptionBase( int nCode ) throw() :
        nErrorCode( nCode ),
        sWhat( NULL )
 {
 }
-ExceptionBase::~ExceptionBase() throw()
+Bu::ExceptionBase::~ExceptionBase() throw()
 {
        if( sWhat )
        {
@@ -38,7 +38,7 @@ ExceptionBase::~ExceptionBase() throw()
        }
 }
-void ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
+void Bu::ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
 {
        if( sWhat ) delete[] sWhat;
        int nSize;
@@ -48,7 +48,7 @@ void ExceptionBase::setWhat( const char *lpFormat, va_list &vargs )
        vsnprintf( sWhat, nSize+1, lpFormat, vargs );
 }
-void ExceptionBase::setWhat( const char *lpText )
+void Bu::ExceptionBase::setWhat( const char *lpText )
 {
        if( sWhat ) delete[] sWhat;
        int nSize;
@@ -58,12 +58,12 @@ void ExceptionBase::setWhat( const char *lpText )
        strcpy( sWhat, lpText );
 }
-const char *ExceptionBase::what() const throw()
+const char *Bu::ExceptionBase::what() const throw()
 {
        return sWhat;
 }
-int ExceptionBase::getErrorCode()
+int Bu::ExceptionBase::getErrorCode()
 {
        return nErrorCode;
 }
diff --git a/src/exceptionbase.h b/src/exceptionbase.h
index 6f1eca7..24e4bbf 100644
--- a/src/exceptionbase.h
+++ b/src/exceptionbase.h
@@ -1,75 +1,84 @@
-#ifndef EXCEPTION_BASE_H
+#ifndef BU_EXCEPTION_BASE_H
-#define EXCEPTION_BASE_H
+#define BU_EXCEPTION_BASE_H
 #include <string>
 #include <exception>
 #include <stdarg.h>
-/**
+namespace Bu
- * A generalized Exception base class.  This is nice for making general and
- * flexible child classes that can create new error code classes.
- */
-class ExceptionBase : public std::exception
 {
-public:
-        /**
-         * Construct an exception with an error code of zero, but with a
-         * description.  The use of this is not reccomended most of the time, it's
-         * generally best to include an error code with the exception so your
-         * program can handle the exception in a better way.
-         * @param sFormat The format of the text.  See printf for more info.
-         */
-        ExceptionBase( const char *sFormat, ... ) throw();
-        
        /**
+         * A generalized Exception base class.  This is nice for making general and
+         * flexible child classes that can create new error code classes.
+         *
+         * In order to create your own exception class use these two lines.
         * 
-         * @param nCode 
+         * in your header:  subExceptionDecl( NewClassName );
-         * @param sFormat
-         */
-        ExceptionBase( int nCode, const char *sFormat, ... ) throw();
-        
-        /**
         * 
-         * @param nCode 
+         * in your source:  subExcpetienDef( NewClassName );
-         * @return 
         */
-        ExceptionBase( int nCode=0 ) throw();
+        class ExceptionBase : public std::exception
-        
+        {
-        /**
+        public:
-         * 
+                /**
-         * @return 
+                 * Construct an exception with an error code of zero, but with a
-         */
+                 * description.  The use of this is not reccomended most of the time,
-        virtual ~ExceptionBase() throw();
+                 * it's generally best to include an error code with the exception so
+                 * your program can handle the exception in a better way.
+                 * @param sFormat The format of the text.  See printf for more info.
+                 */
+                ExceptionBase( const char *sFormat, ... ) throw();
+                
+                /**
+                 * 
+                 * @param nCode 
+                 * @param sFormat
+                 */
+                ExceptionBase( int nCode, const char *sFormat, ... ) throw();
+                
+                /**
+                 * 
+                 * @param nCode 
+                 * @return 
+                 */
+                ExceptionBase( int nCode=0 ) throw();
+                
+                /**
+                 * 
+                 * @return 
+                 */
+                virtual ~ExceptionBase() throw();
-        /**
+                /**
-         * 
+                 * 
-         * @return 
+                 * @return 
-         */
+                 */
-        virtual const char *what() const throw();
+                virtual const char *what() const throw();
-        
+                
-        /**
+                /**
-         * 
+                 * 
-         * @return 
+                 * @return 
-         */
+                 */
-        int getErrorCode();
+                int getErrorCode();
-        
+                
-        /**
+                /**
-         * 
+                 * 
-         * @param lpFormat 
+                 * @param lpFormat 
-         * @param vargs 
+                 * @param vargs 
-         */
+                 */
-        void setWhat( const char *lpFormat, va_list &vargs );
+                void setWhat( const char *lpFormat, va_list &vargs );
-        /**
+                /**
-         *
+                 *
-         * @param lpText
+                 * @param lpText
-         */
+                 */
-        void setWhat( const char *lpText );
+                void setWhat( const char *lpText );
-private:
+        private:
-        int nErrorCode; /**< The code for the error that occured. */
+                int nErrorCode; /**< The code for the error that occured. */
-        char *sWhat;    /**< The text string telling people what went wrong. */
+                char *sWhat;    /**< The text string telling people what went wrong. */
-};
+        };
+}
 #define subExceptionDecl( name )                                                                                        \
 class name : public ExceptionBase                                                                                       \
diff --git a/src/exceptions.cpp b/src/exceptions.cpp
index ce79a5e..50b95c3 100644
--- a/src/exceptions.cpp
+++ b/src/exceptions.cpp
@@ -1,8 +1,13 @@
 #include "exceptions.h"
 #include <stdarg.h>
-subExceptionDef( XmlException )
+namespace Bu
-subExceptionDef( FileException )
+{
-subExceptionDef( ConnectionException )
+        subExceptionDef( XmlException )
-subExceptionDef( PluginException )
+        subExceptionDef( TafException )
+        subExceptionDef( FileException )
+        subExceptionDef( SocketException )
+        subExceptionDef( ConnectionException )
+        subExceptionDef( PluginException )
+        subExceptionDef( UnsupportedException )
+}
diff --git a/src/exceptions.h b/src/exceptions.h
index 0ab2b15..b824b91 100644
--- a/src/exceptions.h
+++ b/src/exceptions.h
@@ -1,25 +1,32 @@
-#ifndef EXCEPTIONS_H
+#ifndef BU_EXCEPTIONS_H
-#define EXCEPTIONS_H
+#define BU_EXCEPTIONS_H
 #include "exceptionbase.h"
 #include <stdarg.h>
-subExceptionDecl( XmlException )
+namespace Bu
-subExceptionDecl( FileException )
-subExceptionDecl( ConnectionException )
-subExceptionDecl( PluginException )
-enum eFileException
-{
-        excodeEOF
-};
-        
-enum eConnectionException
 {
-        excodeReadError,
+        subExceptionDecl( XmlException )
-        excodeBadReadError,
+        subExceptionDecl( TafException )
-        excodeConnectionClosed,
+        subExceptionDecl( FileException )
-        excodeSocketTimeout
+        subExceptionDecl( SocketException )
-};
+        subExceptionDecl( ConnectionException )
+        subExceptionDecl( PluginException )
+        subExceptionDecl( UnsupportedException )
+        enum eFileException
+        {
+                excodeEOF
+        };
+                
+        enum eConnectionException
+        {
+                excodeReadError,
+                excodeWriteError,
+                excodeBadReadError,
+                excodeConnectionClosed,
+                excodeSocketTimeout
+        };
+}
 #endif
diff --git a/src/file.cpp b/src/file.cpp
new file mode 100644
index 0000000..1a8bd08
--- /dev/null
+++ b/src/file.cpp
@@ -0,0 +1,158 @@
+#include "file.h"
+#include "exceptions.h"
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+Bu::File::File( const char *sName, const char *sFlags )
+{
+        fh = fopen( sName, sFlags );
+        if( fh == NULL )
+        {
+                throw Bu::FileException( errno, strerror(errno) );
+        }
+}
+Bu::File::File( const Bu::FString &sName, const char *sFlags )
+{
+        fh = fopen( sName.getStr(), sFlags );
+        if( fh == NULL )
+        {
+                throw Bu::FileException( errno, strerror(errno) );
+        }
+}
+Bu::File::File( int fd, const char *sFlags )
+{
+        fh = fdopen( fd, sFlags );
+}
+Bu::File::~File()
+{
+        close();
+}
+void Bu::File::close()
+{
+        if( fh )
+        {
+                fclose( fh );
+                fh = NULL;
+        }
+}
+size_t Bu::File::read( void *pBuf, size_t nBytes )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        int nAmnt = fread( pBuf, 1, nBytes, fh );
+        //if( nAmnt == 0 )
+        //      throw FileException("End of file.");
+        return nAmnt;
+}
+size_t Bu::File::write( const void *pBuf, size_t nBytes )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        return fwrite( pBuf, 1, nBytes, fh );
+}
+long Bu::File::tell()
+{
+        if( !fh )
+                throw FileException("File not open.");
+        return ftell( fh );
+}
+void Bu::File::seek( long offset )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        fseek( fh, offset, SEEK_CUR );
+}
+void Bu::File::setPos( long pos )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        fseek( fh, pos, SEEK_SET );
+}
+void Bu::File::setPosEnd( long pos )
+{
+        if( !fh )
+                throw FileException("File not open.");
+        
+        fseek( fh, pos, SEEK_END );
+}
+bool Bu::File::isEOS()
+{
+        return feof( fh );
+}
+bool Bu::File::canRead()
+{
+        return true;
+}
+bool Bu::File::canWrite()
+{
+        return true;
+}
+bool Bu::File::isReadable()
+{
+        return true;
+}
+bool Bu::File::isWritable()
+{
+        return true;
+}
+bool Bu::File::isSeekable()
+{
+        return true;
+}
+bool Bu::File::isBlocking()
+{
+        return true;
+}
+void Bu::File::setBlocking( bool bBlocking )
+{
+        return;
+}
+#ifndef WIN32
+void Bu::File::truncate( long nSize )
+{
+        ftruncate( fileno( fh ), nSize );
+}
+void Bu::File::chmod( mode_t t )
+{
+        fchmod( fileno( fh ), t );
+}
+#endif
+void Bu::File::flush()
+{
+        fflush( fh );
+}
+bool Bu::File::isOpen()
+{
+        return (fh != NULL);
+}
diff --git a/src/file.h b/src/file.h
new file mode 100644
index 0000000..d4e43eb
--- /dev/null
+++ b/src/file.h
@@ -0,0 +1,78 @@
+#ifndef BU_FILE_H
+#define BU_FILE_H
+#include <stdint.h>
+#include "bu/stream.h"
+#include "bu/fstring.h"
+namespace Bu
+{
+        class File : public Bu::Stream
+        {
+        public:
+                File( const char *sName, const char *sFlags );
+                File( const Bu::FString &sName, const char *sFlags );
+                File( int fd, const char *sFlags );
+                virtual ~File();
+                virtual void close();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+                virtual void flush();
+                virtual bool canRead();
+                virtual bool canWrite();
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+                /**
+                 * Create a temp file and return its handle
+                 *@param sName (Bu::FString) Give in the form: "/tmp/tmpfileXXXXXXXX"
+                 *              It will alter your (sName) setting the 'X's to random
+                 *              characters.
+                 *@param sFlags (const char *) Standard file flags 'rb'... etc..
+                 *@returns (Bu::File) A file object representing your temp file.
+                 */
+#ifndef WIN32
+                inline static Bu::File tempFile( Bu::FString &sName, const char *sFlags )
+                {
+                        int afh_d = mkstemp( sName.getStr() );
+                        return Bu::File( afh_d, sFlags );
+                }
+                /**
+                 * Set the size of the file to (nSize). You can either grow or shrink
+                 *              the file.
+                 *@param nSize (long) The new size of the file.
+                 */
+                void truncate( long nSize );
+                /**
+                 * Change the file access permissions.
+                 *@param t (mode_t) The new file access permissions.
+                 */
+                void chmod( mode_t t );
+#endif
+        private:
+                FILE *fh;
+        };
+}
+#endif
diff --git a/src/filter.cpp b/src/filter.cpp
new file mode 100644
index 0000000..96a8694
--- /dev/null
+++ b/src/filter.cpp
@@ -0,0 +1,97 @@
+#include "bu/filter.h"
+Bu::Filter::Filter( Bu::Stream &rNext ) :
+        rNext( rNext )
+{
+}
+Bu::Filter::~Filter()
+{
+        //printf("-> Bu::Filter::~Filter()\n");         
+}
+/*
+void Bu::Filter::start()
+{
+        printf("-> Bu::Filter::start()\n");
+}
+void Bu::Filter::stop()
+{
+}*/
+void Bu::Filter::close()
+{
+        stop();
+        rNext.close();
+}
+long Bu::Filter::tell()
+{
+        return rNext.tell();
+}
+void Bu::Filter::seek( long offset )
+{
+        rNext.seek( offset );
+}
+void Bu::Filter::setPos( long pos )
+{
+        rNext.setPos( pos );
+}
+void Bu::Filter::setPosEnd( long pos )
+{
+        rNext.setPosEnd( pos );
+}
+bool Bu::Filter::isEOS()
+{
+        return rNext.isEOS();
+}
+bool Bu::Filter::isOpen()
+{
+        return rNext.isOpen();
+}
+bool Bu::Filter::canRead()
+{
+        return rNext.canRead();
+}
+bool Bu::Filter::canWrite()
+{
+        return rNext.canWrite();
+}
+bool Bu::Filter::isReadable()
+{
+        return rNext.isReadable();
+}
+bool Bu::Filter::isWritable()
+{
+        return rNext.isWritable();
+}
+bool Bu::Filter::isSeekable()
+{
+        return rNext.isSeekable();
+}
+bool Bu::Filter::isBlocking()
+{
+        return rNext.isBlocking();
+}
+void Bu::Filter::setBlocking( bool bBlocking )
+{
+        rNext.setBlocking( bBlocking );
+}
+void Bu::Filter::flush()
+{
+        rNext.flush();
+}
diff --git a/src/filter.h b/src/filter.h
new file mode 100644
index 0000000..bd557b2
--- /dev/null
+++ b/src/filter.h
@@ -0,0 +1,65 @@
+#ifndef BU_FILTER_H
+#define BU_FILTER_H
+#include <stdint.h>
+#include "bu/stream.h"
+namespace Bu
+{
+        /**
+         * Data filter base class.  Each data filter should contain a read and write
+         * section.  Effectively, the write applies the filter, the read un-applies
+         * the filter, if possible.  For example, BZip2 is a filter that compresses
+         * on write and decompresses on read.  All bi-directional filters should
+         * follow:  x == read( write( x ) ) (byte-for-byte comparison)
+         *
+         * Also, all returned buffers should be owned by the filter, and deleted
+         * when the filter is deleted.  This means that the output of a read or
+         * write operation must be used before the next call to read or write or the
+         * data will be destroyed.  Also, the internal buffer may be changed or
+         * recreated between calls, so always get a new pointer from a call to
+         * read or write.
+         *
+         * The close function can also return data, so make sure to check for it,
+         * many filters such as compression filters will buffer data until they have
+         * enough to create a compression block, in these cases the leftover data
+         * will be returned by close.
+         */
+        class Filter : public Bu::Stream
+        {
+        public:
+                Filter( Bu::Stream &rNext );
+                virtual ~Filter();
+                virtual void start()=0;
+                virtual size_t stop()=0;
+                virtual void close();
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+                virtual void flush();
+                virtual bool canRead();
+                virtual bool canWrite();
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+        protected:
+                Bu::Stream &rNext;
+        private:
+        };
+}
+#endif
diff --git a/src/fstring.cpp b/src/fstring.cpp
index 82d024d..f71d6c1 100644
--- a/src/fstring.cpp
+++ b/src/fstring.cpp
@@ -1,13 +1,20 @@
 #include "fstring.h"
 #include "hash.h"
-template<> uint32_t __calcHashCode<FString>( const FString &k )
+template<> uint32_t Bu::__calcHashCode<Bu::FString>( const Bu::FString &k )
 {
        return __calcHashCode( k.c_str() );
 }
-template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b )
+template<> bool Bu::__cmpHashKeys<Bu::FString>(
+                const Bu::FString &a, const Bu::FString &b )
 {
        return a == b;
 }
+std::basic_ostream<char>& operator<< (std::basic_ostream<char> &os, const Bu::FString &val )
+{
+        os.write( val.getStr(), val.getSize() );
+        return os;
+}
diff --git a/src/fstring.h b/src/fstring.h
index c5397cc..1e1fc02 100644
--- a/src/fstring.h
+++ b/src/fstring.h
@@ -1,651 +1,903 @@
-#ifndef F_STRING_H
+#ifndef BU_F_STRING_H
-#define F_STRING_H
+#define BU_F_STRING_H
 #include <stdint.h>
 #include <memory>
-#include "serializable.h"
+#include "bu/archival.h"
-#include "serializer.h"
+#include "bu/archive.h"
+#include "bu/hash.h"
-template< typename chr >
+#define min( a, b )  ((a<b)?(a):(b))
-struct FStringChunk
-{
+namespace Bu
-        long nLength;
-        chr *pData;
-        FStringChunk *pNext;
-};
-/**
- * Flexible String class.  This class was designed with string passing and
- * generation in mind.  Like the standard string class you can specify what
- * datatype to use for each character.  Unlike the standard string class,
- * collection of appended and prepended terms is done lazily, making long
- * operations that involve many appends very inexpensive.  In addition internal
- * ref-counting means that if you pass strings around between functions there's
- * almost no overhead in time or memory since a reference is created and no
- * data is actually copied.  This also means that you never need to put any
- * FBasicString into a ref-counting container class.
- */
-template< typename chr, typename chralloc=std::allocator<chr>, typename chunkalloc=std::allocator<struct FStringChunk<chr> > >
-class FBasicString : public Serializable
 {
+        template< typename chr >
+        struct FStringChunk
+        {
+                long nLength;
+                chr *pData;
+                FStringChunk *pNext;
+        };
+        /**
+         * Flexible String class.  This class was designed with string passing and
+         * generation in mind.  Like the standard string class you can specify what
+         * datatype to use for each character.  Unlike the standard string class,
+         * collection of appended and prepended terms is done lazily, making long
+         * operations that involve many appends very inexpensive.  In addition internal
+         * ref-counting means that if you pass strings around between functions there's
+         * almost no overhead in time or memory since a reference is created and no
+         * data is actually copied.  This also means that you never need to put any
+         * FBasicString into a ref-counting container class.
+         *
+         *@param chr (typename) Type of character (i.e. char)
+         *@param nMinSize (int) Chunk size (default: 256)
+         *@param chralloc (typename) Memory Allocator for chr
+         *@param chunkalloc (typename) Memory Allocator for chr chunks
+         */
+        template< typename chr, int nMinSize=256, typename chralloc=std::allocator<chr>, typename chunkalloc=std::allocator<struct FStringChunk<chr> > >
+        class FBasicString : public Archival
+        {
 #ifndef VALTEST
 #define cpy( dest, src, size ) memcpy( dest, src, size*sizeof(chr) )
 #endif
-private:
+        private:
-        typedef struct FStringChunk<chr> Chunk;
+                typedef struct FStringChunk<chr> Chunk;
-        typedef struct FBasicString<chr, chralloc, chunkalloc> MyType;
+                typedef struct FBasicString<chr, nMinSize, chralloc, chunkalloc> MyType;
-public:
+        public:
-        FBasicString() :
+                FBasicString() :
-                nLength( 0 ),
+                        nLength( 0 ),
-                pnRefs( NULL ),
+                        pnRefs( NULL ),
-                pFirst( NULL ),
+                        pFirst( NULL ),
-                pLast( NULL )
+                        pLast( NULL )
-        {
+                {
-        }
+                }
-        FBasicString( const chr *pData ) :
+                FBasicString( const chr *pData ) :
-                nLength( 0 ),
+                        nLength( 0 ),
-                pnRefs( NULL ),
+                        pnRefs( NULL ),
-                pFirst( NULL ),
+                        pFirst( NULL ),
-                pLast( NULL )
+                        pLast( NULL )
-        {
+                {
-                append( pData );
+                        append( pData );
-        }
+                }
-        FBasicString( const chr *pData, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( pData, nLength );
-        }
-        FBasicString( const MyType &rSrc ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                // Here we have no choice but to copy, since the other guy is a const.
-                // In the case that the source were flat, we could get a reference, it
-                // would make some things faster, but not matter in many other cases.
-                joinShare( rSrc );
-                //copyFrom( rSrc );
-        }
-        FBasicString( const MyType &rSrc, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( rSrc.pFirst->pData, nLength );
-        }
-        
-        FBasicString( const MyType &rSrc, long nStart, long nLength ) :
-                nLength( 0 ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                append( rSrc.pFirst->pData+nStart, nLength );
-        }
-        FBasicString( long nSize ) :
-                nLength( nSize ),
-                pnRefs( NULL ),
-                pFirst( NULL ),
-                pLast( NULL )
-        {
-                pFirst = pLast = newChunk( nSize );
-        }
-        virtual ~FBasicString()
+                FBasicString( const chr *pData, long nLength ) :
-        {
+                        nLength( 0 ),
-                clear();
+                        pnRefs( NULL ),
-        }
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( pData, nLength );
+                }
-        void append( const chr *pData )
+                FBasicString( const MyType &rSrc ) :
-        {
+                        nLength( 0 ),
-                long nLen;
+                        pnRefs( NULL ),
-                for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                        pFirst( NULL ),
-                
+                        pLast( NULL )
-                Chunk *pNew = newChunk( nLen );
+                {
-                cpy( pNew->pData, pData, nLen );
+                        // Here we have no choice but to copy, since the other guy is a const.
+                        // In the case that the source were flat, we could get a reference, it
+                        // would make some things faster, but not matter in many other cases.
-                appendChunk( pNew );
+                        joinShare( rSrc );
-        }
+                        //copyFrom( rSrc );
+                }
-        void append( const chr *pData, long nLen )
+                FBasicString( const MyType &rSrc, long nLength ) :
-        {
+                        nLength( 0 ),
-                Chunk *pNew = newChunk( nLen );
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( rSrc.pFirst->pData, nLength );
+                }
                
-                cpy( pNew->pData, pData, nLen );
+                FBasicString( const MyType &rSrc, long nStart, long nLength ) :
+                        nLength( 0 ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        append( rSrc.pFirst->pData+nStart, nLength );
+                }
-                appendChunk( pNew );
+                FBasicString( long nSize ) :
-        }
+                        nLength( nSize ),
+                        pnRefs( NULL ),
+                        pFirst( NULL ),
+                        pLast( NULL )
+                {
+                        pFirst = pLast = newChunk( nSize );
+                }
-        void prepend( const chr *pData )
+                virtual ~FBasicString()
-        {
+                {
-                long nLen;
+                        clear();
-                for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                }
-                
-                Chunk *pNew = newChunk( nLen );
-                cpy( pNew->pData, pData, nLen );
-                prependChunk( pNew );
+                /**
-        }
+                 *@todo void append( const MyType & sData )
+                 */
-        void prepend( const chr *pData, long nLen )
+                /**
-        {
+                 * Append data to your string.
-                Chunk *pNew = newChunk( nLen );
+                 *@param pData (const chr *) The data to append.
-                
+                 */
-                cpy( pNew->pData, pData, nLen );
+                void append( const chr *pData )
+                {
+                        if( !pData ) return;
+                        long nLen;
+                        for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                        if( nLen == 0 )
+                                return;
+                        
+                        Chunk *pNew = newChunk( nLen );
+                        cpy( pNew->pData, pData, nLen );
-                prependChunk( pNew );
+                        appendChunk( pNew );
-        }
+                }
-        void clear()
+                /**
-        {
+                 * Append data to your string.
-                realClear();
+                 *@param pData (const chr *) The data to append.
-        }
+                 *@param nLen (long) The length of the data to append.
+                 */
+                void append( const chr *pData, long nLen )
+                {
+                        if( nLen == 0 )
+                                return;
-        void resize( long nNewSize )
+                        Chunk *pNew = newChunk( nLen );
-        {
+                        
-                if( nLength == nNewSize )
+                        cpy( pNew->pData, pData, nLen );
-                        return;
-                flatten();
-                Chunk *pNew = newChunk( nNewSize );
-                long nNewLen = (nNewSize<nLength)?(nNewSize):(nLength);
-                cpy( pNew->pData, pFirst->pData, nNewLen );
-                pNew->pData[nNewLen] = (chr)0;
-                aChr.deallocate( pFirst->pData, pFirst->nLength+1 );
-                aChunk.deallocate( pFirst, 1 );
-                pFirst = pLast = pNew;
-                nLength = nNewSize;
-        }
-        long getSize() const
-        {
-                return nLength;
-        }
-        
-        chr *getStr()
-        {
-                if( pFirst == NULL )
-                        return NULL;
-                flatten();
-                return pFirst->pData;
-        }
-        
-        const chr *getStr() const
-        {
-                if( pFirst == NULL )
-                        return NULL;
-                flatten();
+                        appendChunk( pNew );
-                return pFirst->pData;
+                }
-        }
-        chr *c_str()
+                /**
-        {
+                 * Append a single chr to your string.
-                if( pFirst == NULL )
+                 *@param cData (const chr &) The character to append.
-                        return NULL;
+                 */
+                void append( const chr &cData )
-                flatten();
+                {
-                return pFirst->pData;
+                        append( &cData, 1 );
-        }
+                }
-        
-        const chr *c_str() const
-        {
-                if( pFirst == NULL )
-                        return NULL;
-                flatten();
+                /**
-                return pFirst->pData;
+                 * Prepend another FString to this one.
-        }
+                 *@param sData (MyType &) The FString to prepend.
+                 */
+                void prepend( const MyType & sData )
+                {
+                        prepend( sData.getStr(), sData.getSize() );
+                }
-        MyType &operator +=( const chr *pData )
+                /**
-        {
+                 * Prepend data to your string.
-                append( pData );
+                 *@param pData (const chr *) The data to prepend.
+                 */
+                void prepend( const chr *pData )
+                {
+                        long nLen;
+                        for( nLen = 0; pData[nLen] != (chr)0; nLen++ );
+                        
+                        Chunk *pNew = newChunk( nLen );
+                        cpy( pNew->pData, pData, nLen );
-                return (*this);
+                        prependChunk( pNew );
-        }
+                }
-        
-        MyType &operator +=( const MyType &rSrc )
-        {
-                rSrc.flatten();
-                append( rSrc.pFirst->pData, rSrc.nLength );
-                return (*this);
+                /**
-        }
+                 * Prepend data to your string.
+                 *@param pData (const chr *) The data to prepend.
+                 *@param nLen (long) The length of the data to prepend.
+                 */
+                void prepend( const chr *pData, long nLen )
+                {
+                        Chunk *pNew = newChunk( nLen );
+                        
+                        cpy( pNew->pData, pData, nLen );
-        MyType &operator +=( const chr pData )
+                        prependChunk( pNew );
-        {
+                }
-                chr tmp[2] = { pData, (chr)0 };
-                append( tmp );
-                return (*this);
+                /**
-        }
+                 *@todo void prepend( const chr &cData )
+                 */
-        MyType &operator =( const chr *pData )
+                /**
-        {
+                 * Clear all data from the string.
-                clear();
+                 */
-                append( pData );
+                void clear()
+                {
+                        realClear();
+                }
-                return (*this);
+                /**
-        }
+                 * Force the string to resize
+                 *@param nNewSize (long) The new size of the string.
+                 */
+                void resize( long nNewSize )
+                {
+                        if( nLength == nNewSize )
+                                return;
-        MyType &operator =( const MyType &rSrc )
+                        flatten();
-        {
-                //if( rSrc.isFlat() )
+                        Chunk *pNew = newChunk( nNewSize );
-                //{
+                        long nNewLen = (nNewSize<nLength)?(nNewSize):(nLength);
-                        joinShare( rSrc );
+                        cpy( pNew->pData, pFirst->pData, nNewLen );
-                //}
+                        pNew->pData[nNewLen] = (chr)0;
-                //else
+                        aChr.deallocate( pFirst->pData, pFirst->nLength+1 );
-                //{
+                        aChunk.deallocate( pFirst, 1 );
-                //      copyFrom( rSrc );
+                        pFirst = pLast = pNew;
-                //}
+                        nLength = nNewSize;
-                //
-                return (*this);
-        }
-        
-        bool operator ==( const chr *pData ) const
-        {
-                if( pFirst == NULL ) {
-                        if( pData == NULL )
-                                return true;
-                        return false;
                }
-                flatten();
+                /**
-                const chr *a = pData;
+                 * Get the current size of the string.
-                chr *b = pFirst->pData;
+                 *@returns (long) The current size of the string.
-                for( ; *a!=(chr)0; a++, b++ )
+                 */
+                long getSize() const
                {
-                        if( *a != *b )
+                        return nLength;
-                                return false;
                }
+                
+                /**
+                 * Get a pointer to the string array.
+                 *@returns (chr *) The string data.
+                 */
+                chr *getStr()
+                {
+                        if( pFirst == NULL )
+                                return NULL;
-                return true;
+                        flatten();
-        }
+                        return pFirst->pData;
-        
+                }
-        bool operator ==( const MyType &pData ) const
+                
-        {
+                /**
-                if( pFirst == pData.pFirst )
+                 * Get a const pointer to the string array.
-                        return true;
+                 *@returns (const chr *) The string data.
-                if( pFirst == NULL ) 
+                 */
-                        return false;
+                const chr *getStr() const
+                {
+                        if( pFirst == NULL )
+                                return NULL;
+                        flatten();
+                        return pFirst->pData;
+                }
-                flatten();
+                /**
-                pData.flatten();
+                 * (std::string compatability) Get a pointer to the string array.
-                const chr *a = pData.pFirst->pData;
+                 *@returns (chr *) The string data.
-                chr *b = pFirst->pData;
+                 */
-                for( ; *a!=(chr)0; a++, b++ )
+                chr *c_str()
                {
-                        if( *a != *b )
+                        if( pFirst == NULL )
-                                return false;
+                                return NULL;
+                        flatten();
+                        return pFirst->pData;
                }
+                
+                /**
+                 * (std::string compatability) Get a const pointer to the string array.
+                 *@returns (const chr *) The string data.
+                 */
+                const chr *c_str() const
+                {
+                        if( pFirst == NULL )
+                                return NULL;
-                return true;
+                        flatten();
-        }
+                        return pFirst->pData;
+                }
-        bool operator !=(const chr *pData ) const
+                /**
-        {
+                 * Plus equals operator for FString.
-                return !(*this == pData);
+                 *@param pData (const chr *) The data to append to your FString.
-        }
+                 */
-        
+                MyType &operator +=( const chr *pData )
-        bool operator !=(const MyType &pData ) const
+                {
-        {
+                        append( pData );
-                return !(*this == pData);
-        }
-        chr &operator[]( long nIndex )
+                        return (*this);
-        {
+                }
-                flatten();
+                
+                /**
+                 * Plus equals operator for FString.
+                 *@param pData (const MyType &) The FString to append to your FString.
+                 */
+                MyType &operator +=( const MyType &rSrc )
+                {
+                        if( rSrc.nLength == 0 )
+                                return (*this);
+                        rSrc.flatten();
+                        append( rSrc.pFirst->pData, rSrc.nLength );
-                return pFirst->pData[nIndex];
+                        return (*this);
-        }
+                }
-        
-        const chr &operator[]( long nIndex ) const
-        {
-                flatten();
-                return pFirst->pData[nIndex];
+                /**
-        }
+                 * Plus equals operator for FString.
+                 *@param pData (const chr) The character to append to your FString.
+                 */
+                MyType &operator +=( const chr pData )
+                {
+                        append( &pData, 1 );
-        bool isWS( long nIndex ) const
+                        return (*this);
-        {
+                }
-                flatten();
-                return pFirst->pData[nIndex]==' ' || pFirst->pData[nIndex]=='\t'
+                /**
-                        || pFirst->pData[nIndex]=='\r' || pFirst->pData[nIndex]=='\n';
+                 * Assignment operator.
-        }
+                 *@param pData (const chr *) The character array to append to your
+                 *              FString.
+                 */
+                MyType &operator =( const chr *pData )
+                {
+                        clear();
+                        append( pData );
-        bool isAlpha( long nIndex ) const
+                        return (*this);
-        {
+                }
-                flatten();
-                return (pFirst->pData[nIndex] >= 'a' && pFirst->pData[nIndex] <= 'z')
+                /**
-                        || (pFirst->pData[nIndex] >= 'A' && pFirst->pData[nIndex] <= 'Z');
+                 * Reset your FString to this character array.
-        }
+                 *@param pData (const chr *) The character array to set your FString to.
+                 */
+                void set( const chr *pData )
+                {
+                        clear();
+                        append( pData );
+                }
-        void toLower()
+                /**
-        {
+                 * Reset your FString to this character array.
-                flatten();
+                 *@param pData (const chr *) The character array to set your FString to.
-                unShare();
+                 *@param nSize (long) The length of the inputted character array.
+                 */
+                void set( const chr *pData, long nSize )
+                {
+                        clear();
+                        append( pData, nSize );
+                }
-                for( long j = 0; j < nLength; j++ )
+                /**
+                 * Assignment operator.
+                 *@param rSrc (const MyType &) The FString to set your FString to.
+                 */
+                MyType &operator =( const MyType &rSrc )
                {
-                        if( pFirst->pData[j] >= 'A' && pFirst->pData[j] <= 'Z' )
+                        //if( rSrc.isFlat() )
-                                pFirst->pData[j] -= 'A'-'a';
+                        //{
+                                joinShare( rSrc );
+                        //}
+                        //else
+                        //{
+                        //      copyFrom( rSrc );
+                        //}
+                        //
+                        return (*this);
                }
-        }
+                
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const chr *) The character array to compare your FString
+                 *              to.
+                 */
+                bool operator ==( const chr *pData ) const
+                {
+                        if( pFirst == NULL ) {
+                                if( pData == NULL )
+                                        return true;
+                                return false;
+                        }
-        void toUpper()
+                        flatten();
-        {
+                        const chr *a = pData;
-                flatten();
+                        chr *b = pFirst->pData;
-                unShare();
+                        for( ; *a!=(chr)0; a++, b++ )
+                        {
+                                if( *a != *b )
+                                        return false;
+                        }
-                for( long j = 0; j < nLength; j++ )
+                        return true;
+                }
+                
+                /**
+                 * Equals comparison operator.
+                 *@param pData (const MyType &) The FString to compare your FString to.
+                 */
+                bool operator ==( const MyType &pData ) const
                {
-                        if( pFirst->pData[j] >= 'a' && pFirst->pData[j] <= 'z' )
+                        if( pFirst == pData.pFirst )
-                                pFirst->pData[j] += 'A'-'a';
+                                return true;
+                        if( pFirst == NULL ) 
+                                return false;
+                        flatten();
+                        pData.flatten();
+                        const chr *a = pData.pFirst->pData;
+                        chr *b = pFirst->pData;
+                        for( ; *a!=(chr)0; a++, b++ )
+                        {
+                                if( *a != *b )
+                                        return false;
+                        }
+                        return true;
                }
-        }
-        void serialize( class Serializer &ar )
+                /**
-        {
+                 * Not equals comparison operator.
-                if( ar.isLoading() )
+                 *@param pData (const chr *) The character array to compare your FString
+                 *              to.
+                 */
+                bool operator !=(const chr *pData ) const
                {
-                        clear();
+                        return !(*this == pData);
-                        long nLen;
+                }
-                        ar >> nLen;
                
-                        Chunk *pNew = newChunk( nLen );
+                /**
-                        ar.read( pNew->pData, nLen*sizeof(chr) );
+                 * Not equals comparison operator.
-                        appendChunk( pNew );
+                 *@param pData (const MyType &) The FString to compare your FString to.
+                 */
+                bool operator !=(const MyType &pData ) const
+                {
+                        return !(*this == pData);
                }
-                else
+                /**
+                 * Indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (chr &) The character at position (nIndex).
+                 */
+                chr &operator[]( long nIndex )
                {
                        flatten();
-                        
-                        ar << nLength;
+                        return pFirst->pData[nIndex];
-                        ar.write( pFirst->pData, nLength*sizeof(chr) );
                }
-        }
+                
+                /**
+                 * Const indexing operator
+                 *@param nIndex (long) The index of the character you want.
+                 *@returns (const chr &) The character at position (nIndex).
+                 */
+                const chr &operator[]( long nIndex ) const
+                {
+                        flatten();
-private:
+                        return pFirst->pData[nIndex];
-        void flatten() const
+                }
-        {
+/*
-                if( isFlat() )
+                operator const chr *() const
-                        return;
+                {
+                        if( !pFirst ) return NULL;
+                        flatten();
+                        return pFirst->pData;
+                }
+                */
-                if( pFirst == NULL )
+                operator bool() const
-                        return;
+                {
+                        return (pFirst != NULL);
+                }
-                unShare();
+                bool isSet() const
+                {
+                        return (pFirst != NULL);
+                }
-                Chunk *pNew = newChunk( nLength );
+                /**
-                chr *pos = pNew->pData;
+                 * Is the character at index (nIndex) white space?
-                Chunk *i = pFirst;
+                 *@param nIndex (long) The index of the character you want to check.
-                for(;;)
+                 *@returns (bool) Is it white space?
+                 */
+                bool isWS( long nIndex ) const
                {
-                        cpy( pos, i->pData, i->nLength );
+                        flatten();
-                        pos += i->nLength;
-                        i = i->pNext;
+                        return pFirst->pData[nIndex]==' ' || pFirst->pData[nIndex]=='\t'
-                        if( i == NULL )
+                                || pFirst->pData[nIndex]=='\r' || pFirst->pData[nIndex]=='\n';
-                                break;
                }
-                realClear();
-                pLast = pFirst = pNew;
+                /**
-                nLength = pNew->nLength;
+                 * Is the character at index (nIndex) a letter?
-        }
+                 *@param nIndex (long) The index of the character you want to check.
-        
+                 *@returns (bool) Is it a letter?
-        void realClear() const
+                 */
-        {
+                bool isAlpha( long nIndex ) const
-                if( pFirst == NULL )
+                {
-                        return;
+                        flatten();
-                if( isShared() )
+                        return (pFirst->pData[nIndex] >= 'a' && pFirst->pData[nIndex] <= 'z')
+                                || (pFirst->pData[nIndex] >= 'A' && pFirst->pData[nIndex] <= 'Z');
+                }
+                /**
+                 * Convert your alpha characters to lower case.
+                 */
+                void toLower()
                {
-                        decRefs();
+                        flatten();
+                        unShare();
+                        for( long j = 0; j < nLength; j++ )
+                        {
+                                if( pFirst->pData[j] >= 'A' && pFirst->pData[j] <= 'Z' )
+                                        pFirst->pData[j] -= 'A'-'a';
+                        }
+                }
+                /**
+                 * Convert your alpha characters to upper case.
+                 */
+                void toUpper()
+                {
+                        flatten();
+                        unShare();
+                        for( long j = 0; j < nLength; j++ )
+                        {
+                                if( pFirst->pData[j] >= 'a' && pFirst->pData[j] <= 'z' )
+                                        pFirst->pData[j] += 'A'-'a';
+                        }
+                }
+                /**
+                 * Find the index of the first occurrance of (sText)
+                 *@param sText (const char *) The string to search for.
+                 *@returns (long) The index of the first occurrance. -1 for not found.
+                 */
+                long find( const char *sText )
+                {
+                        long nTLen = strlen( sText );
+                        flatten();
+                        for( long j = 0; j < pFirst->nLength-nTLen; j++ )
+                        {
+                                if( !strncmp( sText, pFirst->pData+j, nTLen ) )
+                                        return j;
+                        }
+                        return -1;
+                }
+                /**
+                 * Do a reverse search for (sText)
+                 *@param sText (const char *) The string to search for.
+                 *@returns (long) The index of the last occurrance. -1 for not found.
+                 */
+                long rfind( const char *sText )
+                {
+                        long nTLen = strlen( sText );
+                        flatten();
+                        for( long j = pFirst->nLength-nTLen-1; j >= 0; j-- )
+                        {
+                                if( !strncmp( sText, pFirst->pData+j, nTLen ) )
+                                        return j;
+                        }
+                        return -1;
+                }
+                /**
+                 * Remove nAmnt bytes from the front of the string.  This function
+                 * operates in O(n) time and should be used sparingly.
+                 */
+                void trimFront( long nAmnt )
+                {
+                        long nNewLen = nLength - nAmnt;
+                        flatten();
+                        Chunk *pNew = newChunk( nNewLen );
+                        cpy( pNew->pData, pFirst->pData, nNewLen );
+                        clear();
+                        appendChunk( pNew );
+                }
+                /**
+                 * Function the archiver calls to archive your FString.
+                 *@param ar (Archive) The archive which is archiving your FString.
+                 */
+                void archive( class Archive &ar )
+                {
+                        if( ar.isLoading() )
+                        {
+                                clear();
+                                long nLen;
+                                ar >> nLen;
+                                if( nLen > 0 )
+                                {
+                                        Chunk *pNew = newChunk( nLen );
+                                        ar.read( pNew->pData, nLen*sizeof(chr) );
+                                        appendChunk( pNew );
+                                }
+                        }
+                        else
+                        {
+                                flatten();
+                                
+                                ar << nLength;
+                                if( nLength )
+                                        ar.write( pFirst->pData, nLength*sizeof(chr) );
+                        }
                }
-                else
+        private:
+                void flatten() const
                {
+                        if( isFlat() )
+                                return;
+                        if( pFirst == NULL )
+                                return;
+                        unShare();
+                        Chunk *pNew = newChunk( nLength );
+                        chr *pos = pNew->pData;
                        Chunk *i = pFirst;
                        for(;;)
                        {
-                                Chunk *n = i->pNext;
+                                cpy( pos, i->pData, i->nLength );
-                                aChr.deallocate( i->pData, i->nLength+1 );
+                                pos += i->nLength;
-                                aChunk.deallocate( i, 1 );
+                                i = i->pNext;
-                                if( n == NULL )
+                                if( i == NULL )
                                        break;
-                                i = n;
                        }
-                        pFirst = pLast = NULL;
+                        realClear();
-                        nLength = 0;
+                        pLast = pFirst = pNew;
+                        nLength = pNew->nLength;
                }
-        }
-        
-        void copyFrom( const FBasicString<chr, chralloc, chunkalloc> &rSrc )
-        {
-                if( rSrc.pFirst == NULL )
-                        return;
                
-                decRefs();
+                void realClear() const
-                Chunk *pNew = newChunk( rSrc.nLength );
-                chr *pos = pNew->pData;
-                Chunk *i = rSrc.pFirst;
-                for(;;)
                {
-                        cpy( pos, i->pData, i->nLength );
+                        if( pFirst == NULL )
-                        pos += i->nLength;
+                                return;
-                        i = i->pNext;
-                        if( i == NULL )
-                                break;
-                }
-                clear();
-                appendChunk( pNew );
+                        if( isShared() )
-        }
+                        {
-        
+                                decRefs();
-        bool isFlat() const
+                        }
-        {
+                        else
-                return (pFirst == pLast);
+                        {
-        }
+                                Chunk *i = pFirst;
+                                for(;;)
-        bool isShared() const
+                                {
-        {
+                                        Chunk *n = i->pNext;
-                return (pnRefs != NULL);
+                                        aChr.deallocate( i->pData, i->nLength+1 );
-        }
+                                        aChunk.deallocate( i, 1 );
+                                        if( n == NULL )
+                                                break;
+                                        i = n;
+                                }
+                                pFirst = pLast = NULL;
+                                nLength = 0;
+                        }
+                }
+                
+                void copyFrom( const FBasicString<chr, nMinSize, chralloc, chunkalloc> &rSrc )
+                {
+                        if( rSrc.pFirst == NULL )
+                                return;
+                        
+                        decRefs();
-        Chunk *newChunk() const
+                        Chunk *pNew = newChunk( rSrc.nLength );
-        {
+                        chr *pos = pNew->pData;
-                Chunk *pNew = aChunk.allocate( 1 );
+                        Chunk *i = rSrc.pFirst;
-                pNew->pNext = NULL;
+                        for(;;)
-                return pNew;
+                        {
-        }
+                                cpy( pos, i->pData, i->nLength );
-        
+                                pos += i->nLength;
-        Chunk *newChunk( long nLen ) const
+                                i = i->pNext;
-        {
+                                if( i == NULL )
-                Chunk *pNew = aChunk.allocate( 1 );
+                                        break;
-                pNew->pNext = NULL;
+                        }
-                pNew->nLength = nLen;
+                        clear();
-                pNew->pData = aChr.allocate( nLen+1 );
-                pNew->pData[nLen] = (chr)0;
-                return pNew;
-        }
-        void appendChunk( Chunk *pNewChunk )
-        {
-                unShare();
-                if( pFirst == NULL )
+                        appendChunk( pNew );
-                        pLast = pFirst = pNewChunk;
+                }
-                else
+                
+                bool isFlat() const
                {
-                        pLast->pNext = pNewChunk;
+                        return (pFirst == pLast);
-                        pLast = pNewChunk;
                }
-                nLength += pNewChunk->nLength;
+                bool isShared() const
-        }
+                {
-        
+                        return (pnRefs != NULL);
-        void prependChunk( Chunk *pNewChunk )
+                }
-        {
-                unShare();
-                if( pFirst == NULL )
+                Chunk *newChunk() const
-                        pLast = pFirst = pNewChunk;
+                {
-                else
+                        Chunk *pNew = aChunk.allocate( 1 );
+                        pNew->pNext = NULL;
+                        return pNew;
+                }
+                
+                Chunk *newChunk( long nLen ) const
                {
-                        pNewChunk->pNext = pFirst;
+                        Chunk *pNew = aChunk.allocate( 1 );
-                        pFirst = pNewChunk;
+                        pNew->pNext = NULL;
+                        pNew->nLength = nLen;
+                        pNew->pData = aChr.allocate( nLen+1 );
+                        pNew->pData[nLen] = (chr)0;
+                        return pNew;
                }
-                nLength += pNewChunk->nLength;
+                void appendChunk( Chunk *pNewChunk )
-        }
+                {
+                        unShare();
-        void joinShare( MyType &rSrc )
+                        if( pFirst == NULL )
-        {
+                                pLast = pFirst = pNewChunk;
-                clear();
+                        else
+                        {
+                                pLast->pNext = pNewChunk;
+                                pLast = pNewChunk;
+                        }
-                if( !rSrc.isFlat() )
+                        nLength += pNewChunk->nLength;
-                        rSrc.flatten();
+                }
+                
+                void prependChunk( Chunk *pNewChunk )
+                {
+                        unShare();
-                rSrc.initCount();
+                        if( pFirst == NULL )
-                pnRefs = rSrc.pnRefs;
+                                pLast = pFirst = pNewChunk;
-                (*pnRefs)++;
+                        else
-                nLength = rSrc.nLength;
+                        {
-                pFirst = rSrc.pFirst;
+                                pNewChunk->pNext = pFirst;
-                pLast = rSrc.pLast;
+                                pFirst = pNewChunk;
-        }
+                        }
-        
-        void joinShare( const MyType &rSrc )
-        {
-                clear();
-                rSrc.flatten();
+                        nLength += pNewChunk->nLength;
+                }
-                if( !rSrc.isShared() )
+                void joinShare( MyType &rSrc )
                {
-                        rSrc.pnRefs = new uint32_t;
+                        clear();
-                        (*rSrc.pnRefs) = 1;
+                        if( !rSrc.isFlat() )
+                                rSrc.flatten();
+                        rSrc.initCount();
+                        pnRefs = rSrc.pnRefs;
+                        (*pnRefs)++;
+                        nLength = rSrc.nLength;
+                        pFirst = rSrc.pFirst;
+                        pLast = rSrc.pLast;
                }
-                pnRefs = rSrc.pnRefs;
+                
-                (*pnRefs)++;
+                void joinShare( const MyType &rSrc )
-                nLength = rSrc.nLength;
+                {
-                pFirst = rSrc.pFirst;
+                        clear();
-                pLast = rSrc.pLast;
-        }
-        /**
+                        rSrc.flatten();
-         * This takes an object that was shared and makes a copy of the base data
-         * that was being shared so that this copy can be changed.  This should be
-         * added before any call that will change this object;
-         */
-        void unShare() const
-        {
-                if( isShared() == false )
-                        return;
-                Chunk *pNew = newChunk( nLength );
+                        if( !rSrc.isShared() )
-                chr *pos = pNew->pData;
+                        {
-                Chunk *i = pFirst;
+                                rSrc.pnRefs = new uint32_t;
-                for(;;)
+                                (*rSrc.pnRefs) = 1;
+                        }
+                        pnRefs = rSrc.pnRefs;
+                        (*pnRefs)++;
+                        nLength = rSrc.nLength;
+                        pFirst = rSrc.pFirst;
+                        pLast = rSrc.pLast;
+                }
+                /**
+                 * This takes an object that was shared and makes a copy of the base data
+                 * that was being shared so that this copy can be changed.  This should be
+                 * added before any call that will change this object;
+                 */
+                void unShare() const
                {
-                        cpy( pos, i->pData, i->nLength );
+                        if( isShared() == false )
-                        pos += i->nLength;
+                                return;
-                        i = i->pNext;
+                        if( pFirst == NULL )
-                        if( i == NULL )
+                                return;
-                                break;
+                        Chunk *pNew = newChunk( nLength );
+                        chr *pos = pNew->pData;
+                        Chunk *i = pFirst;
+                        for(;;)
+                        {
+                                cpy( pos, i->pData, i->nLength );
+                                pos += i->nLength;
+                                i = i->pNext;
+                                if( i == NULL )
+                                        break;
+                        }
+                        decRefs();
+                        pLast = pFirst = pNew;
+                        nLength = pNew->nLength;
                }
-                decRefs();
-                pLast = pFirst = pNew;
-                nLength = pNew->nLength;
-        }
-        /**
+                /**
-         * This decrements our ref count and pulls us out of the share.  If the ref
+                 * This decrements our ref count and pulls us out of the share.  If the ref
-         * count hits zero because of this, it destroys the share.  This is not
+                 * count hits zero because of this, it destroys the share.  This is not
-         * safe to call on it's own, it's much better to call unShare.
+                 * safe to call on it's own, it's much better to call unShare.
-         */
+                 */
-        void decRefs() const
+                void decRefs() const
-        {
-                if( isShared() )
                {
-                        (*pnRefs)--;
+                        if( isShared() )
-                        if( (*pnRefs) == 0 )
-                                destroyShare();
-                        else
                        {
-                                pnRefs = NULL;
+                                (*pnRefs)--;
-                                pFirst = NULL;
+                                if( (*pnRefs) == 0 )
-                                pLast = NULL;
+                                        destroyShare();
-                                nLength = 0;
+                                else
+                                {
+                                        pnRefs = NULL;
+                                        pFirst = NULL;
+                                        pLast = NULL;
+                                        nLength = 0;
+                                }
                        }
                }
-        }
-        /**
+                /**
-         * While the unShare function removes an instance from a share, this
+                 * While the unShare function removes an instance from a share, this
-         * function destroys the data that was in the share, removing the share
+                 * function destroys the data that was in the share, removing the share
-         * itself.  This should only be called when the refcount for the share has
+                 * itself.  This should only be called when the refcount for the share has
-         * or is about to reach zero.
+                 * or is about to reach zero.
-         */
+                 */
-        void destroyShare() const
+                void destroyShare() const
-        {
+                {
-                delete pnRefs;
+                        delete pnRefs;
-                pnRefs = NULL;
+                        pnRefs = NULL;
-                realClear();
+                        realClear();
-        }
+                }
 #ifdef VALTEST
-        void cpy( chr *dest, const chr *src, long count ) const
+                void cpy( chr *dest, const chr *src, long count ) const
-        {
-                for( int j = 0; j < count; j++ )
                {
-                        *dest = *src;
+                        for( int j = 0; j < count; j++ )
-                        dest++;
+                        {
-                        src++;
+                                *dest = *src;
+                                dest++;
+                                src++;
+                        }
                }
-        }
 #endif
-        void initCount() const
+                void initCount() const
-        {
-                if( !isShared() )
                {
-                        pnRefs = new uint32_t;
+                        if( !isShared() )
-                        (*pnRefs) = 1;
+                        {
+                                pnRefs = new uint32_t;
+                                (*pnRefs) = 1;
+                        }
                }
-        }
-private:
+        private:
-        mutable long nLength;
+                mutable long nLength;
-        mutable uint32_t *pnRefs;
+                mutable uint32_t *pnRefs;
-        mutable Chunk *pFirst;
+                mutable Chunk *pFirst;
-        mutable Chunk *pLast;
+                mutable Chunk *pLast;
-        mutable chralloc aChr;
+                mutable chralloc aChr;
-        mutable chunkalloc aChunk;
+                mutable chunkalloc aChunk;
-};
+        };
-typedef FBasicString<char> FString;
+        typedef FBasicString<char> FString;
-#include "hash.h"
+        template<> uint32_t __calcHashCode<FString>( const FString &k );
-template<> uint32_t __calcHashCode<FString>( const FString &k );
+        template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b );
-template<> bool __cmpHashKeys<FString>( const FString &a, const FString &b );
+}
+#include <ostream>
+std::basic_ostream<char>& operator<< (std::basic_ostream<char> &os, const Bu::FString &val );
 #endif
diff --git a/src/hash.cpp b/src/hash.cpp
index c52e6b1..a207c29 100644
--- a/src/hash.cpp
+++ b/src/hash.cpp
@@ -1,29 +1,29 @@
 #include "hash.h"
-subExceptionDef( HashException )
+namespace Bu { subExceptionDef( HashException ) }
-template<> uint32_t __calcHashCode<int>( const int &k )
+template<> uint32_t Bu::__calcHashCode<int>( const int &k )
 {
        return k;
 }
-template<> bool __cmpHashKeys<int>( const int &a, const int &b )
+template<> bool Bu::__cmpHashKeys<int>( const int &a, const int &b )
 {
        return a == b;
 }
-template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k )
+template<> uint32_t Bu::__calcHashCode<unsigned int>( const unsigned int &k )
 {
        return k;
 }
-template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b )
+template<> bool Bu::__cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b )
 {
        return a == b;
 }
 template<>
-uint32_t __calcHashCode<const char *>( const char * const &k )
+uint32_t Bu::__calcHashCode<const char *>( const char * const &k )
 {
        if (k == NULL)
        {
@@ -39,7 +39,7 @@ uint32_t __calcHashCode<const char *>( const char * const &k )
        return nPos;
 }
-template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b )
+template<> bool Bu::__cmpHashKeys<const char *>( const char * const &a, const char * const &b )
 {
        if( a == b )
                return true;
@@ -52,7 +52,7 @@ template<> bool __cmpHashKeys<const char *>( const char * const &a, const char *
 }
 template<>
-uint32_t __calcHashCode<char *>( char * const &k )
+uint32_t Bu::__calcHashCode<char *>( char * const &k )
 {
        if (k == NULL)
        {
@@ -68,7 +68,7 @@ uint32_t __calcHashCode<char *>( char * const &k )
        return nPos;
 }
-template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b )
+template<> bool Bu::__cmpHashKeys<char *>( char * const &a, char * const &b )
 {
        if( a == b )
                return true;
@@ -80,7 +80,7 @@ template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b )
        return false;
 }
-template<> uint32_t __calcHashCode<std::string>( const std::string &k )
+template<> uint32_t Bu::__calcHashCode<std::string>( const std::string &k )
 {
        std::string::size_type j, sz = k.size();
        const char *s = k.c_str();
@@ -94,20 +94,8 @@ template<> uint32_t __calcHashCode<std::string>( const std::string &k )
        return nPos;
 }
-template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b )
+template<> bool Bu::__cmpHashKeys<std::string>( const std::string &a, const std::string &b )
 {
        return a == b;
 }
-template<> uint32_t __calcHashCode<Hashable>( const Hashable &k )
-{
-        return 0;
-        //return k.getHashCode();
-}
-template<> bool __cmpHashKeys<Hashable>( const Hashable &a, const Hashable &b )
-{
-        return false;
-        //return a.compareForHash( b );
-}
diff --git a/src/hash.h b/src/hash.h
index a21d651..f183823 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -1,745 +1,1071 @@
-#ifndef HASH_H
+#ifndef BU_HASH_H
-#define HASH_H
+#define BU_HASH_H
 #include <stddef.h>
 #include <string.h>
 #include <memory>
 #include <iostream>
 #include <list>
-#include "exceptionbase.h"
+#include <utility>
-#include "hashable.h"
+#include "bu/exceptionbase.h"
-#include "serializable.h"
+#include "bu/list.h"
-#include "serializer.h"
+///#include "archival.h"
+///#include "archive.h"
 #define bitsToBytes( n ) (n/32+(n%32>0 ? 1 : 0))
-subExceptionDecl( HashException )
+namespace Bu
-enum eHashException
 {
-        excodeNotFilled
+        subExceptionDecl( HashException )
-};
-template<typename T>
-uint32_t __calcHashCode( const T &k );
-template<typename T>
-bool __cmpHashKeys( const T &a, const T &b );
-struct __calcNextTSize_fast
+        enum eHashException
-{
-        uint32_t operator()( uint32_t nCapacity, uint32_t nFill, uint32_t nDeleted ) const
        {
-                if( nDeleted >= nCapacity/2 )
+                excodeNotFilled
-                        return nCapacity;
+        };
-                return nCapacity*2+1;
-        }
-};
-template<typename key, typename value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<value>, typename challoc = std::allocator<uint32_t> >
+        template<typename T>
-class Hash;
+        uint32_t __calcHashCode( const T &k );
-template< typename key, typename _value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<_value>, typename challoc = std::allocator<uint32_t> >
+        template<typename T>
-struct HashProxy
+        bool __cmpHashKeys( const T &a, const T &b );
-{
-        friend class Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc>;
-private:
-        HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, key *k, uint32_t nPos, uint32_t hash ) :
-                hsh( h ),
-                pKey( k ),
-                nPos( nPos ),
-                hash( hash ),
-                bFilled( false )
-        {
-        }
-        HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, uint32_t nPos, _value *pValue ) :
+        struct __calcNextTSize_fast
-                hsh( h ),
-                nPos( nPos ),
-                pValue( pValue ),
-                bFilled( true )
        {
-        }
+                uint32_t operator()( uint32_t nCapacity, uint32_t nFill, uint32_t nDeleted ) const
+                {
+                        if( nDeleted >= nCapacity/2 )
+                                return nCapacity;
+                        return nCapacity*2+1;
+                }
+        };
-        Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+        template<typename key, typename value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<value>, typename challoc = std::allocator<uint32_t> >
-        key *pKey;
+        class Hash;
-        uint32_t nPos;
-        _value *pValue;
-        uint32_t hash;
-        bool bFilled;
-public:
+        template< typename key, typename _value, typename sizecalc = __calcNextTSize_fast, typename keyalloc = std::allocator<key>, typename valuealloc = std::allocator<_value>, typename challoc = std::allocator<uint32_t> >
-        operator _value &()
+        struct HashProxy
        {
-                if( bFilled == false )
+                friend class Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc>;
-                        throw HashException(
+        private:
-                                        excodeNotFilled,
+                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, key *k, uint32_t nPos, uint32_t hash ) :
-                                        "No data assosiated with that key."
+                        hsh( h ),
-                                        );
+                        pKey( k ),
-                return *pValue;
+                        nPos( nPos ),
-        }
+                        hash( hash ),
+                        bFilled( false )
+                {
+                }
-        _value &value()
+                HashProxy( Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &h, uint32_t nPos, _value *pValue ) :
-        {
+                        hsh( h ),
-                if( bFilled == false )
+                        nPos( nPos ),
-                        throw HashException(
+                        pValue( pValue ),
-                                        excodeNotFilled,
+                        bFilled( true )
-                                        "No data assosiated with that key."
+                {
-                                        );
+                }
-                return *pValue;
-        }
-        bool isFilled()
+                Hash<key, _value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
-        {
+                key *pKey;
-                return bFilled;
+                uint32_t nPos;
-        }
+                _value *pValue;
+                uint32_t hash;
+                bool bFilled;
-        void erase()
+        public:
-        {
+                /**
-                if( bFilled )
+                 * Cast operator for HashProxy.
+                 *@returns (value_type &) The value the HashProxy is pointing to.
+                 */
+                operator _value &()
                {
-                        hsh._erase( nPos );
+                        if( bFilled == false )
-                        hsh.onDelete();
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        return *pValue;
                }
-        }
-        _value operator=( _value nval )
+                /**
-        {
+                 * Direct function for retrieving a value out of the HashProxy.
-                if( bFilled )
+                 *@returns (value_type &) The value pointed to by this HashProxy.
+                 */
+                _value &value()
                {
-                        hsh.va.destroy( pValue );
+                        if( bFilled == false )
-                        hsh.va.construct( pValue, nval );
+                                throw HashException(
-                        hsh.onUpdate();
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        return *pValue;
                }
-                else
+                /**
+                 * Whether this HashProxy points to something real or not.
+                 */
+                bool isFilled()
                {
-                        hsh.fill( nPos, *pKey, nval, hash ); 
+                        return bFilled;
-                        hsh.onInsert();
                }
-                return nval;
+                /**
-        }
+                 * Erase the data pointed to by this HashProxy.
+                 */
+                void erase()
+                {
+                        if( bFilled )
+                        {
+                                hsh._erase( nPos );
+                                hsh.onDelete();
+                        }
+                }
-        _value *operator->()
+                /**
-        {
+                 * Assign data to this point in the hash table.
-                if( bFilled == false )
+                 *@param nval (value_type) the data to assign.
-                        throw HashException(
+                 */
-                                        excodeNotFilled,
+                _value operator=( _value nval )
-                                        "No data assosiated with that key."
+                {
-                                        );
+                        if( bFilled )
-                return pValue;
+                        {
-        }
+                                hsh.va.destroy( pValue );
-};
+                                hsh.va.construct( pValue, nval );
+                                hsh.onUpdate();
+                        }
+                        else
+                        {
+                                hsh.fill( nPos, *pKey, nval, hash ); 
+                                hsh.onInsert();
+                        }
-template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
+                        return nval;
-class Hash
+                }
-{
-        friend struct HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-public:
-        Hash() :
-                nCapacity( 11 ),
-                nFilled( 0 ),
-                nDeleted( 0 ),
-                bFilled( NULL ),
-                bDeleted( NULL ),
-                aKeys( NULL ),
-                aValues( NULL ),
-                aHashCodes( NULL )
-        {
-                nKeysSize = bitsToBytes( nCapacity );
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
-                aHashCodes = ca.allocate( nCapacity );
-                aKeys = ka.allocate( nCapacity );
-                aValues = va.allocate( nCapacity );
-        }
-        Hash( const Hash &src ) :
+                /**
-                nCapacity( src.nCapacity ),
+                 * Pointer extraction operator. Access to members of data pointed to
-                nFilled( 0 ),
+                 *              by HashProxy.
-                nDeleted( 0 ),
+                 *@returns (value_type *)
-                bFilled( NULL ),
+                 */
-                bDeleted( NULL ),
+                _value *operator->()
-                aKeys( NULL ),
+                {
-                aValues( NULL ),
+                        if( bFilled == false )
-                aHashCodes( NULL )
+                                throw HashException(
-        {
+                                                excodeNotFilled,
-                nKeysSize = bitsToBytes( nCapacity );
+                                                "No data assosiated with that key."
-                bFilled = ca.allocate( nKeysSize );
+                                                );
-                bDeleted = ca.allocate( nKeysSize );
+                        return pValue;
-                clearBits();
+                }
+        };
-                aHashCodes = ca.allocate( nCapacity );
+        /**
-                aKeys = ka.allocate( nCapacity );
+         * Libbu Template Hash Table
-                aValues = va.allocate( nCapacity );
+         *@param key (typename) The datatype of the hashtable keys
+         *@param value (typename) The datatype of the hashtable data
+         *@param sizecalc (typename) Functor to compute new table size on rehash
+         *@param keyalloc (typename) Memory allocator for hashtable keys
+         *@param valuealloc (typename) Memory allocator for hashtable values
+         *@param challoc (typename) Byte allocator for bitflags
+         */
+        template<typename key, typename value, typename sizecalc, typename keyalloc, typename valuealloc, typename challoc >
+        class Hash
+        {
+                friend struct HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+        public:
+                Hash() :
+                        nCapacity( 11 ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
+                {
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+                }
-                for( uint32_t j = 0; j < src.nCapacity; j++ )
+                Hash( const Hash &src ) :
+                        nCapacity( src.nCapacity ),
+                        nFilled( 0 ),
+                        nDeleted( 0 ),
+                        bFilled( NULL ),
+                        bDeleted( NULL ),
+                        aKeys( NULL ),
+                        aValues( NULL ),
+                        aHashCodes( NULL )
                {
-                        if( src.isFilled( j ) )
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+                        for( uint32_t j = 0; j < src.nCapacity; j++ )
                        {
-                                insert( src.aKeys[j], src.aValues[j] );
+                                if( src.isFilled( j ) )
+                                {
+                                        insert( src.aKeys[j], src.aValues[j] );
+                                }
                        }
                }
-        }
-        Hash &operator=( const Hash &src )
+                /**
-        {
+                 * Hashtable assignment operator. Clears this hashtable and
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                 * copies RH into it.
+                 */
+                Hash &operator=( const Hash &src )
                {
-                        if( isFilled( j ) )
+                        for( uint32_t j = 0; j < nCapacity; j++ )
-                                if( !isDeleted( j ) )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                        }
+                        }
+                        va.deallocate( aValues, nCapacity );
+                        ka.deallocate( aKeys, nCapacity );
+                        ca.deallocate( bFilled, nKeysSize );
+                        ca.deallocate( bDeleted, nKeysSize );
+                        ca.deallocate( aHashCodes, nCapacity );
+                        nFilled = 0;
+                        nDeleted = 0;
+                        nCapacity = src.nCapacity;
+                        nKeysSize = bitsToBytes( nCapacity );
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
+                        aHashCodes = ca.allocate( nCapacity );
+                        aKeys = ka.allocate( nCapacity );
+                        aValues = va.allocate( nCapacity );
+                        for( uint32_t j = 0; j < src.nCapacity; j++ )
+                        {
+                                if( src.isFilled( j ) )
                                {
-                                        va.destroy( &aValues[j] );
+                                        insert( src.aKeys[j], src.aValues[j] );
-                                        ka.destroy( &aKeys[j] );
                                }
-                }
+                        }
-                va.deallocate( aValues, nCapacity );
-                ka.deallocate( aKeys, nCapacity );
-                ca.deallocate( bFilled, nKeysSize );
-                ca.deallocate( bDeleted, nKeysSize );
-                ca.deallocate( aHashCodes, nCapacity );
-                nFilled = 0;
-                nDeleted = 0;
-                nCapacity = src.nCapacity;
-                nKeysSize = bitsToBytes( nCapacity );
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
-                aHashCodes = ca.allocate( nCapacity );
+                        return *this;
-                aKeys = ka.allocate( nCapacity );
+                }
-                aValues = va.allocate( nCapacity );
-                for( uint32_t j = 0; j < src.nCapacity; j++ )
+                virtual ~Hash()
                {
-                        if( src.isFilled( j ) )
+                        for( uint32_t j = 0; j < nCapacity; j++ )
                        {
-                                insert( src.aKeys[j], src.aValues[j] );
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                        }
                        }
+                        va.deallocate( aValues, nCapacity );
+                        ka.deallocate( aKeys, nCapacity );
+                        ca.deallocate( bFilled, nKeysSize );
+                        ca.deallocate( bDeleted, nKeysSize );
+                        ca.deallocate( aHashCodes, nCapacity );
                }
-                return *this;
+                /**
-        }
+                 * Get the current hash table capacity. (Changes at re-hash)
+                 *@returns (uint32_t) The current capacity.
-        virtual ~Hash()
+                 */
-        {
+                uint32_t getCapacity()
-                for( uint32_t j = 0; j < nCapacity; j++ )
                {
-                        if( isFilled( j ) )
+                        return nCapacity;
-                                if( !isDeleted( j ) )
-                                {
-                                        va.destroy( &aValues[j] );
-                                        ka.destroy( &aKeys[j] );
-                                }
                }
-                va.deallocate( aValues, nCapacity );
-                ka.deallocate( aKeys, nCapacity );
-                ca.deallocate( bFilled, nKeysSize );
-                ca.deallocate( bDeleted, nKeysSize );
-                ca.deallocate( aHashCodes, nCapacity );
-        }
-        uint32_t getCapacity()
+                /**
-        {
+                 * Get the number of hash locations spoken for. (Including 
-                return nCapacity;
+                 * not-yet-cleaned-up deleted items.)
-        }
+                 *@returns (uint32_t) The current fill state.
+                 */
+                uint32_t getFill()
+                {
+                        return nFilled;
+                }
-        uint32_t getFill()
+                /**
-        {
+                 * Get the number of items stored in the hash table.
-                return nFilled;
+                 *@returns (uint32_t) The number of items stored in the hash table.
-        }
+                 */
+                uint32_t size()
+                {
+                        return nFilled-nDeleted;
+                }
-        uint32_t size()
+                /**
-        {
+                 * Get the number of items which have been deleted, but not yet
-                return nFilled-nDeleted;
+                 * cleaned up.
-        }
+                 *@returns (uint32_t) The number of deleted items.
+                 */
+                uint32_t getDeleted()
+                {
+                        return nDeleted;
+                }
-        uint32_t getDeleted()
+                /**
-        {
+                 * Hash table index operator
-                return nDeleted;
+                 *@param k (key_type) Key of data to be retrieved.
-        }
+                 *@returns (HashProxy) Proxy pointing to the data.
+                 */
+                virtual HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( key k )
+                {
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
-        virtual HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc> operator[]( key k )
+                        if( bFill )
-        {
+                        {
-                uint32_t hash = __calcHashCode( k );
+                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, nPos, &aValues[nPos] );
-                bool bFill;
+                        }
-                uint32_t nPos = probe( hash, k, bFill );
+                        else
+                        {
+                                return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, &k, nPos, hash );
+                        }
+                }
-                if( bFill )
+                /**
+                 * Insert a value (v) under key (k) into the hash table
+                 *@param k (key_type) Key to list the value under.
+                 *@param v (value_type) Value to store in the hash table.
+                 */
+                virtual void insert( key k, value v )
                {
-                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, nPos, &aValues[nPos] );
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+                        if( bFill )
+                        {
+                                va.destroy( &aValues[nPos] );
+                                va.construct( &aValues[nPos], v );
+                                onUpdate();
+                        }
+                        else
+                        {
+                                fill( nPos, k, v, hash );
+                                onInsert();
+                        }
                }
-                else
+                /**
+                 * Remove a value from the hash table.
+                 *@param k (key_type) The data under this key will be erased.
+                 */
+                virtual void erase( key k )
                {
-                        return HashProxy<key, value, sizecalc, keyalloc, valuealloc, challoc>( *this, &k, nPos, hash );
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+                        if( bFill )
+                        {
+                                _erase( nPos );
+                                onDelete();
+                        }
                }
-        }
-        virtual void insert( key k, value v )
+                struct iterator;
-        {
-                uint32_t hash = __calcHashCode( k );
-                bool bFill;
-                uint32_t nPos = probe( hash, k, bFill );
-                if( bFill )
+                /**
+                 * Remove a value from the hash pointed to from an iterator.
+                 *@param i (iterator &) The data to be erased.
+                 */
+                virtual void erase( struct iterator &i )
                {
-                        va.destroy( &aValues[nPos] );
+                        if( this != &i.hsh )
-                        va.construct( &aValues[nPos], v );
+                                throw HashException("This iterator didn't come from this Hash.");
-                        onUpdate();
+                        if( isFilled( i.nPos ) && !isDeleted( i.nPos ) )
+                        {
+                                _erase( i.nPos );
+                                onDelete();
+                        }
                }
-                else
+                /**
+                 * Remove all data from the hash table.
+                 */
+                virtual void clear()
                {
-                        fill( nPos, k, v, hash );
+                        for( uint32_t j = 0; j < nCapacity; j++ )
-                        onInsert();
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                        {
+                                                va.destroy( &aValues[j] );
+                                                ka.destroy( &aKeys[j] );
+                                                onDelete();
+                                        }
+                        }
+                        
+                        clearBits();
                }
-        }
-        virtual void erase( key k )
+                /**
-        {
+                 * Get an item of data from the hash table.
-                uint32_t hash = __calcHashCode( k );
+                 *@param k (key_type) Key pointing to the data to be retrieved.
-                bool bFill;
+                 *@returns (value_type &) The data pointed to by (k).
-                uint32_t nPos = probe( hash, k, bFill );
+                 */
+                virtual value &get( key k )
+                {
+                        uint32_t hash = __calcHashCode( k );
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
-                if( bFill )
+                        if( bFill )
+                        {
+                                return aValues[nPos];
+                        }
+                        else
+                        {
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        }
+                }
+                
+                /**
+                 * Get a const item of data from the hash table.
+                 *@param k (key_type) Key pointing to the data to be retrieved.
+                 *@returns (const value_type &) A const version of the data pointed
+                 *              to by (k).
+                 */
+                virtual const value &get( key k ) const
                {
-                        _erase( nPos );
+                        uint32_t hash = __calcHashCode( k );
-                        onDelete();
+                        bool bFill;
+                        uint32_t nPos = probe( hash, k, bFill );
+                        if( bFill )
+                        {
+                                return aValues[nPos];
+                        }
+                        else
+                        {
+                                throw HashException(
+                                                excodeNotFilled,
+                                                "No data assosiated with that key."
+                                                );
+                        }
                }
-        }
-        struct iterator;
+                /**
-        virtual void erase( struct iterator &i )
+                 * Does the hash table contain an item under key (k).
-        {
+                 *@param k (key_type) The key to check.
-                if( this != &i.hsh )
+                 *@returns (bool) Whether there was an item in the hash under key (k).
-                        throw HashException("This iterator didn't come from this Hash.");
+                 */
-                if( isFilled( i.nPos ) && !isDeleted( i.nPos ) )
+                virtual bool has( key k )
                {
-                        _erase( i.nPos );
+                        bool bFill;
-                        onDelete();
+                        probe( __calcHashCode( k ), k, bFill, false );
+                        return bFill;
                }
-        }
-        virtual void clear()
+                /**
-        {
+                 * Iteration structure for iterating through the hash.
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                 */
+                typedef struct iterator
                {
-                        if( isFilled( j ) )
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                                if( !isDeleted( j ) )
+                private:
+                        iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( false )
+                        {
+                                nPos = hsh.getFirstPos( bFinished );
+                        }
+                        
+                        iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
+                        Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+                        uint32_t nPos;
+                        bool bFinished;
+                public:
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+                                return *this;
+                        }
+                        
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        iterator operator++()
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+                                return *this;
+                        }
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const iterator &oth )
+                        {
+                                if( bFinished != oth.bFinished )
+                                        return false;
+                                if( bFinished == true )
                                {
-                                        va.destroy( &aValues[j] );
+                                        return true;
-                                        ka.destroy( &aKeys[j] );
-                                        onDelete();
                                }
-                }
+                                else
-                
+                                {
-                clearBits();
+                                        if( oth.nPos == nPos )
-        }
+                                                return true;
+                                        return false;
+                                }
+                        }
+                        
+                        /**
+                         * Iterator not equality comparison operator. Not the same?
+                         */
+                        bool operator!=( const iterator &oth )
+                        {
+                                return !(*this == oth );
+                        }
-        virtual value &get( key k )
+                        /**
-        {
+                         * Iterator assignment operator.
-                uint32_t hash = __calcHashCode( k );
+                         */
-                bool bFill;
+                        iterator operator=( const iterator &oth )
-                uint32_t nPos = probe( hash, k, bFill );
+                        {
+                                if( &hsh != &oth.hsh )
+                                        throw HashException(
+                                                "Cannot mix iterators from different hash objects.");
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                        }
-                if( bFill )
+                        /**
-                {
+                         * Iterator dereference operator... err.. get the value
-                        return aValues[nPos];
+                         *@returns (value_type &) The value behind this iterator.
-                }
+                         */
-                else
+                        value &operator *()
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        key &getKey()
+                        {
+                                return hsh.getKeyAtPos( nPos );
+                        }
+                        /**
+                         * Get the value behind this iterator.
+                         *@returs (value_type &) The value behind this iterator.
+                         */
+                        value &getValue()
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                };
+                
+                /**
+                 * Iteration structure for iterating through the hash (const).
+                 */
+                typedef struct const_iterator
                {
-                        throw HashException(
+                        friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
-                                        excodeNotFilled,
+                private:
-                                        "No data assosiated with that key."
+                        const_iterator( const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
-                                        );
+                                hsh( hsh ),
-                }
+                                nPos( 0 ),
-        }
+                                bFinished( false )
+                        {
+                                nPos = hsh.getFirstPos( bFinished );
+                        }
+                        
+                        const_iterator( const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                                hsh( hsh ),
+                                nPos( 0 ),
+                                bFinished( bDone )
+                        {
+                        }
-        virtual bool has( key k )
+                        const Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
-        {
+                        uint32_t nPos;
-                bool bFill;
+                        bool bFinished;
-                probe( __calcHashCode( k ), k, bFill, false );
-                return bFill;
+                public:
-        }
+                        /**
+                         * Iterator incrementation operator. Move the iterator forward.
+                         */
+                        const_iterator operator++( int )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
-        typedef struct iterator
+                                return *this;
-        {
+                        }
-                friend class Hash<key, value, sizecalc, keyalloc, valuealloc, challoc>;
+                        
-        private:
+                        /**
-                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh ) :
+                         * Iterator incrementation operator. Move the iterator forward.
-                        hsh( hsh ),
+                         */
-                        nPos( 0 ),
+                        const_iterator operator++()
-                        bFinished( false )
+                        {
+                                if( bFinished == false )
+                                        nPos = hsh.getNextPos( nPos, bFinished );
+                                return *this;
+                        }
+                        /**
+                         * Iterator equality comparison operator. Iterators the same?
+                         */
+                        bool operator==( const const_iterator &oth )
+                        {
+                                if( bFinished != oth.bFinished )
+                                        return false;
+                                if( bFinished == true )
+                                {
+                                        return true;
+                                }
+                                else
+                                {
+                                        if( oth.nPos == nPos )
+                                                return true;
+                                        return false;
+                                }
+                        }
+                        
+                        /**
+                         * Iterator not equality comparison operator. Not the same?
+                         */
+                        bool operator!=( const const_iterator &oth )
+                        {
+                                return !(*this == oth );
+                        }
+                        /**
+                         * Iterator assignment operator.
+                         */
+                        const_iterator operator=( const const_iterator &oth )
+                        {
+                                if( &hsh != &oth.hsh )
+                                        throw HashException(
+                                                "Cannot mix iterators from different hash objects.");
+                                nPos = oth.nPos;
+                                bFinished = oth.bFinished;
+                        }
+                        /**
+                         * Iterator dereference operator... err.. get the value
+                         *@returns (value_type &) The value behind this iterator.
+                         */
+                        const value &operator *() const
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                        
+                        /**
+                         * Get the key behind this iterator.
+                         *@returns (key_type &) The key behind this iterator.
+                         */
+                        const key &getKey() const
+                        {
+                                return hsh.getKeyAtPos( nPos );
+                        }
+                        /**
+                         * Get the value behind this iterator.
+                         *@returs (value_type &) The value behind this iterator.
+                         */
+                        const value &getValue() const
+                        {
+                                return hsh.getValueAtPos( nPos );
+                        }
+                };
+                /**
+                 * Get an iterator pointing to the first item in the hash table.
+                 *@returns (iterator) An iterator pointing to the first item in the
+                 *              hash table.
+                 */
+                iterator begin()
                {
-                        nPos = hsh.getFirstPos( bFinished );
+                        return iterator( *this );
                }
                
-                iterator( Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh, bool bDone ) :
+                const_iterator begin() const
-                        hsh( hsh ),
-                        nPos( 0 ),
-                        bFinished( bDone )
                {
+                        return const_iterator( *this );
                }
+                
-                Hash<key, value, sizecalc, keyalloc, valuealloc, challoc> &hsh;
+                /**
-                uint32_t nPos;
+                 * Get an iterator pointing to a point just past the last item in the
-                bool bFinished;
+                 *              hash table.
+                 *@returns (iterator) An iterator pointing to a point just past the
-        public:
+                 *              last item in the hash table.
-                iterator operator++( int )
+                 */
+                iterator end()
                {
-                        if( bFinished == false )
+                        return iterator( *this, true );
-                                nPos = hsh.getNextPos( nPos, bFinished );
-                        return *this;
                }
                
-                iterator operator++()
+                const_iterator end() const
                {
-                        if( bFinished == false )
+                        return const_iterator( *this, true );
-                                nPos = hsh.getNextPos( nPos, bFinished );
-                        return *this;
                }
-                bool operator==( const iterator &oth )
+                /**
+                 * Get a list of all the keys in the hash table.
+                 *@returns (std::list<key_type>) The list of keys in the hash table.
+                 */
+                Bu::List<key> getKeys() const
                {
-                        if( bFinished != oth.bFinished )
+                        Bu::List<key> lKeys;
-                                return false;
-                        if( bFinished == true )
+                        for( uint32_t j = 0; j < nCapacity; j++ )
                        {
-                                return true;
+                                if( isFilled( j ) )
+                                {
+                                        if( !isDeleted( j ) )
+                                        {
+                                                lKeys.append( aKeys[j] );
+                                        }
+                                }
                        }
-                        else
+                        return lKeys;
+                }
+        protected:
+                virtual void onInsert() {}
+                virtual void onUpdate() {}
+                virtual void onDelete() {}
+                virtual void onReHash() {}
+                virtual void clearBits()
+                {
+                        for( uint32_t j = 0; j < nKeysSize; j++ )
                        {
-                                if( oth.nPos == nPos )
+                                bFilled[j] = bDeleted[j] = 0;
-                                        return true;
-                                return false;
                        }
                }
-                
-                bool operator!=( const iterator &oth )
+                virtual void fill( uint32_t loc, key &k, value &v, uint32_t hash )
                {
-                        return !(*this == oth );
+                        bFilled[loc/32] |= (1<<(loc%32));
+                        va.construct( &aValues[loc], v );
+                        ka.construct( &aKeys[loc], k );
+                        aHashCodes[loc] = hash;
+                        nFilled++;
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+                        //      nFilled, nDeleted, nCapacity );
                }
-                iterator operator=( const iterator &oth )
+                virtual void _erase( uint32_t loc )
                {
-                        if( &hsh != &oth.hsh )
+                        bDeleted[loc/32] |= (1<<(loc%32));
-                                throw HashException(
+                        va.destroy( &aValues[loc] );
-                                        "Cannot mix iterators from different hash objects.");
+                        ka.destroy( &aKeys[loc] );
-                        nPos = oth.nPos;
+                        nDeleted++;
-                        bFinished = oth.bFinished;
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
+                        //      nFilled, nDeleted, nCapacity );
                }
-                std::pair<key,value> operator *()
+                virtual std::pair<key,value> getAtPos( uint32_t nPos )
+                {
+                        return std::pair<key,value>(aKeys[nPos],aValues[nPos]);
+                }
+                
+                virtual key &getKeyAtPos( uint32_t nPos )
                {
-                        return hsh.getAtPos( nPos );
+                        return aKeys[nPos];
                }
                
-                key &getKey()
+                virtual const key &getKeyAtPos( uint32_t nPos ) const
                {
-                        return hsh.getKeyAtPos( nPos );
+                        return aKeys[nPos];
+                }
+                
+                virtual value &getValueAtPos( uint32_t nPos )
+                {
+                        return aValues[nPos];
+                }
+                
+                virtual const value &getValueAtPos( uint32_t nPos ) const
+                {
+                        return aValues[nPos];
                }
-                value &getValue()
+                virtual uint32_t getFirstPos( bool &bFinished ) const
                {
-                        return hsh.getValueAtPos( nPos );
+                        for( uint32_t j = 0; j < nCapacity; j++ )
+                        {
+                                if( isFilled( j ) )
+                                        if( !isDeleted( j ) )
+                                                return j;
+                        }
+                        bFinished = true;
+                        return 0;
                }
-        };
-        iterator begin()
+                virtual uint32_t getNextPos( uint32_t nPos, bool &bFinished ) const
-        {
+                {
-                return iterator( *this );
+                        for( uint32_t j = nPos+1; j < nCapacity; j++ )
-        }
+                        {
-        
+                                if( isFilled( j ) )
-        iterator end()
+                                        if( !isDeleted( j ) )
-        {
+                                                return j;
-                return iterator( *this, true );
+                        }
-        }
-        std::list<key> getKeys()
+                        bFinished = true;
-        {
+                        return 0;
-                std::list<key> lKeys;
+                }
-                for( uint32_t j = 0; j < nCapacity; j++ )
+                uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true )
                {
-                        if( isFilled( j ) )
+                        uint32_t nCur = hash%nCapacity;
+                        // First we scan to see if the key is already there, abort if we
+                        // run out of probing room, or we find a non-filled entry
+                        for( int8_t j = 0;
+                                isFilled( nCur ) && j < 32;
+                                nCur = (nCur + (1<<j))%nCapacity, j++
+                                )
                        {
-                                if( !isDeleted( j ) )
+                                // Is this the same hash code we were looking for?
+                                if( hash == aHashCodes[nCur] )
                                {
-                                        lKeys.push_back( aKeys[j] );
+                                        // Skip over deleted entries.  Deleted entries are also filled,
+                                        // so we only have to do this check here.
+                                        if( isDeleted( nCur ) )
+                                                continue;
+                                        // Is it really the same key? (for safety)
+                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                                        {
+                                                bFill = true;
+                                                return nCur;
+                                        }
                                }
                        }
-                }
-                return lKeys;
+                        // This is our insurance, if the table is full, then go ahead and
-        }
+                        // rehash, then try again.
+                        if( isFilled( nCur ) && rehash == true )
+                        {
+                                reHash( szCalc(getCapacity(), getFill(), getDeleted()) );
-protected:
+                                // This is potentially dangerous, and could cause an infinite loop.
-        virtual void onInsert() {}
+                                // Be careful writing probe, eh?
-        virtual void onUpdate() {}
+                                return probe( hash, k, bFill );
-        virtual void onDelete() {}
+                        }
-        virtual void onReHash() {}
-        virtual void clearBits()
+                        bFill = false;
-        {
+                        return nCur;
-                for( uint32_t j = 0; j < nKeysSize; j++ )
-                {
-                        bFilled[j] = bDeleted[j] = 0;
                }
-        }
+                
+                uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true ) const
-        virtual void fill( uint32_t loc, key &k, value &v, uint32_t hash )
-        {
-                bFilled[loc/32] |= (1<<(loc%32));
-                va.construct( &aValues[loc], v );
-                ka.construct( &aKeys[loc], k );
-                aHashCodes[loc] = hash;
-                nFilled++;
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-        }
-        virtual void _erase( uint32_t loc )
-        {
-                bDeleted[loc/32] |= (1<<(loc%32));
-                va.destroy( &aValues[loc] );
-                ka.destroy( &aKeys[loc] );
-                nDeleted++;
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-        }
-        virtual std::pair<key,value> getAtPos( uint32_t nPos )
-        {
-                return std::pair<key,value>(aKeys[nPos],aValues[nPos]);
-        }
-        
-        virtual key &getKeyAtPos( uint32_t nPos )
-        {
-                return aKeys[nPos];
-        }
-        
-        virtual value &getValueAtPos( uint32_t nPos )
-        {
-                return aValues[nPos];
-        }
-        virtual uint32_t getFirstPos( bool &bFinished )
-        {
-                for( uint32_t j = 0; j < nCapacity; j++ )
                {
-                        if( isFilled( j ) )
+                        uint32_t nCur = hash%nCapacity;
-                                if( !isDeleted( j ) )
-                                        return j;
+                        // First we scan to see if the key is already there, abort if we
-                }
+                        // run out of probing room, or we find a non-filled entry
+                        for( int8_t j = 0;
+                                isFilled( nCur ) && j < 32;
+                                nCur = (nCur + (1<<j))%nCapacity, j++
+                                )
+                        {
+                                // Is this the same hash code we were looking for?
+                                if( hash == aHashCodes[nCur] )
+                                {
+                                        // Skip over deleted entries.  Deleted entries are also filled,
+                                        // so we only have to do this check here.
+                                        if( isDeleted( nCur ) )
+                                                continue;
+                                        // Is it really the same key? (for safety)
+                                        if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                                        {
+                                                bFill = true;
+                                                return nCur;
+                                        }
+                                }
+                        }
-                bFinished = true;
+                        bFill = false;
-                return 0;
+                        return nCur;
-        }
+                }
-        virtual uint32_t getNextPos( uint32_t nPos, bool &bFinished )
+                void reHash( uint32_t nNewSize )
-        {
-                for( uint32_t j = nPos+1; j < nCapacity; j++ )
                {
-                        if( isFilled( j ) )
+                        //printf("---REHASH---");
-                                if( !isDeleted( j ) )
+                        //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                                        return j;
+                        //      nFilled, nDeleted, nCapacity );
-                }
+                        
+                        // Save all the old data
+                        uint32_t nOldCapacity = nCapacity;
+                        uint32_t *bOldFilled = bFilled;
+                        uint32_t *aOldHashCodes = aHashCodes;
+                        uint32_t nOldKeysSize = nKeysSize;
+                        uint32_t *bOldDeleted = bDeleted;
+                        value *aOldValues = aValues;
+                        key *aOldKeys = aKeys;
+                        
+                        // Calculate new sizes
+                        nCapacity = nNewSize;
+                        nKeysSize = bitsToBytes( nCapacity );
+                
+                        // Allocate new memory + prep
+                        bFilled = ca.allocate( nKeysSize );
+                        bDeleted = ca.allocate( nKeysSize );
+                        clearBits();
-                bFinished = true;
+                        aHashCodes = ca.allocate( nCapacity );
-                return 0;
+                        aKeys = ka.allocate( nCapacity );
-        }
+                        aValues = va.allocate( nCapacity );
-        uint32_t probe( uint32_t hash, key k, bool &bFill, bool rehash=true )
+                        nDeleted = nFilled = 0;
-        {
-                uint32_t nCur = hash%nCapacity;
-                // First we scan to see if the key is already there, abort if we
+                        // Re-insert all of the old data (except deleted items)
-                // run out of probing room, or we find a non-filled entry
+                        for( uint32_t j = 0; j < nOldCapacity; j++ )
-                for( int8_t j = 0;
-                        isFilled( nCur ) && j < 32;
-                        nCur = (nCur + (1<<j))%nCapacity, j++
-                        )
-                {
-                        // Is this the same hash code we were looking for?
-                        if( hash == aHashCodes[nCur] )
                        {
-                                // Skip over deleted entries.  Deleted entries are also filled,
+                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                // so we only have to do this check here.
+                                        (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                                if( isDeleted( nCur ) )
+                                {
-                                        continue;
+                                        insert( aOldKeys[j], aOldValues[j] );
+                                }
+                        }
-                                // Is it really the same key? (for safety)
+                        // Delete all of the old data
-                                if( __cmpHashKeys( aKeys[nCur], k ) == true )
+                        for( uint32_t j = 0; j < nOldCapacity; j++ )
+                        {
+                                if( (bOldFilled[j/32]&(1<<(j%32)))!=0 )
                                {
-                                        bFill = true;
+                                        va.destroy( &aOldValues[j] );
-                                        return nCur;
+                                        ka.destroy( &aOldKeys[j] );
                                }
                        }
+                        va.deallocate( aOldValues, nOldCapacity );
+                        ka.deallocate( aOldKeys, nOldCapacity );
+                        ca.deallocate( bOldFilled, nOldKeysSize );
+                        ca.deallocate( bOldDeleted, nOldKeysSize );
+                        ca.deallocate( aOldHashCodes, nOldCapacity );
                }
-                // This is our insurance, if the table is full, then go ahead and
+                virtual bool isFilled( uint32_t loc ) const
-                // rehash, then try again.
-                if( isFilled( nCur ) && rehash == true )
                {
-                        reHash( szCalc(getCapacity(), getFill(), getDeleted()) );
+                        return (bFilled[loc/32]&(1<<(loc%32)))!=0;
+                }
-                        // This is potentially dangerous, and could cause an infinite loop.
+                virtual bool isDeleted( uint32_t loc ) const
-                        // Be careful writing probe, eh?
+                {
-                        return probe( hash, k, bFill );
+                        return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
                }
-                bFill = false;
+        protected:
-                return nCur;
+                uint32_t nCapacity;
-        }
+                uint32_t nFilled;
+                uint32_t nDeleted;
+                uint32_t *bFilled;
+                uint32_t *bDeleted;
+                uint32_t nKeysSize;
+                key *aKeys;
+                value *aValues;
+                uint32_t *aHashCodes;
+                valuealloc va;
+                keyalloc ka;
+                challoc ca;
+                sizecalc szCalc;
+        };
-        void reHash( uint32_t nNewSize )
+        template<> uint32_t __calcHashCode<int>( const int &k );
-        {
+        template<> bool __cmpHashKeys<int>( const int &a, const int &b );
-                //printf("---REHASH---");
-                //printf("Filled: %d, Deleted: %d, Capacity: %d\n",
-                //      nFilled, nDeleted, nCapacity );
-                
-                // Save all the old data
-                uint32_t nOldCapacity = nCapacity;
-                uint32_t *bOldFilled = bFilled;
-                uint32_t *aOldHashCodes = aHashCodes;
-                uint32_t nOldKeysSize = nKeysSize;
-                uint32_t *bOldDeleted = bDeleted;
-                value *aOldValues = aValues;
-                key *aOldKeys = aKeys;
-                
-                // Calculate new sizes
-                nCapacity = nNewSize;
-                nKeysSize = bitsToBytes( nCapacity );
-        
-                // Allocate new memory + prep
-                bFilled = ca.allocate( nKeysSize );
-                bDeleted = ca.allocate( nKeysSize );
-                clearBits();
-                aHashCodes = ca.allocate( nCapacity );
+        template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k );
-                aKeys = ka.allocate( nCapacity );
+        template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b );
-                aValues = va.allocate( nCapacity );
-                nDeleted = nFilled = 0;
+        template<> uint32_t __calcHashCode<const char *>( const char * const &k );
+        template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
-                // Re-insert all of the old data (except deleted items)
+        template<> uint32_t __calcHashCode<char *>( char * const &k );
-                for( uint32_t j = 0; j < nOldCapacity; j++ )
+        template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
-                {
-                        if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
-                                (bOldDeleted[j/32]&(1<<(j%32)))==0 )
-                        {
-                                insert( aOldKeys[j], aOldValues[j] );
-                        }
-                }
-                // Delete all of the old data
+        template<> uint32_t __calcHashCode<std::string>( const std::string &k );
-                for( uint32_t j = 0; j < nOldCapacity; j++ )
+        template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b );
+        /*
+        template<typename key, typename value>
+        Archive &operator<<( Archive &ar, Hash<key,value> &h )
+        {
+                ar << h.size();
+                for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
                {
-                        if( (bOldFilled[j/32]&(1<<(j%32)))!=0 &&
+                        std::pair<key,value> p = *i;
-                                (bOldDeleted[j/32]&(1<<(j%32)))==0 )
+                        ar << p.first << p.second;
-                        {
-                                va.destroy( &aOldValues[j] );
-                                ka.destroy( &aOldKeys[j] );
-                        }
                }
-                va.deallocate( aOldValues, nOldCapacity );
-                ka.deallocate( aOldKeys, nOldCapacity );
-                ca.deallocate( bOldFilled, nOldKeysSize );
-                ca.deallocate( bOldDeleted, nOldKeysSize );
-                ca.deallocate( aOldHashCodes, nOldCapacity );
-        }
-        virtual bool isFilled( uint32_t loc ) const
+                return ar;
-        {
-                return (bFilled[loc/32]&(1<<(loc%32)))!=0;
        }
-        virtual bool isDeleted( uint32_t loc )
+        template<typename key, typename value>
+        Archive &operator>>( Archive &ar, Hash<key,value> &h )
        {
-                return (bDeleted[loc/32]&(1<<(loc%32)))!=0;
+                h.clear();
-        }
+                uint32_t nSize;
+                ar >> nSize;
-protected:
+                for( uint32_t j = 0; j < nSize; j++ )
-        uint32_t nCapacity;
+                {
-        uint32_t nFilled;
+                        key k; value v;
-        uint32_t nDeleted;
+                        ar >> k >> v;
-        uint32_t *bFilled;
+                        h.insert( k, v );
-        uint32_t *bDeleted;
+                }
-        uint32_t nKeysSize;
-        key *aKeys;
-        value *aValues;
-        uint32_t *aHashCodes;
-        valuealloc va;
-        keyalloc ka;
-        challoc ca;
-        sizecalc szCalc;
-};
-template<> uint32_t __calcHashCode<int>( const int &k );
-template<> bool __cmpHashKeys<int>( const int &a, const int &b );
-template<> uint32_t __calcHashCode<unsigned int>( const unsigned int &k );
-template<> bool __cmpHashKeys<unsigned int>( const unsigned int &a, const unsigned int &b );
-template<> uint32_t __calcHashCode<const char *>( const char * const &k );
-template<> bool __cmpHashKeys<const char *>( const char * const &a, const char * const &b );
-template<> uint32_t __calcHashCode<char *>( char * const &k );
-template<> bool __cmpHashKeys<char *>( char * const &a, char * const &b );
-template<> uint32_t __calcHashCode<std::string>( const std::string &k );
-template<> bool __cmpHashKeys<std::string>( const std::string &a, const std::string &b );
-template<> uint32_t __calcHashCode<Hashable>( const Hashable &k );
-template<> bool __cmpHashKeys<Hashable>( const Hashable &a, const Hashable &b );
-template<typename key, typename value>
-Serializer &operator<<( Serializer &ar, Hash<key,value> &h )
-{
-        ar << h.size();
-        for( typename Hash<key,value>::iterator i = h.begin(); i != h.end(); i++ )
-        {
-                std::pair<key,value> p = *i;
-                ar << p.first << p.second;
-        }
-        return ar;
+                return ar;
-}
+        }*/
-template<typename key, typename value>
+        /*
-Serializer &operator>>( Serializer &ar, Hash<key,value> &h )
+        template<typename key, typename value>
-{
+        Serializer &operator&&( Serializer &ar, Hash<key,value> &h )
-        h.clear();
-        uint32_t nSize;
-        ar >> nSize;
-        for( uint32_t j = 0; j < nSize; j++ )
        {
-                key k; value v;
+                if( ar.isLoading() )
-                ar >> k >> v;
+                {
-                h.insert( k, v );
+                        return ar >> h;
-        }
+                }
+                else
-        return ar;
+                {
-}
+                        return ar << h;
+                }
-template<typename key, typename value>
+        }*/
-Serializer &operator&&( Serializer &ar, Hash<key,value> &h )
-{
-        if( ar.isLoading() )
-        {
-                return ar >> h;
-        }
-        else
-        {
-                return ar << h;
-        }
 }
 #endif
diff --git a/src/hashable.cpp b/src/hashable.cpp
deleted file mode 100644
index 8565956..0000000
--- a/src/hashable.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "hashable.h"
diff --git a/src/hashable.h b/src/hashable.h
deleted file mode 100644
index 98643d5..0000000
--- a/src/hashable.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef HASHABLE_H
-#define HASHABLE_H
-class Hashable
-{
-public:
-        virtual ~Hashable() {};
-        virtual unsigned long int getHashCode() = 0;
-        virtual bool compareForHash( Hashable &other ) = 0;
-};
-#endif
diff --git a/src/hashfunction.cpp b/src/hashfunction.cpp
deleted file mode 100644
index 51f2259..0000000
--- a/src/hashfunction.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "hashfunction.h"
-HashFunction::HashFunction()
-{
-}
-HashFunction::~HashFunction()
-{
-}
diff --git a/src/hashfunction.h b/src/hashfunction.h
deleted file mode 100644
index cbcf70f..0000000
--- a/src/hashfunction.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef HASH_FUNCTION
-#define HASH_FUNCTION
-/** This represents the shell of a hash function.  It must be aggregated in
-  * order to be used.  Please read about it's two functions for specificatins
-  * relating to what values will be passed to them and what they should return
-  * for creating your own hash functions.
-  *@author Mike Buland.
-  */
-class HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunction();
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunction();
-        /** Hashes the value represnted by id.  This must return a fairly unique
-          * number in the range of 0-2^32 (or whatever the size of an unsigned long
-          * is on your system) based on the id given.  The faster the number changes
-          * the better in a general sence.  The return value will be the index
-          * (after probing takes place) to the data assosiated with an id, so this
-          * function should always produce the same number for any given id.
-          *@param id The identifier to use to create a unique numerical identifier.
-          *@returns A mostly unique numerical identifier generated using the given
-          * id.
-          */
-        virtual unsigned long int hash( const void *id ) = 0;
-        /** This function must compare two ids in the format that this hashfunction
-          * accepts.  For example, if the hash function hashes strings it should
-          * probably { return strcmp( id1, id2 ) == 0 }.
-          *@param id1 One value to use in the comparison
-          *@param id2 Another value to use in the comparison
-          *@returns True if the two values match, otherwise false.
-          */
-        virtual bool cmpIDs( const void *id1, const void *id2 ) = 0;
-        
-//      virtual void *createPersistantID( const void *id ) = 0;
-//      virtual void destroyPersistantID( const void *id ) = 0;
-};
-#endif
diff --git a/src/hashfunctioncasestring.cpp b/src/hashfunctioncasestring.cpp
deleted file mode 100644
index 6361f45..0000000
--- a/src/hashfunctioncasestring.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include "hashfunctioncasestring.h"
-HashFunctionCaseString::HashFunctionCaseString()
-{
-}
-HashFunctionCaseString::~HashFunctionCaseString()
-{
-}
-unsigned long int HashFunctionCaseString::hash( const void *id )
-{
-        const char *str = (const char *)id;
-        unsigned long int nPos = 0;
-        for( int j = 0; str[j] != '\0'; j++ )
-        {
-                nPos = tolower(str[j]) + (nPos << 6) + (nPos << 16) - nPos;
-//              nPos += nPos<<16|(((unsigned long int)tolower(str[j]))<<((j*7)%24));
-        }
-        return nPos;
-}
-bool HashFunctionCaseString::cmpIDs( const void *id1, const void *id2 )
-{
-        const char *str1 = (const char *)id1;
-        const char *str2 = (const char *)id2;
-        int j;
-        for( j = 0; str1[j] != '\0' && str2[j] != '\0'; j++ )
-        {
-                if( tolower(str1[j]) != tolower(str2[j]) )
-                        return false;
-        }
-        return (str1[j]==str2[j]);
-}
diff --git a/src/hashfunctioncasestring.h b/src/hashfunctioncasestring.h
deleted file mode 100644
index 7816a1b..0000000
--- a/src/hashfunctioncasestring.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef HASH_FUNCTION_CASE_STRING
-#define HASH_FUNCTION_CASE_STRING
-#include "hashfunction.h"
-/** A hash function for string data.  This hash function does strings, but is
-  * actually generalized to handle any binary stream of characters terminated
-  * by a null character.  This is different than HashFunctionString in that
-  * this does comparisons without regaurd to case.
-  *@author Mike Buland.
-  */
-class HashFunctionCaseString : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionCaseString();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionCaseString();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-#endif
diff --git a/src/hashfunctionint.cpp b/src/hashfunctionint.cpp
deleted file mode 100644
index 4bd0feb..0000000
--- a/src/hashfunctionint.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "hashfunctionint.h"
-HashFunctionInt::HashFunctionInt()
-{
-}
-HashFunctionInt::~HashFunctionInt()
-{
-}
-unsigned long int HashFunctionInt::hash( const void *id )
-{
-        return (unsigned long)(id);
-}
-bool HashFunctionInt::cmpIDs( const void *id1, const void *id2 )
-{
-        return (unsigned long)(id1) == (unsigned long)(id2);
-}
diff --git a/src/hashfunctionint.h b/src/hashfunctionint.h
deleted file mode 100644
index 0fbc764..0000000
--- a/src/hashfunctionint.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef HASH_FUNCTION_INT
-#define HASH_FUNCTION_INT
-#include "hashfunction.h"
-/** A hash function for integer data.  Really, this does almost nothing except
-  * ensure we're dealing with positive indicies.
-  *@author Mike Buland.
-  */
-class HashFunctionInt : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionInt();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionInt();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-#endif
diff --git a/src/hashfunctionstring.cpp b/src/hashfunctionstring.cpp
deleted file mode 100644
index bd14643..0000000
--- a/src/hashfunctionstring.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "hashfunctionstring.h"
-#ifndef NULL
-#define NULL ((void *) 0)
-#endif
-HashFunctionString::HashFunctionString()
-{
-}
-HashFunctionString::~HashFunctionString()
-{
-}
-unsigned long int HashFunctionString::hash( const void *id )
-{
-        if (id == NULL)
-        {
-                return 0;
-        }
-        
-        unsigned long int nPos = 0;
-        for( const char *s = (const char *)id; *s; s++ )
-        {
-                nPos = *s + (nPos << 6) + (nPos << 16) - nPos;
-        }
-        return nPos;
-}
-bool HashFunctionString::cmpIDs( const void *id1, const void *id2 )
-{
-        if (id1 == NULL || id2 == NULL)
-        {
-                return false;
-        }
-        if (id1 == id2)
-        {
-                return true;
-        }
-        
-        const char *str1 = (const char *)id1;
-        const char *str2 = (const char *)id2;
-        int j;
-        for( j = 0; str1[j] != '\0' && str2[j] != '\0'; j++ )
-        {
-                if( str1[j] != str2[j] )
-                        return false;
-        }
-        return (str1[j]==str2[j]);
-}
diff --git a/src/hashfunctionstring.h b/src/hashfunctionstring.h
deleted file mode 100644
index 7d2a1a6..0000000
--- a/src/hashfunctionstring.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef HASH_FUNCTION_STRING
-#define HASH_FUNCTION_STRING
-#include "hashfunction.h"
-/** A hash function for string data.  This hash function does strings, but is
-  * actually generalized to handle any binary stream of characters terminated
-  * by a null character.
-  *@author Mike Buland.
-  */
-class HashFunctionString : public HashFunction
-{
-public:
-        /**
-         * Standard Constructor.
-         */
-        HashFunctionString();
-        
-        /**
-         * Standard Deconstructor.
-         */
-        virtual ~HashFunctionString();
-        unsigned long int hash( const void *id );
-        bool cmpIDs( const void *id1, const void *id2 );
-};
-#endif
diff --git a/src/hashtable.cpp b/src/hashtable.cpp
deleted file mode 100644
index dbcd964..0000000
--- a/src/hashtable.cpp
+++ /dev/null
@@ -1,424 +0,0 @@
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-#include "hashtable.h"
-HashTable::HashTable( HashFunction *hNewFunc, unsigned long int nInitSize, bool bAllowDupes )
-{
-        hFunc = hNewFunc;
-        nTableSize = nextPrime( nInitSize );
-        aTable = new HashNode[nTableSize];
-        //for( int j = 0; j < nTableSize; j++ ) if( aTable[j].id || aTable[j].data || aTable[j].bDeleted ) printf("Unclean entry\n");
-        nSize = 0;
-        nFilled = 0;
-        this->bAllowDupes = bAllowDupes;
-}
-HashTable::~HashTable()
-{
-        delete[] aTable;
-        delete hFunc;
-}
-void HashTable::set( int j, const void *newID, const void *newData )
-{
-        if( newData == NULL )
-        {
-                printf("Inserting NULL data is indestinguishable from uninserted data!\n");
-        }
-        aTable[j].id = newID;
-        aTable[j].data = newData;
-}
-void HashTable::clear()
-{
-        memset( aTable, 0, sizeof(HashNode) * nTableSize );
-}
-bool HashTable::isFilled( int j )
-{
-        return (aTable[j].id != NULL)||(aTable[j].bDeleted);
-}
-void HashTable::reHash( unsigned long int nNewSize )
-{
-        HashNode *aOldTable = aTable;
-        unsigned long int oldSize = nTableSize;
-        // If the table can still be used if we just get rid of deleted items, don't
-        // change the size of the table, otherwise, go ahead and use the number
-        // passed in.
-        if( nSize > nTableSize>>1 )
-        {
-                nTableSize = nextPrime( nNewSize );
-        }
-        aTable = newTable( nTableSize );
-        //for( int j = 0; j < nTableSize; j++ ) if( aTable[j].id || aTable[j].data || aTable[j].bDeleted ) printf("Unclean entry\n");
-        nSize = 0;
-        nFilled = 0;
-        for( unsigned long int j = 0; j < oldSize; j++ )
-        {
-                if( aOldTable[j].id != NULL && aOldTable[j].bDeleted == false )
-                {
-                        insert( aOldTable[j].id, aOldTable[j].data );
-                }
-        }
-        delete[] aOldTable;
-}
-unsigned long int HashTable::probe( unsigned long int nStart, const void *id )
-{
-        int nHash = nStart;
-        nStart = nStart%nTableSize;
-        if( bAllowDupes == true )
-        {
-                for(
-                        unsigned long int j=0;
-                        isFilled( nStart ) && j < 32;
-                        nStart = (nStart+(1<<j))%nTableSize, j++
-                        );
-                /**
-                 * This is an ugly little hack.  If the hash table is too full in allow-
-                 * dups mode we have to fall back on a linear search, otherwise you can
-                 * only get up to 32 entries with the same name.
-                 */
-                if( isFilled( nStart ) )
-                {
-                        unsigned long int nOldStart = nStart;
-                        for(
-                                nStart++;
-                                isFilled( nStart ) && nStart != nOldStart;
-                                nStart = (nStart+1)%nTableSize
-                           );
-                }
-        }
-        else
-        {
-                for(
-                        unsigned long int j=0;
-                        isFilled( nStart ) && j < 32;
-                        nStart = (nStart+(1<<j))%nTableSize, j++
-                        )
-                {
-                        if( isFilled( nStart ) )
-                        {
-                                if( hFunc->cmpIDs( aTable[nStart].id, id ) == true &&
-                                        aTable[nStart].bDeleted == false )
-                                {
-                                        return nStart;
-                                }
-                        }
-                }
-        }
-        // This is our insurance, if the table is full, then go ahead and rehash,
-        // then try again.
-        if( isFilled( nStart ) )
-        {
-                reHash( getCapacity()*2 );
-                return probe( nHash, id );
-        }
-        return nStart;
-}
-HashTable::HashNode *HashTable::newTable( unsigned long int nNewSize )
-{
-        return new HashNode[nNewSize];
-}
-#ifdef HASH_DEBUG_VIS
-void HashTable::printDebugLine( const char *exData )
-{
-        char *buf = new char[getCapacity()+3];
-        int j;
-        buf[0] = '[';
-        for( j = 0; j < getCapacity(); j++ )
-        {
-                buf[j+1] = (aTable[j].bDeleted)?('X'):((isFilled( j ))?('#'):('-'));
-        }
-        buf[j+1] = ']';
-        buf[j+2] = '\0';
-        printf("%s %s\n", buf, exData );
-        delete[] buf;
-}
-#endif
-bool HashTable::insert( const void *id, const void *data )
-{
-        unsigned long int nPos = probe( hFunc->hash( id ), id )%nTableSize;
-        if( bAllowDupes == true )
-        {
-                if( aTable[nPos].id == NULL && aTable[nPos].bDeleted == false )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        nSize++;
-                        nFilled++;
-                        return true;
-                }
-                else
-                {
-                        return false;
-                }
-        }
-        else
-        {
-                if( aTable[nPos].id == NULL && aTable[nPos].bDeleted == false )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        nSize++;
-                        nFilled++;
-                        return true;
-                }
-                else if( hFunc->cmpIDs( aTable[nPos].id, id ) == true )
-                {
-                        set( nPos, id, data );
-#ifdef HASH_DEBUG_VIS
-                        printDebugLine( (const char *)id );
-#endif
-                        return true;
-                }
-                else
-                {
-                        return false;
-                }
-        }
-}
-const void *HashTable::get( const void *id, unsigned long int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return NULL;
-                if( aTable[nPos].bDeleted == false )
-                {
-                        if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                        {
-                                if( nSkip == 0 )
-                                {
-                                        return aTable[nPos].data;
-                                }
-                                else
-                                {
-                                        nSkip--;
-                                }
-                        }
-                }
-        }
-        if( bAllowDupes )
-        {
-                unsigned long int nOldPos = nPos;
-                for( nPos++; nPos != nOldPos; nPos=(nPos+1)%nTableSize )
-                {
-                        if( !isFilled( nPos ) ) return NULL;
-                        if( aTable[nPos].bDeleted == false )
-                        {
-                                if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                                {
-                                        if( nSkip == 0 )
-                                        {
-                                                return aTable[nPos].data;
-                                        }
-                                        else
-                                        {
-                                                nSkip--;
-                                        }
-                                }
-                        }
-                }
-        }
-        return NULL;
-}
-const void *HashTable::getKey( const void *id, unsigned long int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return NULL;
-                if( aTable[nPos].bDeleted == false )
-                {
-                        if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                        {
-                                if( nSkip == 0 )
-                                {
-                                        return aTable[nPos].id;
-                                }
-                                else
-                                {
-                                        nSkip--;
-                                }
-                        }
-                }
-        }
-        if( bAllowDupes )
-        {
-                unsigned long int nOldPos = nPos;
-                for( nPos++; nPos != nOldPos; nPos=(nPos+1)%nTableSize )
-                {
-                        if( !isFilled( nPos ) ) return NULL;
-                        if( aTable[nPos].bDeleted == false )
-                        {
-                                if( hFunc->cmpIDs( id, aTable[nPos].id ) )
-                                {
-                                        if( nSkip == 0 )
-                                        {
-                                                return aTable[nPos].id;
-                                        }
-                                        else
-                                        {
-                                                nSkip--;
-                                        }
-                                }
-                        }
-                }
-        }
-        return NULL;
-}
-void *HashTable::getFirstItemPos()
-{
-        HashPos *pos = new HashPos;
-        return pos;
-}
-const void *HashTable::getItemData( void *xPos )
-{
-        return aTable[((HashPos *)xPos)->nPos].data;
-}
-const void *HashTable::getItemID( void *xPos )
-{
-        return aTable[((HashPos *)xPos)->nPos].id;
-}
-void *HashTable::getNextItemPos( void *xPos )
-{
-        HashPos *pos = (HashPos *)xPos;
-        if( pos->bStarted == false )
-        {
-                pos->bStarted = true;
-                pos->nPos = 0;
-        }
-        else
-        {
-                pos->nPos++;
-        }
-        if( pos->nPos < nTableSize )
-        {
-                for( ; pos->nPos < nTableSize; pos->nPos++ )
-                {
-                        if( isFilled( pos->nPos ) &&
-                                aTable[pos->nPos].bDeleted == false )
-                        {
-                                return xPos;
-                        }
-                }
-        }
-        delete pos;
-        return NULL;
-}
-// Big-O sqrt(n)
-// Change this to be erethpothynies table with a storage
-// lookup later on.
-bool HashTable::isPrime (int num)
-{
-    if (num == 2)         // the only even prime
-        return true;
-    else if (num % 2 == 0)     // other even numbers are composite
-        return false;
-    else
-    {
-        //bool prime = true;
-        int divisor = 3;
-        int upperLimit = static_cast<int>(sqrt(num) + 1);
-        while (divisor <= upperLimit)
-        {
-            if (num % divisor == 0)
-                                return false;
-            //    prime = false;
-            divisor +=2;
-        }
-        return true;
-    }
-}
-// Big-O n^(3/2)
-int HashTable::nextPrime( int base )
-{
-        int nPrime;
-        for( nPrime = base; isPrime( nPrime ) == false; nPrime++ );
-        return nPrime;
-}
-unsigned long int HashTable::getCapacity()
-{
-        return nTableSize;
-}
-unsigned long int HashTable::getSize()
-{
-        return nSize;
-}
-double HashTable::getLoad()
-{
-        return (double)(nFilled)/(double)(nTableSize);
-}
-const void *HashTable::operator[](const void *id)
-{
-        return get( id );
-}
-bool HashTable::del( const void *id, int nSkip )
-{
-        unsigned long int nPos = hFunc->hash( id )%nTableSize;
-        for( unsigned long int j=0; j < 32; nPos = (nPos+(1<<j))%nTableSize, j++ )
-        {
-                if( !isFilled( nPos ) ) return false;
-                //printf("0x%08X \"%s\" == 0x%08X \"%s\" (%d)\n", id, id, aTable[nPos].id, aTable[nPos].id, nPos );
-                if( hFunc->cmpIDs( id, aTable[nPos].id ) &&
-                        aTable[nPos].bDeleted == false )
-                {
-                        if( nSkip == 0 )
-                        {
-                                aTable[nPos].bDeleted = true;
-                                nSize--;
-#ifdef HASH_DEBUG_VIS
-                                printDebugLine( (const char *)id );
-#endif
-                                return true;
-                        }
-                        else
-                        {
-                                nSkip--;
-                        }
-                }
-        }
-        return false;
-}
diff --git a/src/hashtable.h b/src/hashtable.h
deleted file mode 100644
index 179b694..0000000
--- a/src/hashtable.h
+++ /dev/null
@@ -1,308 +0,0 @@
-/**\hashtable.h
- * Describes the HashFunction, HashFunctionString, and HashTable classes.  It
- * was just easier to put them all in one set of files.
- *@author Mike Buland
- */
-#ifndef HASH_TABLE_H
-#define HASH_TABLE_H
-//Uncomment this line to see a cool text-mode visualization of what's going on
-//#define HASH_DEBUG_VIS 1
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include "hashfunction.h"
-/**
- * A simple yet flexable hash-table.  This uses several tricks to help ensure
- * that the table is always running at maximum efficiency.  You no longer have
- * to specify a "danger fill level" when more space is needed a rehash is
- * automatically trigered.  Deleting elements is fully supported, as well as
- * duplicate elements.  To work with and allow duplicates simple construct your
- * HashTable the way you normally would, but when deleting or getting elements
- * you can specify a skip value.  This effectively allows you to treat elements
- * with duplicate ID's as though they were in a zero-based array.  The first
- * element inserted with a given ID would be at skip zero, the next at skip 1
- * and so on.  This allows you to quickly search for elements with duplicate
- * names, just stop when you get a null for a skip number, i.e.
- * <pre>
- *   for( int j = 0;; j++ )
- *   {
- *       void *pData = hash.get( myID, j );
- *       if( !pData ) break;
- *       // Do something interesting with pData
- *   }
- * </pre>
- * There are new features in this HashTable that also allow for memory saving
- * when dealing with systems where many elements are being deleted from the
- * table.  In those cases the elements deleted cannot be simply deleted, instead
- * they have to be marked as deleted and hidden from the user, but maintained in
- * the table so that future hashing operations don't fail.  When rehashing
- * occurs all elements marked as deleted are quietly removed.  In these cases,
- * if the number of deleted items would free enough space in the table for the
- * table to be used efficiently without resizing, it is left the same size and
- * rehashing is performed effectively in place, allowing the deleted items to
- * be removed.
- * <br>
- * For info on adding new hashing algorithms, please see the HashFunction class.
- *@author Mike Buland
- *@todo Fix probing for tables that allow duplicates, and delete an item, then
- * insert an item with the same name.
- */
-class HashTable
-{
-public:
-        /** Constructs a hash table.
-          *@param hNewFunc A pointer to a hashfunction class to use.  If this is
-          * null the default general string type will be used.
-          *@param nInitSize The initial size of the hashtable.
-          *@param bAllowDupes Setting this value to true allows the system to
-          * insert more than one copy of any given key.  This can be tricky, and
-          * will require you to use the nSkip parameter on the get function.
-          */
-        HashTable( HashFunction *hNewFunc, unsigned long int nInitSize, bool bAllowDupes=false );
-        
-        /**
-         * Destroys the hashtable, cleaning up all internal storage, but not stored
-         * elements.  Also deletes the HashFunction passed in in the constructor.
-         */
-        virtual ~HashTable();
-        /** Inserts an item into the hashtable.  This function will trigger a
-          * rehash if adding another item would force the table's load factor over
-          * the danger level.
-          *@param id used to find the data later.
-          *@param data The data item to insert into the table with the identifier
-          * id
-          *@returns True if insertion was successfull, and false if it failed.
-          */
-        bool insert( const void *id, const void *data );
-        /** Gets an item in the hashtable based on the id of that item.  If there
-          * is more than one item with the same id you can use the nSkip parameter
-          * to access all of them.
-          *@param id The id of the item you're trying to find.
-          *@param nSkip The number of items with that id to skip before returning
-          * with the requested item.
-          *@returns A pointer to the data stored at the given id.
-          */
-        const void *get( const void *id, unsigned long int nSkip=0 );
-        
-        const void *getKey( const void *id, unsigned long int nSkip=0 );
-        /** Gets the total capacity of the hashtable.  This is actually the number
-          * of total positions available inside the hashtable at the moment.  This
-          * will change when the hashtable's load exceeds the danger level.
-          * Please note that this is NOT the actual amount of space available.
-          * In reality you can only access about 45-50 percent of that space.
-          *@returns The total capacity.
-          */
-        unsigned long int getCapacity();
-        /** Gets the number of filled in items in the hash table.  This is roughly
-          * equivelent to the getSize function assosiated with the Lists.
-          *@returns The number of filled in items in the hash table.
-          */
-        unsigned long int getSize();
-        /** Gets the load (percentage) of filled in items in the table.  This is
-          * technically the size divided by the capacity, but is definately usefull
-          * since it's required to check if it's time to rehash.
-          *@returns The table load in the range 0.0 to 1.0
-          */
-        double getLoad();
-        /** Sets up an xPos object for use indexing the items in the table.  Call
-          * this first and follow the directions for getNextItemPos below to
-          * iterate through every item in the table, while avoiding the empty
-          * spaces.
-          *@returns A pointer to a xPos object telling the hashtable where to find
-          * the item you're looking at.
-          */
-        void *getFirstItemPos();
-        /** Get the item's data that is being pointed to by xPos.  This is only
-          * valid after xPos was created using getFirstItemPos and getNextItemPos
-          * was called at least once.
-          *@param xPos supplied by getFirstItemPos.
-          *@returns The key value that was used to insert the data into the table.
-          */
-        const void *getItemData( void *xPos );
-        /** Get the item's ID that is being pointed to by xPos.  This is only
-          * valid after xPos was created using getFirstItemPos and getNextItemPos
-          * was called at least once.
-          *@param xPos supplied by getFirstItemPos.
-          *@returns The key value that was used to insert the data into the table.
-          */
-        const void *getItemID( void *xPos );
-        /** Used for iterating through a hash table sequentially.  This will
-          * update the xPos pointer to point to the next time, all ready to
-          * be accessed with getItemID and getItemData.  This must be called at
-          * least once before xPos is meaningful, and will return a NULL when it
-          * has reached the last item.
-          *@param xPos This must be an object created by a call to the function
-          * getFirstItemPos, and is only meaningful to the internal routines.
-          * Aborting a call in the middle (not running to the end of the table)
-          * may result in a memory leak at the moment.
-          *@returns xPos if still iterating through the list, otherwise it will
-          * return NULL when the end has been reached and the xPos variable has
-          * been deleted.
-          */
-        void *getNextItemPos( void *xPos );
-        /** A helpful operator to make accessing items easier.  Please note that
-          * this simply returns a pointer to the data stored internally, and cannot
-          * be used like the STL operator to store new data, use insert for that.
-          *@param id The identifier used to store the requested item.
-          *@returns The data value assosiated with the given id, or NULL if it
-          * wasn't found in the table.
-          */
-        const void *operator[](const void *id);
-        /**
-         * Delete the specified item from the hashtable.  This actually keeps the
-         * data and marks it deleted.  For all intents and purposes to the user it
-         * is deleted, except that the space is still used until a rehash is forced.
-         * This means that in hashtables where elements are being inserted and
-         * deleted frequently you may run into a higher rate of expansion.
-         *@param id The ID to delete.
-         *@param nSkip The number of similar id's to skip before deleting in a
-         * hashtable that allows duplicates.
-         *@returns True if the element was found and deleted, false otherwise.
-         */
-        bool del( const void *id, int nSkip=0 );
-        /**
-         * Deletes every entry in the hash table.  See the notes on del to see what
-         * this means, except that since no data is being kept, the entire table is
-         * just marked as usable space.
-         */
-        void clear();
-private:
-        /**
-         * Contains info related to a position in the hashtable.  Used for
-         * searching through hashtables one item at a time, in order.  This class
-         * should never be created by anything but a HashTable, and should never
-         * be referenced directly.  Instead the hashtable returns a void pointer,
-         * which is what should be passed back in next time you use a search
-         * function.  Always finish a search, since the object is deleted at the
-         * end of the search.
-         *@author Mike Buland
-         */
-        class HashPos
-        {
-        public:
-                /** Create a blank HashPos. */
-                HashPos() { bStarted=false; nPos = 0; };
-                /** Has the search been started?  */
-                bool bStarted;
-                /** The position (index) into the backend storage structure. */
-                unsigned long int nPos;
-        };
-        /**
-         * All data related to a single element in the hashtable.  This should
-         * really only be used and manipulated by the HashTable itself.
-         *@author Mike Buland
-         */
-        typedef struct HashNode
-        {
-        public:
-                /** Create a new, empty HashNode. */
-                HashNode() { id = NULL; data = NULL; bDeleted = false; };
-                /** A pointer to the original ID that was used to key the data. */
-                const void *id;
-                /** A pointer to the data stored along with the above ID. */
-                const void *data;
-                /** Weather or not this data should really...exist */
-                bool bDeleted;
-        } HashNode;
-private:
-        /**
-         * Just sets the values in the element to some friendly values.
-         *@param newID The new ID to store.
-         *@param newData The new Data to store.
-         */
-        void set( int j, const void *newID, const void *newData );
-        /**
-         * Tells you if the node is filled or not.
-         *@returns True=an ID has been stored here, False=no ID.
-         */
-        bool isFilled( int j );
-        /**
-         * This actually resizes, but since every resize requires a reHash to go
-         * along with it, that's the name.  This actually creates a new buffer for
-         * all of the contained data and then pulls every old element that was in
-         * the old table out and performs the hashing placement calculations again.
-         * This function skips all data that was marked as deleted, so at this
-         * point it really will be.
-         *@param nNewSize The new size to set the table to while re-hashing.
-         *@returns True if the operation was successful, false otherwise.
-         */
-        void reHash( unsigned long int nNewSize );
-        /**
-         * Helper function to allocate a new table.  Really just does the memory
-         * allocation.
-         *@param nNewSize The size of the table to generate.
-         *@returns A new, blank array of HashNode objects the size you specified.
-         */
-        HashNode *newTable( unsigned long int nNewSize );
-        /**
-         * This function is used once an actual hash code is obtained.  nStart is
-         * the given hash code, which is then wrapped to the size of the table.  If
-         * there is data at that location, tests are performed to see if it's the
-         * right one.  If it is, then it is returned, otherwise a series of further
-         * tests based on a 2^n search pattern is performed.  The position of the
-         * requested data in the back-end storage is returned if found, otherwise
-         * another less useful value is returned...
-         *@param nStart The initial hashcode of the ID testing for.
-         *@param id A pointer to the id that is being searched for.
-         *@returns The real location of the data requested.
-         */
-        unsigned long int probe( unsigned long int nStart, const void *id );
-        /**
-         * Simple helper function to determine if a number is prime or not.
-         * This function runs in sqrt(n) time.
-         *@param num Number to test for prime-hood.
-         *@returns True if the number is prime, false otherwise.
-         */
-        bool isPrime( int num );
-        /**
-         * Given any number, this function finds the first number after it that is
-         * prime.  Since this number is a multiple internally it's rare that the
-         * starting number would be prime.
-         *@param base The number to start the prime search on.
-         *@returns The first prime after the number given.
-         */
-        int nextPrime( int base );
-        
-#ifdef HASH_DEBUG_VIS
-        void printDebugLine( const char *exData );
-#endif
-        /** A pointer to the HashFunction subclass instance to use. */
-        HashFunction *hFunc;
-        /** The complete array of HashNode objects to store data in. */
-        HashNode *aTable;
-        /** The actual size of the table, not how many elements are in it. */
-        unsigned long int nTableSize;
-        /** The number of elements that are in the table. */
-        unsigned long int nSize;
-        /** The number of elements that are unavailable now. */
-        unsigned long int nFilled;
-        /** Allow duplicate ID's in the table. */
-        bool bAllowDupes;
-};
-#endif
diff --git a/src/inprogress/xmldocument.cpp b/src/inprogress/xmldocument.cpp
new file mode 100644
index 0000000..cb21826
--- /dev/null
+++ b/src/inprogress/xmldocument.cpp
@@ -0,0 +1,9 @@
+#include "xmldocument.h"
+Bu::XmlDocument::XmlDocument()
+{
+}
+Bu::XmlDocument::~XmlDocument()
+{
+}
diff --git a/src/inprogress/xmldocument.h b/src/inprogress/xmldocument.h
new file mode 100644
index 0000000..e16e3ea
--- /dev/null
+++ b/src/inprogress/xmldocument.h
@@ -0,0 +1,22 @@
+#ifndef XML_DOCUMENT_H
+#define XML_DOCUMENT_H
+#include <stdint.h>
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlDocument
+        {
+        public:
+                XmlDocument();
+                virtual ~XmlDocument();
+        private:
+        };
+}
+#endif
diff --git a/src/inprogress/xmlnode.cpp b/src/inprogress/xmlnode.cpp
new file mode 100644
index 0000000..58ef5c5
--- /dev/null
+++ b/src/inprogress/xmlnode.cpp
@@ -0,0 +1,9 @@
+#include "xmlnode.h"
+Bu::XmlNode::XmlNode()
+{
+}
+Bu::XmlNode::~XmlNode()
+{
+}
diff --git a/src/inprogress/xmlnode.h b/src/inprogress/xmlnode.h
new file mode 100644
index 0000000..cd9961a
--- /dev/null
+++ b/src/inprogress/xmlnode.h
@@ -0,0 +1,22 @@
+#ifndef XML_NODE_H
+#define XML_NODE_H
+#include <stdint.h>
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlNode
+        {
+        public:
+                XmlNode();
+                virtual ~XmlNode();
+        private:
+        };
+}
+#endif
diff --git a/src/inprogress/xmlreader.cpp b/src/inprogress/xmlreader.cpp
new file mode 100644
index 0000000..bd241cf
--- /dev/null
+++ b/src/inprogress/xmlreader.cpp
@@ -0,0 +1,267 @@
+#include "xmlreader.h"
+Bu::XmlReader::XmlReader( Bu::Stream &sIn ) :
+        sIn( sIn )
+{
+}
+Bu::XmlReader::~XmlReader()
+{
+}
+const char *Bu::XmlReader::lookahead( int nAmnt )
+{
+        if( sBuf.getSize() >= nAmnt )
+                return sBuf.getStr();
+        int nNew = nAmnt - sBuf.getSize();
+        char *buf = new char[nNew];
+        sIn.read( buf, nNew );
+        sBuf.append( buf );
+        return sBuf.getStr();
+}
+void Bu::XmlReader::burn( int nAmnt )
+{
+        if( sBuf.getSize() < nAmnt )
+        {
+                lookahead( nAmnt );
+        }
+        //sBuf.remove( nAmnt );
+}
+void Bu::XmlReader::checkString( const char *str, int nLen )
+{
+        if( !strncmp( str, lookahead( nLen ), nLen ) )
+        {
+                burn( nLen );
+                return;
+        }
+        throw Bu::ExceptionBase("Expected string '%s'", str );
+}
+Bu::XmlNode *Bu::XmlReader::read()
+{
+        prolog();
+}
+void Bu::XmlReader::prolog()
+{
+        XMLDecl();
+        Misc();
+}
+void Bu::XmlReader::XMLDecl()
+{
+        checkString("<?xml", 5 );
+        S();
+        VersionInfo();
+        EncodingDecl();
+        SDDecl();
+        Sq();
+        checkString("?>", 2 );
+}
+void Bu::XmlReader::Misc()
+{
+        for(;;)
+        {
+                S();
+                if( !strncmp("<!--", lookahead( 4 ), 4 ) )
+                {
+                        Comment();
+                }
+                else if( !strncmp("<?", lookahead( 2 ), 2 ) )
+                {
+                        PI();
+                }
+                else
+                {
+                        return;
+                }
+        }
+}
+void Bu::XmlReader::Comment()
+{
+        checkString("<!--", 4 );
+        for(;;)
+        {
+                unsigned char c = *lookahead(1);
+                if( c == '-' )
+                {
+                        if( lookahead(2)[1] == '-' )
+                        {
+                                checkString("-->", 3 );
+                                return;
+                        }
+                }
+                burn( 1 );
+        }
+}
+void Bu::XmlReader::PI()
+{
+        checkString("<?", 2 );
+        FString sName = Name();
+        printf("PI: %s\n---\n", sName.getStr() );
+        S();
+        for(int j = 0;; j++ )
+        {
+                if( !strncmp( "?>", lookahead(j+2)+j, 2 ) )
+                {
+                        burn( j+2 );
+                        return;
+                }
+        }
+}
+void Bu::XmlReader::S()
+{
+        for( int j = 0;; j++ )
+        {
+                char c = *lookahead( 1 );
+                if( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA )
+                        continue;
+                if( j == 0 )
+                        throw ExceptionBase("Expected whitespace.");
+                return;
+        }
+}
+void Bu::XmlReader::Sq()
+{
+        for(;;)
+        {
+                char c = *lookahead( 1 );
+                if( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA )
+                        continue;
+                return;
+        }
+}
+void Bu::XmlReader::VersionInfo()
+{
+        try
+        {
+                S();
+                checkString("version", 7 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+        Eq();
+        Bu::FString ver = AttValue();
+        if( ver != "1.1" )
+                throw ExceptionBase("Currently we only support xml version 1.1\n");
+}
+void Bu::XmlReader::Eq()
+{
+        Sq();
+        checkString("=", 1 );
+        Sq();
+}
+void Bu::XmlReader::EncodingDecl()
+{
+        S();
+        try
+        {
+                checkString("encoding", 8 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+        Eq();
+        AttValue();
+}
+void Bu::XmlReader::SDDecl()
+{
+        S();
+        try
+        {
+                checkString("standalone", 10 );
+        }
+        catch( ExceptionBase &e )
+        {
+                return;
+        }
+        Eq();
+        AttValue();
+}
+Bu::FString Bu::XmlReader::AttValue()
+{
+        char q = *lookahead(1);
+        if( q == '\"' )
+        {
+                for( int j = 2;; j++ )
+                {
+                        if( lookahead(j)[j-1] == '\"' )
+                        {
+                                Bu::FString ret( lookahead(j)+1, j-2 );
+                                burn( j );
+                                return ret;
+                        }
+                }
+        }
+        else if( q == '\'' )
+        {
+                for( int j = 2;; j++ )
+                {
+                        if( lookahead(j)[j-1] == '\'' )
+                        {
+                                Bu::FString ret( lookahead(j)+1, j-2 );
+                                burn( j );
+                                return ret;
+                        }
+                }
+        }
+        throw ExceptionBase("Excpected either \' or \".\n");
+}
+Bu::FString Bu::XmlReader::Name()
+{
+        unsigned char c = *lookahead( 1 );
+        if( c != ':' && c != '_' &&
+                (c < 'A' || c > 'Z') &&
+                (c < 'a' || c > 'z') &&
+                (c < 0xC0 || c > 0xD6 ) &&
+                (c < 0xD8 || c > 0xF6 ) &&
+                (c < 0xF8))
+        {
+                throw ExceptionBase("Invalid entity name starting character.");
+        }
+        for( int j = 1;; j++ )
+        {
+                unsigned char c = lookahead(j+1)[j];
+                if( isS( c ) )
+                {
+                        FString ret( lookahead(j+1), j+1 );
+                        burn( j+1 );
+                        return ret;
+                }
+                if( c != ':' && c != '_' && c != '-' && c != '.' && c != 0xB7 &&
+                        (c < 'A' || c > 'Z') &&
+                        (c < 'a' || c > 'z') &&
+                        (c < '0' || c > '9') && 
+                        (c < 0xC0 || c > 0xD6 ) &&
+                        (c < 0xD8 || c > 0xF6 ) &&
+                        (c < 0xF8))
+                {
+                        throw ExceptionBase("Invalid character in name.");
+                }
+        }
+}
diff --git a/src/inprogress/xmlreader.h b/src/inprogress/xmlreader.h
new file mode 100644
index 0000000..708a386
--- /dev/null
+++ b/src/inprogress/xmlreader.h
@@ -0,0 +1,121 @@
+#ifndef XML_READER_H
+#define XML_READER_H
+#include <stdint.h>
+#include "bu/stream.h"
+#include "bu/fstring.h"
+#include "bu/xmlnode.h"
+namespace Bu
+{
+        /**
+         * An Xml 1.1 reader.  I've decided to write this, this time, based on the
+         * official W3C reccomendation, now included with the source code.  I've
+         * named the productions in the parser states the same as in that document,
+         * which may make them easier to find, etc, although possibly slightly less
+         * optimized than writing my own reduced grammer.
+         *
+         * Below I will list differences between my parser and the official standard
+         * as I come up with them.
+         *  - Encoding and Standalone headings are ignored for the moment. (4.3.3,
+         *    2.9)
+         *  - The standalone heading attribute can have any standard whitespace
+         *    before it (the specs say only spaces, no newlines). (2.9)
+         *  - Since standalone is ignored, it is currently allowed to have any
+         *    value (should be restricted to "yes" or "no"). (2.9)
+         *  - Currently only UTF-8 / ascii are parsed.
+         *  - [optional] The content of comments is thrown away. (2.5)
+         *  - The content of processing instruction blocks is parsed properly, but
+         *    thrown away. (2.6)
+         */
+        class XmlReader
+        {
+        public:
+                XmlReader( Bu::Stream &sIn );
+                virtual ~XmlReader();
+                XmlNode *read();
+        private:
+                Bu::Stream &sIn;
+                Bu::FString sBuf;
+        private: // Helpers
+                const char *lookahead( int nAmnt );
+                void burn( int nAmnt );
+                void checkString( const char *str, int nLen );
+        private: // States
+                /**
+                 * The headers, etc.
+                 */
+                void prolog();
+                /**
+                 * The xml decleration (version, encoding, etc).
+                 */
+                void XMLDecl();
+                /**
+                 * Misc things, Includes Comments and PIData (Processing Instructions).
+                 */
+                void Misc();
+                /**
+                 * Comments
+                 */
+                void Comment();
+                /**
+                 * Processing Instructions
+                 */
+                void PI();
+                /**
+                 * Whitespace eater.
+                 */
+                void S();
+                /**
+                 * Optional whitespace eater.
+                 */
+                void Sq();
+                /**
+                 * XML Version spec
+                 */
+                void VersionInfo();
+                /**
+                 * Your basic equals sign with surrounding whitespace.
+                 */
+                void Eq();
+                /**
+                 * Read in an attribute value.
+                 */
+                FString AttValue();
+                /**
+                 * Read in the name of something.
+                 */
+                FString Name();
+                /**
+                 * Encoding decleration in the header
+                 */
+                void EncodingDecl();
+                /**
+                 * Standalone decleration in the header
+                 */
+                void SDDecl();
+                bool isS( unsigned char c )
+                {
+                        return ( c == 0x20 || c == 0x9 || c == 0xD || c == 0xA );
+                }
+        };
+}
+#endif
diff --git a/src/inprogress/xmlwriter.cpp b/src/inprogress/xmlwriter.cpp
new file mode 100644
index 0000000..23a5175
--- /dev/null
+++ b/src/inprogress/xmlwriter.cpp
@@ -0,0 +1,9 @@
+#include "xmlwriter.h"
+Bu::XmlWriter::XmlWriter()
+{
+}
+Bu::XmlWriter::~XmlWriter()
+{
+}
diff --git a/src/inprogress/xmlwriter.h b/src/inprogress/xmlwriter.h
new file mode 100644
index 0000000..796d6fb
--- /dev/null
+++ b/src/inprogress/xmlwriter.h
@@ -0,0 +1,22 @@
+#ifndef XML_WRITER_H
+#define XML_WRITER_H
+#include <stdint.h>
+namespace Bu
+{
+        /**
+         *
+         */
+        class XmlWriter
+        {
+        public:
+                XmlWriter();
+                virtual ~XmlWriter();
+        private:
+        };
+}
+#endif
diff --git a/src/ito.cpp b/src/ito.cpp
new file mode 100644
index 0000000..001ca06
--- /dev/null
+++ b/src/ito.cpp
@@ -0,0 +1,40 @@
+#include "ito.h"
+Bu::Ito::Ito()
+{
+}
+Bu::Ito::~Ito()
+{
+}
+bool Bu::Ito::start()
+{
+        nHandle = pthread_create( &ptHandle, NULL, threadRunner, this );
+        return true;
+}
+bool Bu::Ito::stop()
+{
+        pthread_exit( &ptHandle );
+        return true;
+}
+void *Bu::Ito::threadRunner( void *pThread )
+{
+        return ((Ito *)pThread)->run();
+}
+bool Bu::Ito::join()
+{
+        pthread_join( ptHandle, NULL );
+        return true;
+}
+void Bu::Ito::yield()
+{
+        pthread_yield();
+}
diff --git a/src/ito.h b/src/ito.h
new file mode 100644
index 0000000..c062052
--- /dev/null
+++ b/src/ito.h
@@ -0,0 +1,98 @@
+#ifndef BU_ITO_H
+#define BU_ITO_H
+#include <pthread.h>
+namespace Bu
+{
+        /**
+         * Simple thread class.  This wraps the basic pthread (posix threads) system in
+         * an object oriented sort of way.  It allows you to create a class with
+         * standard member variables and callable functions that can be run in it's own
+         * thread, one per class instance.
+         *@author Mike Buland
+         */
+        class Ito
+        {
+        public:
+                /**
+                 * Construct an Ito thread.
+                 */
+                Ito();
+                /**
+                 * Destroy an Ito thread.
+                 */
+                virtual ~Ito();
+                /**
+                 * Begin thread execution.  This will call the overridden run function,
+                 * which will simply execute in it's own thread until the function exits,
+                 * the thread is killed, or the thread is cancelled (optionally).  The
+                 * thread started in this manner has access to all of it's class variables,
+                 * but be sure to protect possible multiple-access with ItoMutex objects.
+                 *@returns True if starting the thread was successful.  False if something
+                 * went wrong and the thread has not started.
+                 */
+                bool start();
+                /**
+                 * Forcibly kill a thread.  This is not generally considered a good thing to
+                 * do, but in those rare cases you need it, it's invaluable.  The problem
+                 * with stopping (or killing) a thread is that it stops it the moment you
+                 * call stop, no matter what it's doing.  The object oriented approach to
+                 * this will help clean up any class variables that were used, but anything
+                 * not managed as a member variable will probably create a memory leak type
+                 * of situation.  Instead of stop, consider using cancel, which can be
+                 * handled by the running thread in a graceful manner.
+                 *@returns True if the thread was stopped, false otherwise.  When this
+                 * function returns the thread may not have stopped, to ensure that the
+                 * thread has really stopped, call join.
+                 */
+                bool stop();
+                /**
+                 * The workhorse of the Ito class.  This is the function that will run in
+                 * the thread, when this function exits the thread dies and is cleaned up
+                 * by the system.  Make sure to read up on ItoMutex, ItoCondition, and
+                 * cancel to see how to control and protect everything you do in a safe way
+                 * within this function.
+                 *@returns I'm not sure right now, but this is the posix standard form.
+                 */
+                virtual void *run()=0;
+                /**
+                 * Join the thread in action.  This function performs what is commonly
+                 * called a thread join.  That is that it effectively makes the calling
+                 * thread an the Ito thread contained in the called object one in the same,
+                 * and pauses the calling thread until the called thread exits.  That is,
+                 * when called from, say, your main(), mythread.join() will not return until
+                 * the thread mythread has exited.  This is very handy at the end of
+                 * programs to ensure all of your data was cleaned up.
+                 *@returns True if the thread was joined, false if the thread couldn't be
+                 * joined, usually because it isn't running to begin with.
+                 */
+                bool join();
+        private:
+                pthread_t ptHandle;     /**< Internal handle to the posix thread. */
+                int nHandle;    /**< Numeric handle to the posix thread. */
+        protected:
+                /**
+                 * This is the hidden-heard of the thread system.  While run is what the
+                 * user gets to override, and everything said about it is true, this is
+                 * the function that actually makes up the thread, it simply calls the
+                 * run member function in an OO-friendly way.  This is what allows us to
+                 * use member variables from within the thread itself.
+                 *@param Should always be this.
+                 *@returns This is specified by posix, I'm not sure yet.
+                 */
+                static void *threadRunner( void *pThread );
+                void yield();
+                
+        };
+}
+#endif
diff --git a/src/itoatom.h b/src/itoatom.h
new file mode 100644
index 0000000..7fc9090
--- /dev/null
+++ b/src/itoatom.h
@@ -0,0 +1,56 @@
+#ifndef BU_ITO_QUEUE_H
+#define BU_ITO_QUEUE_H
+#include <pthread.h>
+#include "itomutex.h"
+#include "itocondition.h"
+/**
+ * A thread-safe wrapper class.
+ *@author Mike Buland
+ */
+template <class T>
+class ItoAtom
+{
+public:
+        /**
+         * Construct an empty queue.
+         */
+        ItoAtom()
+        {
+        }
+        ItoAtom( const T &src ) :
+                data( src )
+        {
+        }
+        
+        ~ItoQueue()
+        {
+        }
+        T get()
+        {
+                mOperate.lock();
+                mOperate.unlock();
+                return data;
+        }
+        void set( const T &val )
+        {
+                mOperate.lock();
+                data = val;
+                cBlock.signal();
+                mOperate.unlock();
+        }
+private:
+        Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+        Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
+        ItoMutex mOperate;      /**< The master mutex, used on all operations. */
+        ItoCondition cBlock;    /**< The condition for blocking dequeues. */
+};
+#endif
diff --git a/src/itocondition.cpp b/src/itocondition.cpp
new file mode 100644
index 0000000..d8f5375
--- /dev/null
+++ b/src/itocondition.cpp
@@ -0,0 +1,42 @@
+#include <sys/time.h>
+#include "itocondition.h"
+Bu::ItoCondition::ItoCondition()
+{
+        pthread_cond_init( &cond, NULL );
+}
+Bu::ItoCondition::~ItoCondition()
+{
+        pthread_cond_destroy( &cond );
+}
+int Bu::ItoCondition::wait()
+{
+        return pthread_cond_wait( &cond, &mutex );
+}
+int Bu::ItoCondition::wait( int nSec, int nUSec )
+{
+        struct timeval now;
+        struct timespec timeout;
+        struct timezone tz;
+        
+        gettimeofday( &now, &tz );
+        timeout.tv_sec = now.tv_sec + nSec + ((now.tv_usec + nUSec)/1000000);
+        timeout.tv_nsec = ((now.tv_usec + nUSec)%1000000)*1000;
+        return pthread_cond_timedwait( &cond, &mutex, &timeout );
+}
+int Bu::ItoCondition::signal()
+{
+        return pthread_cond_signal( &cond );
+}
+int Bu::ItoCondition::broadcast()
+{
+        return pthread_cond_broadcast( &cond );
+}
diff --git a/src/itocondition.h b/src/itocondition.h
new file mode 100644
index 0000000..1793f81
--- /dev/null
+++ b/src/itocondition.h
@@ -0,0 +1,81 @@
+#ifndef BU_ITO_CONDITION_H
+#define BU_ITO_CONDITION_H
+#include <pthread.h>
+#include "itomutex.h"
+namespace Bu
+{
+        /**
+         * Ito condition.  This is a fairly simple condition mechanism.  As you may
+         * notice this class inherits from the ItoMutex class, this is because all
+         * conditions must be within a locked block.  The standard usage of a condition
+         * is to pause one thread, perhaps indefinately, until another thread signals
+         * that it is alright to procede.
+         * <br>
+         * Standard usage for the thread that wants to wait is as follows:
+         * <pre>
+         * ItoCondition cond;
+         * ... // Perform setup and enter your run loop
+         * cond.lock();
+         * while( !isFinished() ) // Could be anything you're waiting for
+         *     cond.wait();
+         * ...  // Take care of what you have to.
+         * cond.unlock();
+         * </pre>
+         * The usage for the triggering thread is much simpler, when it needs to tell
+         * the others that it's time to grab some data it calls either signal or
+         * broadcast.  See both of those functions for the difference.
+         *@author Mike Buland
+         */
+        class ItoCondition : public ItoMutex
+        {
+        public:
+                /**
+                 * Create a condition.
+                 */
+                ItoCondition();
+                /**
+                 * Destroy a condition.
+                 */
+                ~ItoCondition();
+                /**
+                 * Wait forever, or until signalled.  This has to be called from within a
+                 * locked section, i.e. before calling this this object's lock function
+                 * should be called.
+                 */
+                int wait();
+                /**
+                 * Wait for a maximum of nSec seconds and nUSec micro-seconds or until
+                 * signalled.  This is a little more friendly function if you want to
+                 * perform other operations in the thrad loop that calls this function.
+                 * Like the other wait function, this must be inside a locked section.
+                 *@param nSec The seconds to wait.
+                 *@param nUSec the micro-seconds to wait.
+                 */
+                int wait( int nSec, int nUSec );
+                /**
+                 * Notify the next thread waiting on this condition that they can go ahead.
+                 * This only signals one thread, the next one in the condition queue, that
+                 * it is safe to procede with whatever operation was being waited on.
+                 */
+                int signal();
+                /**
+                 * Notify all threads waiting on this condition that they can go ahead now.
+                 * This function is slower than signal, but more effective in certain
+                 * situations where you may not know how many threads should be activated.
+                 */
+                int broadcast();
+        private:
+                pthread_cond_t cond;    /**< Internal condition reference. */
+        };
+}
+#endif
diff --git a/src/itomutex.cpp b/src/itomutex.cpp
new file mode 100644
index 0000000..dc51af9
--- /dev/null
+++ b/src/itomutex.cpp
@@ -0,0 +1,27 @@
+#include "itomutex.h"
+Bu::ItoMutex::ItoMutex()
+{
+        pthread_mutex_init( &mutex, NULL );
+}
+Bu::ItoMutex::~ItoMutex()
+{
+        pthread_mutex_destroy( &mutex );
+}
+int Bu::ItoMutex::lock()
+{
+        return pthread_mutex_lock( &mutex );
+}
+int Bu::ItoMutex::unlock()
+{
+        return pthread_mutex_unlock( &mutex );
+}
+int Bu::ItoMutex::trylock()
+{
+        return pthread_mutex_trylock( &mutex );
+}
diff --git a/src/itomutex.h b/src/itomutex.h
new file mode 100644
index 0000000..9c9d205
--- /dev/null
+++ b/src/itomutex.h
@@ -0,0 +1,61 @@
+#ifndef BU_ITO_MUTEX_H
+#define BU_ITO_MUTEX_H
+#include <pthread.h>
+namespace Bu
+{
+        /**
+         * Simple mutex wrapper.  Currently this doesn't do anything extra for you
+         * except keep all of the functionality together in an OO sorta' way and keep
+         * you from having to worry about cleaning up your mutexes properly, or initing
+         * them.
+         *@author Mike Buland
+         */
+        class ItoMutex
+        {
+        public:
+                /**
+                 * Create an unlocked mutex.
+                 */
+                ItoMutex();
+                
+                /**
+                 * Destroy a mutex.  This can only be done when a mutex is unlocked.
+                 * Failure to unlock before destroying a mutex object could cause it to
+                 * wait for the mutex to unlock, the odds of which are usually farily low
+                 * at deconstruction time.
+                 */
+                ~ItoMutex();
+                /**
+                 * Lock the mutex.  This causes all future calls to lock on this instance
+                 * of mutex to block until the first thread that called mutex unlocks it.
+                 * At that point the next thread that called lock will get a chance to go
+                 * to work.  Because of the nature of a mutex lock it is a very bad idea to
+                 * do any kind of serious or rather time consuming computation within a
+                 * locked section.  This can cause thread-deadlock and your program may
+                 * hang.
+                 */
+                int lock();
+                /**
+                 * Unlock the mutex.  This allows the next thread that asked for a lock to
+                 * lock the mutex and continue with execution.
+                 */
+                int unlock();
+                /**
+                 * Try to lock the mutex.  This is the option to go with if you cannot avoid
+                 * putting lengthy operations within a locked section.  trylock will attempt
+                 * to lock the mutex, if the mutex is already locked this function returns
+                 * immediately with an error code.
+                 */
+                int trylock();
+        protected:
+                pthread_mutex_t mutex;  /**< The internal mutex reference. */
+        };
+}
+#endif
diff --git a/src/itoqueue.h b/src/itoqueue.h
new file mode 100644
index 0000000..75a2f27
--- /dev/null
+++ b/src/itoqueue.h
@@ -0,0 +1,231 @@
+#ifndef BU_ITO_QUEUE_H
+#define BU_ITO_QUEUE_H
+#include <pthread.h>
+#include "itomutex.h"
+#include "itocondition.h"
+namespace Bu
+{
+        /**
+         * A thread-safe queue class.  This class is a very simple queue with some cool
+         * extra functionality for use with the Ito system.  The main extra that it
+         * provides is the option to either dequeue without blocking, with infinite
+         * blocking, or with timed blocking, which will return a value if something is
+         * enqueued within the specified time limit, or NULL if the time limit is
+         * exceded.
+         *@author Mike Buland
+         */
+        template <class T>
+        class ItoQueue
+        {
+        private:
+                /**
+                 * Helper struct.  Keeps track of linked-list items for the queue data.
+                 */
+                typedef struct Item
+                {
+                        T pData;
+                        Item *pNext;
+                } Item;
+        public:
+                /**
+                 * Construct an empty queue.
+                 */
+                ItoQueue() :
+                        pStart( NULL ),
+                        pEnd( NULL ),
+                        nSize( 0 )
+                {
+                }
+                
+                /**
+                 * Destroy the queue.  This function will simply free all contained
+                 * structures.  If you stored pointers in the queue, this will lose the
+                 * pointers without cleaning up the memory they pointed to.  Make sure
+                 * you're queue is empty before allowing it to be destroyed!
+                 */
+                ~ItoQueue()
+                {
+                        Item *pCur = pStart;
+                        while( pCur )
+                        {
+                                Item *pTmp = pCur->pNext;
+                                delete pCur;
+                                pCur = pTmp;
+                        }
+                }
+                /**
+                 * Enqueue a pieces of data.  The new data will go at the end of the queue,
+                 * and unless another piece of data is enqueued, will be the last piece of
+                 * data to be dequeued.
+                 *@param pData The data to enqueue.  If this is not a primitive data type
+                 * it's probably best to use a pointer type.
+                 */
+                void enqueue( T pData )
+                {
+                        mOperate.lock();
+                        if( pStart == NULL )
+                        {
+                                pStart = pEnd = new Item;
+                                pStart->pData = pData;
+                                pStart->pNext = NULL;
+                                nSize++;
+                        }
+                        else
+                        {
+                                pEnd->pNext = new Item;
+                                pEnd = pEnd->pNext;
+                                pEnd->pData = pData;
+                                pEnd->pNext = NULL;
+                                nSize++;
+                        }
+                        cBlock.signal();
+                
+                        mOperate.unlock();
+                }
+                /**
+                 * Dequeue the first item from the queue.  This function can operate in two
+                 * different modes, blocking and non-blocking.  In non-blocking mode it will
+                 * return immediately weather there was data in the queue or not.  If there
+                 * was data it will remove it from the queue and return it to the caller.
+                 * In blocking mode it will block forever wating for data to be enqueued.
+                 * When data finally is enqueued this function will return immediately with
+                 * the new data.  The only way this function should ever return a null in
+                 * blocking mode is if the calling thread was cancelled.  It's probably a
+                 * good idea to check for NULL return values even if you use blocking, just
+                 * to be on the safe side.
+                 *@param bBlock Set to true to enable blocking, leave as false to work in
+                 * non-blocking mode.
+                 *@returns The next piece of data in the queue, or NULL if no data was in
+                 * the queue.
+                 */
+                T dequeue( bool bBlock=false )
+                {
+                        mOperate.lock();
+                        if( pStart == NULL )
+                        {
+                                mOperate.unlock();
+                                if( bBlock )
+                                {
+                                        cBlock.lock();
+                                        while( pStart == NULL )
+                                                cBlock.wait();
+                                
+                                        T tmp = dequeue( false );
+                                        
+                                        cBlock.unlock();
+                                        return tmp;
+                                }
+                                return NULL;
+                        }
+                        else
+                        {
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                        
+                                mOperate.unlock();
+                                return pTmp;
+                        }
+                }
+                /**
+                 * Operates just like the other dequeue function in blocking mode with one
+                 * twist.  This function will block for at most nSec seconds and nUSec
+                 * micro-seconds.  If the timer is up and no data is available, this will
+                 * just return NULL.  If data is enqueued before the timeout expires, it
+                 * will dequeue and exit immediately.
+                 *@param nSec The number of seconds to wait, max.
+                 *@param nUSec The number of micro-seconds to wait, max.
+                 *@returns The next piece of data in the queue, or NULL if the timeout was
+                 * exceeded.
+                 */
+                T dequeue( int nSec, int nUSec )
+                {
+                        mOperate.lock();
+                        if( pStart == NULL )
+                        {
+                                mOperate.unlock();
+                                cBlock.lock();
+                                
+                                cBlock.wait( nSec, nUSec );
+                                if( pStart == NULL )
+                                {
+                                        cBlock.unlock();
+                                        return NULL;
+                                }
+                        
+                                mOperate.lock();
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                                mOperate.unlock();
+                                        
+                                cBlock.unlock();
+                                return pTmp;
+                        }
+                        else
+                        {
+                                T pTmp = pStart->pData;
+                                Item *pDel = pStart;
+                                pStart = pStart->pNext;
+                                delete pDel;
+                                nSize--;
+                        
+                                mOperate.unlock();
+                                return pTmp;
+                        }
+                }
+                /**
+                 * Checks to see if the queue has data in it or not.  Note that there is no
+                 * function to determine the length of the queue.  This data isn't kept
+                 * track of.  If you really need to know, fix this.
+                 *@returns True if the queue is empty, false if it has data in it.
+                 */
+                bool isEmpty()
+                {
+                        mOperate.lock();
+                        bool bEmpty = (pStart == NULL );
+                        mOperate.unlock();
+                        return bEmpty;
+                }
+                long getSize()
+                {
+                        mOperate.lock();
+                        long nRet = nSize;
+                        mOperate.unlock();
+                        return nRet;
+                }
+        private:
+                Item *pStart;   /**< The start of the queue, the next element to dequeue. */
+                Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
+                long nSize;             /**< The number of items in the queue. */
+                ItoMutex mOperate;      /**< The master mutex, used on all operations. */
+                ItoCondition cBlock;    /**< The condition for blocking dequeues. */
+        };
+}
+#endif
diff --git a/src/linkmessage.cpp b/src/linkmessage.cpp
index cf3df42..abe113c 100644
--- a/src/linkmessage.cpp
+++ b/src/linkmessage.cpp
@@ -1,12 +1,11 @@
-#include "linkmessage.h"
+#include "bu/linkmessage.h"
-#include <string.h>
-LinkMessage::LinkMessage( int nNewMsg )
+Bu::LinkMessage::LinkMessage( int nNewMsg )
 {
        nMsg = nNewMsg;
 }
-LinkMessage::~LinkMessage()
+Bu::LinkMessage::~LinkMessage()
 {
 }
diff --git a/src/linkmessage.h b/src/linkmessage.h
index 6cdfb2f..baa22a6 100644
--- a/src/linkmessage.h
+++ b/src/linkmessage.h
@@ -1,39 +1,42 @@
 /**\file linkmessage.h
 */
-#ifndef LINKMESSAGE_H
+#ifndef BU_LINKMESSAGE_H
-#define LINKMESSAGE_H
+#define BU_LINKMESSAGE_H
-/**
+namespace Bu
- * A message to be broadcast accross ProgramLinks in a ProgramChain.  Generally
- * one would make a subclass of this in order to transmit more useful
- * information, but sometimes it isn't necesarry.
- *@author Mike Buland
- */
-class LinkMessage
 {
-public:
        /**
-         * Construct a blank LinkMessage.
+         * A message to be broadcast accross ProgramLinks in a ProgramChain.  Generally
+         * one would make a subclass of this in order to transmit more useful
+         * information, but sometimes it isn't necesarry.
+         *@author Mike Buland
         */
-        LinkMessage() {};
+        class LinkMessage
+        {
+        public:
+                /**
+                 * Construct a blank LinkMessage.
+                 */
+                LinkMessage() {};
-        /**
+                /**
-         * Deconstruct a LinkMessage.
+                 * Deconstruct a LinkMessage.
-         */
+                 */
-        virtual ~LinkMessage();
+                virtual ~LinkMessage();
-        
+                
-        /**
+                /**
-         * Create a LinkMessage object with a specific message assosiated with it
+                 * Create a LinkMessage object with a specific message assosiated with it
-         * to start with.
+                 * to start with.
-         *@param nNewMsg The message to use in the Message object.
+                 *@param nNewMsg The message to use in the Message object.
-         */
+                 */
-        LinkMessage( int nNewMsg );
+                LinkMessage( int nNewMsg );
-        /**
+                /**
-         * The message contained in the Message object.
+                 * The message contained in the Message object.
-         */
+                 */
-        int nMsg;
+                int nMsg;
-};
+        };
+}
 #endif
diff --git a/src/list.cpp b/src/list.cpp
index 18f1a66..abe92ad 100644
--- a/src/list.cpp
+++ b/src/list.cpp
@@ -1,10 +1,2 @@
-#include "list.h"
+#include "bu/list.h"
-List::List(  )
-{
-}
-List::~List(  )
-{
-}
diff --git a/src/list.h b/src/list.h
index c71b328..e05ebbc 100644
--- a/src/list.h
+++ b/src/list.h
@@ -1,101 +1,489 @@
-#ifndef LIST_H
+#ifndef BU_LIST_H
-#define LIST_H
+#define BU_LIST_H
+#include <memory>
+#include "bu/exceptionbase.h"
-/** The basic List class ADT.  This, on it's own, does absolutely nothing, but
+namespace Bu
-  * does define all standard interface functions to access a list.
-  *@author Mike Buland
-  */
-class List
 {
-public:
+        template<typename value>
-        /**
+        struct ListLink
-         * Construct a list.
+        {
-         */
+                value *pValue;
-        List();
+                ListLink *pNext;
+                ListLink *pPrev;
+        };
        /**
-         * Desconstruct a list.
+         * Linked list template container.  This class is similar to the stl list
+         * class except for a few minor changes.  First, it doesn't mimic a stack or
+         * queue, use the Stack or Queue clasess for that.  Second, when const, all
+         * members are only accessable const.  Third, erasing a location does not
+         * invalidate the iterator, it simply points to the next valid location, or
+         * end() if there are no more.
+         *
+         *@param value (typename) The type of data to store in your list
+         *@param valuealloc (typename) Memory Allocator for your value type
+         *@param linkalloc (typename) Memory Allocator for the list links.
         */
-        virtual ~List();
+        template<typename value, typename valuealloc=std::allocator<value>, typename linkalloc=std::allocator<struct ListLink<value> > >
+        class List
-        /** Gets the value at a specified index.
+        {
-          *@param nIndex The index of the item to return.
+        private:
-          *@returns The specified item, or NULL if the index was beyond the range
+                typedef struct ListLink<value> Link;
-          * of the list.
+                typedef class List<value, valuealloc, linkalloc> MyType;
-          *@author Mike Buland
-          */
-        virtual void *getAt( int nIndex ) = 0;
-        /** Append the given data to the end of the list.  This increases the
-          * size of the list by one.
-          *@param pData The data to append to the list.
-          *@author Mike Buland
-          */
-        virtual void append( void *pData ) = 0;
-        /** Inserts an item at the specified position in the list.  The
-          * new item takes the index that you specify, and all other items
-          * are moved up one position.  The size of the list is increased by
-          * one.
-          *@param pData The value to insert into the list.
-          *@param nPos Where to insert the data into the list.
-          *@author Mike Buland
-          */
-        virtual void insertBefore( void *pData, int nPos = 0 ) = 0;
-        /** Determines the size of the list, in elements.
-          *@returns The size of the list.
-          *@author Mike Buland
-          */
-        virtual int getSize(  ) = 0;
-        /** Determines if the list is empty or not.
-          *@returns True if the list is empty, or false if the list has
-          * data in it (if the size is greater than zero).
-          *@author Mike Buland
-          */
-        virtual bool isEmpty(  ) = 0;
-        /** Deletes an item at the specified index and moves all other
-          * values down one index.  The size of the list is decreased by one.
-          *@param nIndex The index of the item to delete.
-          *@author Mike Buland
-          */
-        virtual void deleteAt( int nIndex ) = 0;
-        /** Completely empties the list, and sets the effective size to
-          * zero.
-          *@author Mike Buland
-          */
-        virtual void empty() = 0;
-        /** Sets the size of the list.  This can be larger or smaller
-          * than what it was previously.  If larger, new blank items will
-          * be added to the end of the list.  If smaller than the old list
-          * items will be deleted from the end.
-          *@param nNewSize The new size of the list.
-          *@author Mike Buland
-          */
-        virtual void setSize( int nNewSize ) = 0;
-        /** Sets a member at a specified location to a new value.
-          * If the member being set is outside of the range of the
-          * current list it should be expanded.
-          *@param nIndex The zero-based index of the item to change.
-          *@param pData The new value for that index.
-          *@author Mike Buland
-          */
-        virtual void setAt( int nIndex, void *pData ) = 0;
-        /** Makes the List work like an array.  Just say listObj[2] to get
-          * the third element.
-          *@param nIndex The index to access in the list.
-          *@returns A pointer to the data at element index.
-          *@author Mike Buland
-          */
-        void *operator[]( int nIndex ) { return getAt( nIndex ); };
-};
-#endif
+        public:
+                List() :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                }
+                List( const MyType &src ) :
+                        pFirst( NULL ),
+                        pLast( NULL ),
+                        nSize( 0 )
+                {
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+                ~List()
+                {
+                        clear();
+                }
+                /**
+                 * Assignment operator.
+                 *@param src (const MyType &) The list to assign to your list.
+                 */
+                MyType &operator=( const MyType &src )
+                {
+                        clear();
+                        for( Link *pCur = src.pFirst; pCur; pCur = pCur->pNext )
+                        {
+                                append( *pCur->pValue );
+                        }
+                }
+                /**
+                 * Clear the data from the list.
+                 */
+                void clear()
+                {
+                        Link *pCur = pFirst;
+                        for(;;)
+                        {
+                                if( pCur == NULL ) break;
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                pCur = pTmp;
+                        }
+                        pFirst = pLast = NULL;
+                        nSize = 0;
+                }
+                /**
+                 * Append a value to the list.
+                 *@param v (const value_type &) The value to append.
+                 */
+                void append( const value &v )
+                {
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
+                        va.construct( pNew->pValue, v );
+                        nSize++;
+                        if( pFirst == NULL )
+                        {
+                                // Empty list
+                                pFirst = pLast = pNew;
+                                pNew->pNext = pNew->pPrev = NULL;
+                        }
+                        else
+                        {
+                                pNew->pNext = NULL;
+                                pNew->pPrev = pLast;
+                                pLast->pNext = pNew;
+                                pLast = pNew;
+                        }
+                }
+                /**
+                 * Prepend a value to the list.
+                 *@param v (const value_type &) The value to prepend.
+                 */
+                void prepend( const value &v )
+                {
+                        Link *pNew = la.allocate( 1 );
+                        pNew->pValue = va.allocate( 1 );
+                        va.construct( pNew->pValue, v );
+                        nSize++;
+                        if( pFirst == NULL )
+                        {
+                                // Empty list
+                                pFirst = pLast = pNew;
+                                pNew->pNext = pNew->pPrev = NULL;
+                        }
+                        else
+                        {
+                                pNew->pNext = pFirst;
+                                pNew->pPrev = NULL;
+                                pFirst->pPrev = pNew;
+                                pFirst = pNew;
+                        }
+                }
+                /**
+                 * An iterator to iterate through your list.
+                 */
+                typedef struct iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+                        iterator() :
+                                pLink( NULL )
+                        {
+                        }
+                        iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+                public:
+                        /**
+                         * Equals comparison operator.
+                         *@param oth (const iterator &) The iterator to compare to.
+                         *@returns (bool) Are they equal?
+                         */
+                        bool operator==( const iterator &oth ) const
+                        {
+                                return ( pLink == oth.pLink );
+                        }
+                        /**
+                         * Equals comparison operator.
+                         *@param pOth (const Link *) The link to compare to.
+                         *@returns (bool) Are they equal?
+                         */
+                        bool operator==( const Link *pOth ) const
+                        {
+                                return ( pLink == pOth );
+                        }
+                        /**
+                         * Not equals comparison operator.
+                         *@param oth (const iterator &) The iterator to compare to.
+                         *@returns (bool) Are they not equal?
+                         */
+                        bool operator!=( const iterator &oth ) const
+                        {
+                                return ( pLink != oth.pLink );
+                        }
+                        /**
+                         * Not equals comparison operator.
+                         *@param pOth (const Link *) The link to compare to.
+                         *@returns (bool) Are they not equal?
+                         */
+                        bool operator!=( const Link *pOth ) const
+                        {
+                                return ( pLink != pOth );
+                        }
+                        /**
+                         * Dereference operator.
+                         *@returns (value_type &) The value.
+                         */
+                        value &operator*()
+                        {
+                                return *(pLink->pValue);
+                        }
+                        /**
+                         * Pointer access operator.
+                         *@returns (value_type *) A pointer to the value.
+                         */
+                        value *operator->()
+                        {
+                                return pLink->pValue;
+                        }
+                        /**
+                         * Increment operator.
+                         */
+                        iterator &operator++()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+                        /**
+                         * Decrement operator.
+                         */
+                        iterator &operator--()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        /**
+                         * Increment operator.
+                         */
+                        iterator &operator++( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+                        /**
+                         * Decrement operator.
+                         */
+                        iterator &operator--( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        /**
+                         * Assignment operator.
+                         *@param oth (const iterator &) The other iterator to set this
+                         *              one to.
+                         */
+                        iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                };
+                
+                /**
+                 *@see iterator
+                 */
+                typedef struct const_iterator
+                {
+                        friend class List<value, valuealloc, linkalloc>;
+                private:
+                        Link *pLink;
+                        const_iterator() :
+                                pLink( NULL )
+                        {
+                        }
+                        const_iterator( Link *pLink ) :
+                                pLink( pLink )
+                        {
+                        }
+                        const_iterator( const iterator &i ) :
+                                pLink( i.pLink )
+                        {
+                        }
+                public:
+                        bool operator==( const const_iterator &oth ) const
+                        {
+                                return ( pLink == oth.pLink );
+                        }
+                        bool operator==( const Link *pOth ) const
+                        {
+                                return ( pLink == pOth );
+                        }
+                        bool operator!=( const const_iterator &oth ) const
+                        {
+                                return ( pLink != oth.pLink );
+                        }
+                        bool operator!=( const Link *pOth ) const
+                        {
+                                return ( pLink != pOth );
+                        }
+                        const value &operator*()
+                        {
+                                return *(pLink->pValue);
+                        }
+                        const value *operator->()
+                        {
+                                return pLink->pValue;
+                        }
+                        const_iterator &operator++()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+                        const_iterator &operator--()
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        
+                        const_iterator &operator++( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pNext;
+                                return *this;
+                        }
+                        const_iterator &operator--( int )
+                        {
+                                if( pLink != NULL )
+                                        pLink = pLink->pPrev;
+                                return *this;
+                        }
+                        const_iterator &operator=( const iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                        const_iterator &operator=( const const_iterator &oth )
+                        {
+                                pLink = oth.pLink;
+                                return *this;
+                        }
+                };
+                /**
+                 * Get an iterator pointing to the first item in the list.
+                 *@returns (iterator)
+                 */
+                iterator begin()
+                {
+                        return iterator( pFirst );
+                }
+                /**
+                 * Get a const iterator pointing to the first item in the list.
+                 *@returns (const const_iterator)
+                 */
+                const const_iterator begin() const
+                {
+                        return const_iterator( pFirst );
+                }
+                /**
+                 * Get an iterator pointing to a place just past the last item in
+                 *              the list.
+                 *@returns (const Link *)
+                 */
+                const Link *end() const
+                {
+                        return NULL;
+                }
+                /**
+                 * Erase an item from the list.
+                 *@param i (iterator) The item to erase.
+                 */
+                void erase( iterator &i )
+                {
+                        Link *pCur = i.pLink;
+                        Link *pPrev = pCur->pPrev;
+                        if( pPrev == NULL )
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                pFirst = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                if( pFirst == NULL )
+                                        pLast = NULL;
+                                nSize--;
+                                i.pLink = pFirst;
+                        }
+                        else
+                        {
+                                va.destroy( pCur->pValue );
+                                va.deallocate( pCur->pValue, 1 );
+                                Link *pTmp = pCur->pNext;
+                                la.destroy( pCur );
+                                la.deallocate( pCur, 1 );
+                                pPrev->pNext = pTmp;
+                                if( pTmp != NULL )
+                                        pTmp->pPrev = pPrev;
+                                nSize--;
+                                i.pLink = pTmp;
+                        }
+                }
+                /**
+                 * Get the current size of the list.
+                 *@returns (int) The current size of the list.
+                 */
+                int getSize() const
+                {
+                        return nSize;
+                }
+                /**
+                 * Get the first item in the list.
+                 *@returns (value_type &) The first item in the list.
+                 */
+                value &first()
+                {
+                        return *pFirst->pValue;
+                }
+                
+                /**
+                 * Get the first item in the list.
+                 *@returns (const value_type &) The first item in the list.
+                 */
+                const value &first() const
+                {
+                        return *pFirst->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (value_type &) The last item in the list.
+                 */
+                value &last()
+                {
+                        return *pLast->pValue;
+                }
+                
+                /**
+                 * Get the last item in the list.
+                 *@returns (const value_type &) The last item in the list.
+                 */
+                const value &last() const
+                {
+                        return *pLast->pValue;
+                }
+                const bool isEmpty() const
+                {
+                        return (nSize == 0);
+                }
+                
+        private:
+                Link *pFirst;
+                Link *pLast;
+                linkalloc la;
+                valuealloc va;
+                int nSize;
+        };
+}
+#endif
diff --git a/src/logger.cpp b/src/logger.cpp
new file mode 100644
index 0000000..1fc2262
--- /dev/null
+++ b/src/logger.cpp
@@ -0,0 +1,131 @@
+#include "bu/logger.h"
+#include <stdarg.h>
+#include <time.h>
+#include <stdio.h>
+Bu::Logger::Logger()
+{
+}
+Bu::Logger::~Logger()
+{
+}
+void Bu::Logger::log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...)
+{
+        if( (nLevel&nLevelMask) == 0 )
+                return;
+        va_list ap;
+        va_start( ap, sFormat );
+        char *text;
+        vasprintf( &text, sFormat, ap );
+        va_end(ap);
+        
+        time_t t = time(NULL);
+        
+        char *line = NULL;
+        struct tm *pTime;
+        pTime = localtime( &t );
+        asprintf(
+                &line,
+                sLogFormat.getStr(),
+                pTime->tm_year+1900,
+                pTime->tm_mon+1,
+                pTime->tm_mday,
+                pTime->tm_hour,
+                pTime->tm_min,
+                pTime->tm_sec,
+                nLevel,
+                sFile,
+                nLine,
+                text,
+                sFunction
+                );
+        write( fileno(stdout), line, strlen(line) );
+        free( text );
+        free( line );
+}
+void Bu::Logger::setFormat( const Bu::FString &str )
+{
+        sLogFormat = "";
+        static char fmts[][4]={
+                {'y', 'd', '0', '1'},
+                {'m', 'd', '0', '2'},
+                {'d', 'd', '0', '3'},
+                {'h', 'd', '0', '4'},
+                {'M', 'd', '0', '5'},
+                {'s', 'd', '0', '6'},
+                {'L', 'd', '0', '7'},
+                {'f', 's', '0', '8'},
+                {'l', 'd', '0', '9'},
+                {'t', 's', '1', '0'},
+                {'F', 's', '1', '1'},
+                {'\0', '\0', '\0', '\0'},
+        };
+        
+        for( const char *s = str.getStr(); *s; s++ )
+        {
+                if( *s == '%' )
+                {
+                        sLogFormat += '%';
+                        Bu::FString sBuf;
+                        for(;;)
+                        {
+                                s++;
+                                int l;
+                                for( l = 0;; l++ )
+                                {
+                                        if( fmts[l][0] == '\0' )
+                                        {
+                                                sBuf += *s;
+                                                break;
+                                        }
+                                        else if( *s == fmts[l][0] )
+                                        {
+                                                sLogFormat += fmts[l][2];
+                                                sLogFormat += fmts[l][3];
+                                                sLogFormat += '$';
+                                                sLogFormat += sBuf;
+                                                sLogFormat += fmts[l][1];
+                                                break;
+                                        }
+                                }
+                                if( fmts[l][0] != '\0' )
+                                        break;
+                        }
+                }
+                else
+                {
+                        sLogFormat += *s;
+                }
+        }
+        sLogFormat += '\n';
+        write( fileno(stdout), sLogFormat.getStr(), sLogFormat.getSize() );
+}
+void Bu::Logger::setMask( int n )
+{
+        nLevelMask = n;
+}
+void Bu::Logger::setLevel( int n )
+{
+        int j;
+        for( j = 31; j > 0; j-- )
+        {
+                if( (n&(1<<j)) )
+                {
+                        for(; j >= 0; j-- )
+                        {
+                                n |= (1<<j);
+                        }
+                        nLevelMask = n;
+                        return;
+                }
+        }
+}
diff --git a/src/logger.h b/src/logger.h
new file mode 100644
index 0000000..f8e1692
--- /dev/null
+++ b/src/logger.h
@@ -0,0 +1,112 @@
+#ifndef BU_LOGGER_H
+#define BU_LOGGER_H
+#include "bu/singleton.h"
+#include "bu/fstring.h"
+namespace Bu
+{
+        /**
+         * Simple logging facility.  All output goes straight to stdout, unlike the
+         * old multi-log system.  Generally we expect any program complex enough to
+         * want to use this will have other facilities for processing the logging
+         * output, but if we need it we can add other output methods.
+         *
+         * Currently implemented as a singleton to avoid clutter with globals, you
+         * generally never want to use the logging system directly, it's annoying.
+         * Instead use the handy macros lineLog, setLogMask, setLogFormat, and
+         * setLogLevel.  They do all the real work for you.
+         *
+         * In the log format, you can specify extra information that will be written
+         * to the log with every message, and extras in printf style.  Use %X flags
+         * where X is one of the following:
+         * - L - Logging level of the log message (not the current mask)
+         * - y - Full year
+         * - m - Month
+         * - d - Day of month
+         * - h - Hour (24-hour format)
+         * - M - Minutes
+         * - s - Seconds 
+         * - f - Source file
+         * - l - Line number
+         * - F - function name
+         * - t - Text of message (usually important)
+         *
+         * You can include anything extra that you would like, a newline will always
+         * be added automatically, so no need to worry about that.  You can also
+         * include any extra printf style formatting that you would like, for
+         * example: "%h:%02M:%02s" for the time 4:02:09 instead of 4:2:9.
+         *
+         * It's generally handy to create an enum of values you use as levels during
+         * program execution (such as error, warning, info, debug, etc).  These
+         * levels should be treated as bitflags, and the most desirable messages,
+         * i.e. serious errors and the like should be low order (0x01), and the much
+         * less desirable messages, like debugging info, should be higher order
+         * (0xF0).  During operation you can then set either an explicit mask,
+         * selecting just the levels that you would like to see printed, or set the
+         * mask using the setLevel helper function, which simulates verbosity
+         * levels, enabling every flag lower order than the highest order set bit
+         * passed.  I.E. if you had the following enumerated levels:
+         * 
+         *@code
+         enum {
+                logError        = 0x01,
+                logWarning      = 0x02,
+                logInfo         = 0x04,
+                logDebug        = 0x08
+         };
+         @endcode
+         * And you set the mask with setMask( logInfo ) the only messages you would
+         * see are the ones catagorized logInfo.  However, if you used 
+         * setLevel( logInfo ) then you would see logInfo, logWarning, and logError
+         * type messages, since they are lower order.
+         */
+        class Logger : public Bu::Singleton<Bu::Logger>
+        {
+                friend class Bu::Singleton<Bu::Logger>;
+        private:
+                Logger();
+                virtual ~Logger();
+        public:
+                void log( int nLevel, const char *sFile, const char *sFunction, int nLine, const char *sFormat, ...);
+                void setFormat( const Bu::FString &str );
+                void setMask( int n );
+                void setLevel( int n );
+        private:
+                Bu::FString sLogFormat;
+                int nLevelMask;
+        };
+}
+/**
+ * Use Bu::Logger to log a message at the given level and with the given message
+ * using printf style formatting, and include extra data such as the current
+ * file, line number, and function.
+ */
+#define lineLog( nLevel, sFrmt, ...) \
+        Bu::Logger::getInstance().log( nLevel, __FILE__, __PRETTY_FUNCTION__, __LINE__, sFrmt, ##__VA_ARGS__ ) 
+/**
+ * Set the Bu::Logger logging mask directly.  See Bu::Logger::setMask for
+ * details.
+ */
+#define setLogMask( nLevel ) \
+        Bu::Logger::getInstance().setMask( nLevel ) 
+/**
+ * Set the Bu::Logger format. See Bu::Logger::setFormat for details.
+ */
+#define setLogFormat( sFrmt ) \
+        Bu::Logger::getInstance().setFormat( sFrmt ) 
+/**
+ * Set the Bu::Logger logging mask simulating levels.  See Bu::Logger::setLevel
+ * for details.
+ */
+#define setLogLevel( nLevel ) \
+        Bu::Logger::getInstance().setLevel( nLevel ) 
+#endif
diff --git a/src/main.dox b/src/main.dox
new file mode 100644
index 0000000..668d2e3
--- /dev/null
+++ b/src/main.dox
@@ -0,0 +1,14 @@
+/**
+ *@mainpage libbu++ utility library
+ * 
+ *@section secIntro Introduction
+ *
+ * Libbu++ is a C++ library of general utility classes and functions.  They
+ * cover a wide range of topics from streams and sockets to data structures to
+ * data serialization and xml handling to threading.
+ *
+ */
+/**
+ *@namespace Bu The core libbu++ namespace, to ensure things don't get muddied.
+ */
diff --git a/src/membuf.cpp b/src/membuf.cpp
new file mode 100644
index 0000000..45ff5bd
--- /dev/null
+++ b/src/membuf.cpp
@@ -0,0 +1,120 @@
+#include "bu/membuf.h"
+using namespace Bu;
+Bu::MemBuf::MemBuf() :
+        nPos( 0 )
+{
+}
+Bu::MemBuf::MemBuf( const Bu::FString &str ) :
+        sBuf( str ),
+        nPos( 0 )
+{
+}
+Bu::MemBuf::~MemBuf()
+{
+}
+void Bu::MemBuf::close()
+{
+}
+size_t Bu::MemBuf::read( void *pBuf, size_t nBytes )
+{
+        if( (size_t)sBuf.getSize()-(size_t)nPos < nBytes )
+                nBytes = sBuf.getSize()-nPos;
+        memcpy( pBuf, sBuf.getStr()+nPos, nBytes );
+        nPos += nBytes;
+        return nBytes;
+}
+        
+size_t Bu::MemBuf::write( const void *pBuf, size_t nBytes )
+{
+        sBuf.append( (const char *)pBuf, nBytes );
+        nPos += nBytes;
+        return nBytes;
+}
+long Bu::MemBuf::tell()
+{
+        return nPos;
+}
+void Bu::MemBuf::seek( long offset )
+{
+        nPos += offset;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+void Bu::MemBuf::setPos( long pos )
+{
+        nPos = pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+void Bu::MemBuf::setPosEnd( long pos )
+{
+        nPos = sBuf.getSize()-pos;
+        if( nPos < 0 ) nPos = 0;
+        else if( nPos > sBuf.getSize() ) nPos = sBuf.getSize();
+}
+bool Bu::MemBuf::isEOS()
+{
+        return (nPos == sBuf.getSize());
+}
+bool Bu::MemBuf::isOpen()
+{
+        return true;
+}
+void Bu::MemBuf::flush()
+{
+}
+bool Bu::MemBuf::canRead()
+{
+        return !isEOS();
+}
+bool Bu::MemBuf::canWrite()
+{
+        return isEOS();
+}
+bool Bu::MemBuf::isReadable()
+{
+        return true;
+}
+bool Bu::MemBuf::isWritable()
+{
+        return true;
+}
+bool Bu::MemBuf::isSeekable()
+{
+        return true;
+}
+bool Bu::MemBuf::isBlocking()
+{
+        return true;
+}
+void Bu::MemBuf::setBlocking( bool bBlocking )
+{
+}
+Bu::FString &Bu::MemBuf::getString()
+{
+        return sBuf;
+}
diff --git a/src/membuf.h b/src/membuf.h
new file mode 100644
index 0000000..8f53d4b
--- /dev/null
+++ b/src/membuf.h
@@ -0,0 +1,53 @@
+#ifndef BU_MEM_BUF_H
+#define BU_MEM_BUF_H
+#include <stdint.h>
+#include "bu/stream.h"
+#include "bu/fstring.h"
+namespace Bu
+{
+        /**
+         * A memory buffer stream.
+         */
+        class MemBuf : public Stream
+        {
+        public:
+                MemBuf();
+                MemBuf( const Bu::FString &str );
+                virtual ~MemBuf();
+                virtual void close();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                /**
+                 *@todo Allow writes at the current position, not just appending to
+                 * the current buffer.  This is a silly way to do it, but it covers all
+                 * of our bases for now.
+                 */
+                virtual size_t write( const void *pBuf, size_t nBytes );
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+                virtual void flush();
+                virtual bool canRead();
+                virtual bool canWrite();
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+                Bu::FString &getString();
+        private:
+                Bu::FString sBuf;
+                long nPos;
+        };
+}
+#endif
diff --git a/src/cgi.cpp b/src/old/cgi.cpp
index 1fecbbe..1fecbbe 100644
--- a/src/cgi.cpp
+++ b/src/old/cgi.cpp
diff --git a/src/cgi.h b/src/old/cgi.h
index 01142b5..01142b5 100644
--- a/src/cgi.h
+++ b/src/old/cgi.h
diff --git a/src/configmanagerbase.cpp b/src/old/configmanagerbase.cpp
index ac55fe0..ac55fe0 100644
--- a/src/configmanagerbase.cpp
+++ b/src/old/configmanagerbase.cpp
diff --git a/src/configmanagerbase.h b/src/old/configmanagerbase.h
index 381cc1f..381cc1f 100644
--- a/src/configmanagerbase.h
+++ b/src/old/configmanagerbase.h
diff --git a/src/confpair.cpp b/src/old/confpair.cpp
index 4741401..4741401 100644
--- a/src/confpair.cpp
+++ b/src/old/confpair.cpp
diff --git a/src/confpair.h b/src/old/confpair.h
index 56eb06e..56eb06e 100644
--- a/src/confpair.h
+++ b/src/old/confpair.h
diff --git a/src/confpairbase.cpp b/src/old/confpairbase.cpp
index 1203dc0..1203dc0 100644
--- a/src/confpairbase.cpp
+++ b/src/old/confpairbase.cpp
diff --git a/src/confpairbase.h b/src/old/confpairbase.h
index 2530756..2530756 100644
--- a/src/confpairbase.h
+++ b/src/old/confpairbase.h
diff --git a/src/conftree.cpp b/src/old/conftree.cpp
index d9a3a3f..d9a3a3f 100644
--- a/src/conftree.cpp
+++ b/src/old/conftree.cpp
diff --git a/src/conftree.h b/src/old/conftree.h
index 197b1ef..197b1ef 100644
--- a/src/conftree.h
+++ b/src/old/conftree.h
diff --git a/src/connection.cpp b/src/old/connection.cpp
index efef144..efef144 100644
--- a/src/connection.cpp
+++ b/src/old/connection.cpp
diff --git a/src/connection.h b/src/old/connection.h
index 0e991c7..0e991c7 100644
--- a/src/connection.h
+++ b/src/old/connection.h
diff --git a/src/connectionmanager.cpp b/src/old/connectionmanager.cpp
index ea60b2b..ea60b2b 100644
--- a/src/connectionmanager.cpp
+++ b/src/old/connectionmanager.cpp
diff --git a/src/connectionmanager.h b/src/old/connectionmanager.h
index cff036b..cff036b 100644
--- a/src/connectionmanager.h
+++ b/src/old/connectionmanager.h
diff --git a/src/connectionmonitor.cpp b/src/old/connectionmonitor.cpp
index 4f90ee6..4f90ee6 100644
--- a/src/connectionmonitor.cpp
+++ b/src/old/connectionmonitor.cpp
diff --git a/src/connectionmonitor.h b/src/old/connectionmonitor.h
index 9910556..9910556 100644
--- a/src/connectionmonitor.h
+++ b/src/old/connectionmonitor.h
diff --git a/src/flexbuf.cpp b/src/old/flexbuf.cpp
index 6d55294..6d55294 100644
--- a/src/flexbuf.cpp
+++ b/src/old/flexbuf.cpp
diff --git a/src/flexbuf.h b/src/old/flexbuf.h
index 7d7f11a..7d7f11a 100644
--- a/src/flexbuf.h
+++ b/src/old/flexbuf.h
diff --git a/src/formula.cpp b/src/old/formula.cpp
index cf63cf3..cf63cf3 100644
--- a/src/formula.cpp
+++ b/src/old/formula.cpp
diff --git a/src/formula.h b/src/old/formula.h
index 939eb09..939eb09 100644
--- a/src/formula.h
+++ b/src/old/formula.h
diff --git a/src/http.cpp b/src/old/http.cpp
index df7dafe..df7dafe 100644
--- a/src/http.cpp
+++ b/src/old/http.cpp
diff --git a/src/http.h b/src/old/http.h
index 7e9f9a0..7e9f9a0 100644
--- a/src/http.h
+++ b/src/old/http.h
diff --git a/src/httpget.cpp b/src/old/httpget.cpp
index ee1f29c..ee1f29c 100644
--- a/src/httpget.cpp
+++ b/src/old/httpget.cpp
diff --git a/src/httpget.h b/src/old/httpget.h
index 8272641..8272641 100644
--- a/src/httpget.h
+++ b/src/old/httpget.h
diff --git a/src/linkedlist.cpp b/src/old/linkedlist.cpp
index a9902bc..a9902bc 100644
--- a/src/linkedlist.cpp
+++ b/src/old/linkedlist.cpp
diff --git a/src/linkedlist.h b/src/old/linkedlist.h
index e430108..e430108 100644
--- a/src/linkedlist.h
+++ b/src/old/linkedlist.h
diff --git a/src/linkmessenger.cpp b/src/old/linkmessenger.cpp
index 3bd401a..3bd401a 100644
--- a/src/linkmessenger.cpp
+++ b/src/old/linkmessenger.cpp
diff --git a/src/linkmessenger.h b/src/old/linkmessenger.h
index ed52639..ed52639 100644
--- a/src/linkmessenger.h
+++ b/src/old/linkmessenger.h
diff --git a/src/old/list.cpp b/src/old/list.cpp
new file mode 100644
index 0000000..18f1a66
--- /dev/null
+++ b/src/old/list.cpp
@@ -0,0 +1,10 @@
+#include "list.h"
+List::List(  )
+{
+}
+List::~List(  )
+{
+}
diff --git a/src/old/list.h b/src/old/list.h
new file mode 100644
index 0000000..c71b328
--- /dev/null
+++ b/src/old/list.h
@@ -0,0 +1,101 @@
+#ifndef LIST_H
+#define LIST_H
+/** The basic List class ADT.  This, on it's own, does absolutely nothing, but
+  * does define all standard interface functions to access a list.
+  *@author Mike Buland
+  */
+class List
+{
+public:
+        /**
+         * Construct a list.
+         */
+        List();
+        /**
+         * Desconstruct a list.
+         */
+        virtual ~List();
+        /** Gets the value at a specified index.
+          *@param nIndex The index of the item to return.
+          *@returns The specified item, or NULL if the index was beyond the range
+          * of the list.
+          *@author Mike Buland
+          */
+        virtual void *getAt( int nIndex ) = 0;
+        /** Append the given data to the end of the list.  This increases the
+          * size of the list by one.
+          *@param pData The data to append to the list.
+          *@author Mike Buland
+          */
+        virtual void append( void *pData ) = 0;
+        /** Inserts an item at the specified position in the list.  The
+          * new item takes the index that you specify, and all other items
+          * are moved up one position.  The size of the list is increased by
+          * one.
+          *@param pData The value to insert into the list.
+          *@param nPos Where to insert the data into the list.
+          *@author Mike Buland
+          */
+        virtual void insertBefore( void *pData, int nPos = 0 ) = 0;
+        /** Determines the size of the list, in elements.
+          *@returns The size of the list.
+          *@author Mike Buland
+          */
+        virtual int getSize(  ) = 0;
+        /** Determines if the list is empty or not.
+          *@returns True if the list is empty, or false if the list has
+          * data in it (if the size is greater than zero).
+          *@author Mike Buland
+          */
+        virtual bool isEmpty(  ) = 0;
+        /** Deletes an item at the specified index and moves all other
+          * values down one index.  The size of the list is decreased by one.
+          *@param nIndex The index of the item to delete.
+          *@author Mike Buland
+          */
+        virtual void deleteAt( int nIndex ) = 0;
+        /** Completely empties the list, and sets the effective size to
+          * zero.
+          *@author Mike Buland
+          */
+        virtual void empty() = 0;
+        /** Sets the size of the list.  This can be larger or smaller
+          * than what it was previously.  If larger, new blank items will
+          * be added to the end of the list.  If smaller than the old list
+          * items will be deleted from the end.
+          *@param nNewSize The new size of the list.
+          *@author Mike Buland
+          */
+        virtual void setSize( int nNewSize ) = 0;
+        /** Sets a member at a specified location to a new value.
+          * If the member being set is outside of the range of the
+          * current list it should be expanded.
+          *@param nIndex The zero-based index of the item to change.
+          *@param pData The new value for that index.
+          *@author Mike Buland
+          */
+        virtual void setAt( int nIndex, void *pData ) = 0;
+        /** Makes the List work like an array.  Just say listObj[2] to get
+          * the third element.
+          *@param nIndex The index to access in the list.
+          *@returns A pointer to the data at element index.
+          *@author Mike Buland
+          */
+        void *operator[]( int nIndex ) { return getAt( nIndex ); };
+};
+#endif
diff --git a/src/md5.cpp b/src/old/md5.cpp
index c0cacdd..c0cacdd 100644
--- a/src/md5.cpp
+++ b/src/old/md5.cpp
diff --git a/src/md5.h b/src/old/md5.h
index 7f77d83..7f77d83 100644
--- a/src/md5.h
+++ b/src/old/md5.h
diff --git a/src/multilog.cpp b/src/old/multilog.cpp
index 143ee89..143ee89 100644
--- a/src/multilog.cpp
+++ b/src/old/multilog.cpp
diff --git a/src/multilog.h b/src/old/multilog.h
index 692095a..692095a 100644
--- a/src/multilog.h
+++ b/src/old/multilog.h
diff --git a/src/multilogchannel.cpp b/src/old/multilogchannel.cpp
index ee4c9bf..ee4c9bf 100644
--- a/src/multilogchannel.cpp
+++ b/src/old/multilogchannel.cpp
diff --git a/src/multilogchannel.h b/src/old/multilogchannel.h
index d891a65..d891a65 100644
--- a/src/multilogchannel.h
+++ b/src/old/multilogchannel.h
diff --git a/src/multilogtext.cpp b/src/old/multilogtext.cpp
index 4337cc9..4337cc9 100644
--- a/src/multilogtext.cpp
+++ b/src/old/multilogtext.cpp
diff --git a/src/multilogtext.h b/src/old/multilogtext.h
index 197aef1..197aef1 100644
--- a/src/multilogtext.h
+++ b/src/old/multilogtext.h
diff --git a/src/ordhash.cpp b/src/old/ordhash.cpp
index 77cbd61..77cbd61 100644
--- a/src/ordhash.cpp
+++ b/src/old/ordhash.cpp
diff --git a/src/ordhash.h b/src/old/ordhash.h
index e946f95..e946f95 100644
--- a/src/ordhash.h
+++ b/src/old/ordhash.h
diff --git a/src/pqueue.cpp b/src/old/pqueue.cpp
index 1f0b8b5..1f0b8b5 100644
--- a/src/pqueue.cpp
+++ b/src/old/pqueue.cpp
diff --git a/src/pqueue.h b/src/old/pqueue.h
index 8307d56..8307d56 100644
--- a/src/pqueue.h
+++ b/src/old/pqueue.h
diff --git a/src/old/protocol.cpp b/src/old/protocol.cpp
new file mode 100644
index 0000000..78b3ee2
--- /dev/null
+++ b/src/old/protocol.cpp
@@ -0,0 +1,20 @@
+#include "protocol.h"
+Protocol::Protocol()
+{
+        pConnection = NULL;
+}
+Protocol::~Protocol()
+{
+}
+void Protocol::setConnection( Connection *pNewConnection )
+{
+        pConnection = pNewConnection;
+}
+Connection *Protocol::getConnection()
+{
+        return pConnection;
+}
diff --git a/src/old/protocol.h b/src/old/protocol.h
new file mode 100644
index 0000000..09e1c98
--- /dev/null
+++ b/src/old/protocol.h
@@ -0,0 +1,62 @@
+#ifndef PROTOCOL_H
+#define PROTOCOL_H
+#include "connection.h"
+/** This is the template for a class that handles specialized input and output
+  * to connections of different types with different protocols.
+  *@author Mike Buland
+  */
+class Protocol
+{
+public:
+        /** Constructor */
+    Protocol();
+        /** Deconstructor */
+    virtual ~Protocol();
+        /**
+         * Function is called every time there is new data on the line.  This is
+         * called directly from the Connection class to process data.  This is not
+         * called whever there is pending data on the input, but every time new data
+         * is added to the input buffer.
+         *@returns True if processing went alright, false if something went wrong,
+         * I suppose.  In truth this value is thrown away right now.
+         *@todo Either make a return value of false mean something, or make these
+         * void.
+         */
+        virtual bool onNewData()=0;
+        /**
+         * Function is called when there is a new connection.  This should only
+         * happen once per Protocol object, but gives each protocol object a
+         * chance to perform connection handshaking and initialization at a point
+         * where they know that they have a handle to an active Connection.
+         *@returns See onNewData
+         */
+        virtual bool onNewConnection()=0;
+        virtual void onNewClientConnection(){};
+        virtual void poll(){};
+        /**
+         * Sets the Protocol's Connection object.  This is rather important, and
+         * handled usually by the ConnectionManager.
+         *@param pNewConnection The Connection object that this protocol will use to
+         * deal with the outside world.
+         */
+        void setConnection( class Connection *pNewConnection );
+        /**
+         * Get a pointer to this object's Connection object, or NULL if one was
+         * never set.  If used with the ConnectionManager that should never happen.
+         *@returns A pointer to the active Connection.
+         */
+        Connection *getConnection();
+private:
+        class Connection *pConnection; /**< The pointer to the Connection. */
+};
+#endif
diff --git a/src/protocoltelnet.cpp b/src/old/protocoltelnet.cpp
index b169a51..b169a51 100644
--- a/src/protocoltelnet.cpp
+++ b/src/old/protocoltelnet.cpp
diff --git a/src/protocoltelnet.h b/src/old/protocoltelnet.h
index a6d2e49..a6d2e49 100644
--- a/src/protocoltelnet.h
+++ b/src/old/protocoltelnet.h
diff --git a/src/queue.cpp b/src/old/queue.cpp
index 42999fe..42999fe 100644
--- a/src/queue.cpp
+++ b/src/old/queue.cpp
diff --git a/src/queue.h b/src/old/queue.h
index 692f5d8..692f5d8 100644
--- a/src/queue.h
+++ b/src/old/queue.h
diff --git a/src/ringlist.cpp b/src/old/ringlist.cpp
index 9efbbc4..9efbbc4 100644
--- a/src/ringlist.cpp
+++ b/src/old/ringlist.cpp
diff --git a/src/ringlist.h b/src/old/ringlist.h
index bc069f3..bc069f3 100644
--- a/src/ringlist.h
+++ b/src/old/ringlist.h
diff --git a/src/sbuffer.cpp b/src/old/sbuffer.cpp
index f84f8a3..f84f8a3 100644
--- a/src/sbuffer.cpp
+++ b/src/old/sbuffer.cpp
diff --git a/src/sbuffer.h b/src/old/sbuffer.h
index 65feb71..65feb71 100644
--- a/src/sbuffer.h
+++ b/src/old/sbuffer.h
diff --git a/src/serializerbinary.cpp b/src/old/serializerbinary.cpp
index ea7ed93..ea7ed93 100644
--- a/src/serializerbinary.cpp
+++ b/src/old/serializerbinary.cpp
diff --git a/src/serializerbinary.h b/src/old/serializerbinary.h
index 8510fcd..8510fcd 100644
--- a/src/serializerbinary.h
+++ b/src/old/serializerbinary.h
diff --git a/src/serializerbzip2.cpp b/src/old/serializerbzip2.cpp
index bafabc8..bafabc8 100644
--- a/src/serializerbzip2.cpp
+++ b/src/old/serializerbzip2.cpp
diff --git a/src/serializerbzip2.h b/src/old/serializerbzip2.h
index 4aeb22e..4aeb22e 100644
--- a/src/serializerbzip2.h
+++ b/src/old/serializerbzip2.h
diff --git a/src/serializerconnection.cpp b/src/old/serializerconnection.cpp
index 2934c8b..2934c8b 100644
--- a/src/serializerconnection.cpp
+++ b/src/old/serializerconnection.cpp
diff --git a/src/serializerconnection.h b/src/old/serializerconnection.h
index e8d85c6..e8d85c6 100644
--- a/src/serializerconnection.h
+++ b/src/old/serializerconnection.h
diff --git a/src/serializertext.cpp b/src/old/serializertext.cpp
index 9cf4394..9cf4394 100644
--- a/src/serializertext.cpp
+++ b/src/old/serializertext.cpp
diff --git a/src/serializertext.h b/src/old/serializertext.h
index 01b7f7b..01b7f7b 100644
--- a/src/serializertext.h
+++ b/src/old/serializertext.h
diff --git a/src/sha1.cpp b/src/old/sha1.cpp
index 8270c3b..8270c3b 100644
--- a/src/sha1.cpp
+++ b/src/old/sha1.cpp
diff --git a/src/sha1.h b/src/old/sha1.h
index ab6081d..ab6081d 100644
--- a/src/sha1.h
+++ b/src/old/sha1.h
diff --git a/src/stack.cpp b/src/old/stack.cpp
index 8d9565c..8d9565c 100644
--- a/src/stack.cpp
+++ b/src/old/stack.cpp
diff --git a/src/stack.h b/src/old/stack.h
index 30e2a19..30e2a19 100644
--- a/src/stack.h
+++ b/src/old/stack.h
diff --git a/src/staticstring.cpp b/src/old/staticstring.cpp
index 60f130f..60f130f 100644
--- a/src/staticstring.cpp
+++ b/src/old/staticstring.cpp
diff --git a/src/staticstring.h b/src/old/staticstring.h
index 4c3f7b8..4c3f7b8 100644
--- a/src/staticstring.h
+++ b/src/old/staticstring.h
diff --git a/src/stringrep.cpp b/src/old/stringrep.cpp
index a505f8a..a505f8a 100644
--- a/src/stringrep.cpp
+++ b/src/old/stringrep.cpp
diff --git a/src/stringrep.h b/src/old/stringrep.h
index eaa4a12..eaa4a12 100644
--- a/src/stringrep.h
+++ b/src/old/stringrep.h
diff --git a/src/tests/clistress.cpp b/src/old/tests/clistress.cpp
index 6b0ac66..6b0ac66 100644
--- a/src/tests/clistress.cpp
+++ b/src/old/tests/clistress.cpp
diff --git a/src/tests/confpair.cpp b/src/old/tests/confpair.cpp
index fb1b0d3..fb1b0d3 100644
--- a/src/tests/confpair.cpp
+++ b/src/old/tests/confpair.cpp
diff --git a/src/tests/connect.cpp b/src/old/tests/connect.cpp
index a9fca64..a9fca64 100644
--- a/src/tests/connect.cpp
+++ b/src/old/tests/connect.cpp
diff --git a/src/tests/exception.cpp b/src/old/tests/exception.cpp
index 6417692..6417692 100644
--- a/src/tests/exception.cpp
+++ b/src/old/tests/exception.cpp
diff --git a/src/tests/formula.cpp b/src/old/tests/formula.cpp
index 976b039..976b039 100644
--- a/src/tests/formula.cpp
+++ b/src/old/tests/formula.cpp
diff --git a/src/old/tests/hash.cpp b/src/old/tests/hash.cpp
new file mode 100644
index 0000000..2fc6968
--- /dev/null
+++ b/src/old/tests/hash.cpp
@@ -0,0 +1,116 @@
+#include "hash.h"
+#include "staticstring.h"
+int main()
+{
+        const char *names[]={
+                "Homer the Great",
+                "And Maggie Makes Three",
+                "Bart's Comet",
+                "Homie The Clown",
+                "Bart Vs Australia",
+                "Homer vs Patty and Selma",
+                "A star is burns",
+                "Lisa's Wedding",
+                "Two Dozen and One Greyhounds",
+                "The PTA Disbands",
+                "Round Springfield",
+                "The Springfield connection",
+                "Lemon of Troy",
+                "Who Shot Mr. Burns (Pt. 1)",
+                "Who Shot Mr. Burns (pt. 2)",
+                "Radioactive Man",
+                "Home Sweet Homediddly-dum-doodly",
+                "Bart Sells His Soul",
+                "Lisa the Vegetarian",
+                "Treehouse of horror VI",
+                "King Size Homer",
+                "Mother Simpson",
+                "Sideshow Bob's Last Gleaming",
+                "The Simpson's 138th Show Spectacular",
+                "Marge Be Not Proud",
+                "Team Homer",
+                "Two Bad Neighbors",
+                "Scenes From the Class Struggle in Springfield",
+                "Bart the Fink",
+                "Lisa the Iconoclast",
+                "Homer the Smithers",
+                "The Day the Violence Died",
+                "A Fish Called Selma",
+                "Bart on the road",
+                "22 Short Films about Springfield",
+                "The Curse of the Flying Hellfish",
+                "Much Apu about Nothing",
+                "Homerpalooza",
+                "The Summer of 4 Ft 2",
+                "Treehouse of Horror VII",
+                "You Only Move Twice",
+                "The Homer They Fall",
+                "Burns Baby Burns",
+                "Bart After Dark",
+                "A Millhouse Divided",
+                "Lisas Date With Destiny",
+                "Hurricane Neddy",
+                "The Mysterious Voyage of Our Homer",
+                "The Springfield Files",
+                "The Twisted World of Marge Simpson",
+                "Mountain of Madness",
+                NULL
+        };
+        Hash<const char *, int> sTest;
+        printf("Inserting\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                sTest[names[j]] = j;
+        }
+        
+        printf("Test1: %d, Test2: %d\n", sTest.has("Lemon of Troy"), sTest.has(std::string("Lemon of Troy").c_str() ) );
+        sTest.has(std::string("Lemon of Troy").c_str() );
+        printf("Getting\n-------------------\n\n");
+        sTest.erase("Homer the Great");
+        sTest["Bart's Comet"].erase();
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+        printf("Testing\n-------------------\n\n");
+        for( int j = 0; j < 33; j++ )
+        {
+                if( sTest.has(names[j]) )
+                {
+                        if( sTest[names[j]] != j )
+                        {
+                                printf("'%s' should be %d, is %d\n",
+                                        names[j], j,
+                                        sTest[names[j]].value()
+                                        );
+                        }
+                }
+                else
+                {
+                        printf("Missing element %d, '%s'\n", j, names[j] );
+                }
+        }
+        printf("Clearing\n-------------------\n\n");
+        sTest.clear();
+        
+        for( Hash<const char *, int>::iterator i = sTest.begin();
+                 i != sTest.end(); i++ )
+        {
+                Hash<const char *, int>::iterator j = i;
+                printf("%d: %s\n", (*j).second, (*j).first );
+        }
+}
diff --git a/src/tests/hashtest.cpp b/src/old/tests/hashtest.cpp
index eaa84a0..eaa84a0 100644
--- a/src/tests/hashtest.cpp
+++ b/src/old/tests/hashtest.cpp
diff --git a/src/tests/hashtest2.cpp b/src/old/tests/hashtest2.cpp
index 74700fd..74700fd 100644
--- a/src/tests/hashtest2.cpp
+++ b/src/old/tests/hashtest2.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.cpp b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
index 51d82f3..51d82f3 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.cpp
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.cpp
diff --git a/src/tests/httpsrv/httpconnectionmonitor.h b/src/old/tests/httpsrv/httpconnectionmonitor.h
index 30c0afd..30c0afd 100644
--- a/src/tests/httpsrv/httpconnectionmonitor.h
+++ b/src/old/tests/httpsrv/httpconnectionmonitor.h
diff --git a/src/tests/httpsrv/main.cpp b/src/old/tests/httpsrv/main.cpp
index 2f1563c..2f1563c 100644
--- a/src/tests/httpsrv/main.cpp
+++ b/src/old/tests/httpsrv/main.cpp
diff --git a/src/tests/log.cpp b/src/old/tests/log.cpp
index d7cfa0b..d7cfa0b 100644
--- a/src/tests/log.cpp
+++ b/src/old/tests/log.cpp
diff --git a/src/tests/md5test.cpp b/src/old/tests/md5test.cpp
index 6f832df..6f832df 100644
--- a/src/tests/md5test.cpp
+++ b/src/old/tests/md5test.cpp
diff --git a/src/tests/ordhash.cpp b/src/old/tests/ordhash.cpp
index f1d96ec..f1d96ec 100644
--- a/src/tests/ordhash.cpp
+++ b/src/old/tests/ordhash.cpp
diff --git a/src/tests/param.cpp b/src/old/tests/param.cpp
index a4d2824..a4d2824 100644
--- a/src/tests/param.cpp
+++ b/src/old/tests/param.cpp
diff --git a/src/tests/param.h b/src/old/tests/param.h
index 2756b69..2756b69 100644
--- a/src/tests/param.h
+++ b/src/old/tests/param.h
diff --git a/src/tests/plugin/main.cpp b/src/old/tests/plugin/main.cpp
index 51c8390..51c8390 100644
--- a/src/tests/plugin/main.cpp
+++ b/src/old/tests/plugin/main.cpp
diff --git a/src/tests/plugin/plugin.cpp b/src/old/tests/plugin/plugin.cpp
index ea558fd..ea558fd 100644
--- a/src/tests/plugin/plugin.cpp
+++ b/src/old/tests/plugin/plugin.cpp
diff --git a/src/tests/plugin/plugin.h b/src/old/tests/plugin/plugin.h
index f726867..f726867 100644
--- a/src/tests/plugin/plugin.h
+++ b/src/old/tests/plugin/plugin.h
diff --git a/src/tests/qsort.cpp b/src/old/tests/qsort.cpp
index 28c6f03..28c6f03 100644
--- a/src/tests/qsort.cpp
+++ b/src/old/tests/qsort.cpp
diff --git a/src/tests/sbuffer.cpp b/src/old/tests/sbuffer.cpp
index 02798cb..02798cb 100644
--- a/src/tests/sbuffer.cpp
+++ b/src/old/tests/sbuffer.cpp
diff --git a/src/tests/serialize.cpp b/src/old/tests/serialize.cpp
index e233704..e233704 100644
--- a/src/tests/serialize.cpp
+++ b/src/old/tests/serialize.cpp
diff --git a/src/tests/serializetext.cpp b/src/old/tests/serializetext.cpp
index f6be7d3..f6be7d3 100644
--- a/src/tests/serializetext.cpp
+++ b/src/old/tests/serializetext.cpp
diff --git a/src/tests/sha1.cpp b/src/old/tests/sha1.cpp
index df3113c..df3113c 100644
--- a/src/tests/sha1.cpp
+++ b/src/old/tests/sha1.cpp
diff --git a/src/tests/sptr.cpp b/src/old/tests/sptr.cpp
index 252463b..38d3675 100644
--- a/src/tests/sptr.cpp
+++ b/src/old/tests/sptr.cpp
@@ -9,12 +9,12 @@ public:
                printf("Created.\n");
        }
-        virtual ~Annoy()
+        ~Annoy()
        {
                printf("Destroyed.\n");
        }
-        virtual void go()
+        void go()
        {
                printf("%d: I'm annoying.\n", ++nCnt);
        }
@@ -22,22 +22,6 @@ public:
        int nCnt;
 };
-class Annoy2: public Annoy
-{
-public:
-        Annoy2(){};
-        virtual ~Annoy2(){};
-        virtual void go()
-        {
-                printf("{{I'm Annoy2!!}} ");
-                Annoy::go();
-        }
-        virtual void go2()
-        {
-                printf("This is me, on my own...\n");
-        }
-};
 void beAnnoying( SPtr<Annoy> bob )
 {
        printf("bob-Count: %d\n", bob.count() );
@@ -46,7 +30,7 @@ void beAnnoying( SPtr<Annoy> bob )
 int main()
 {
-        SPtr<Annoy> pt( new Annoy2 );
+        SPtr<Annoy> pt( new Annoy );
        printf("Count: %d\n", pt.count() );
        pt->go();
@@ -63,14 +47,6 @@ int main()
                        pt3->go();
                        beAnnoying( pt3 );
-                        {
-                                SPtr<Annoy2> pt4( SPtrCast<Annoy2>( pt3 ) );
-                                printf("Count: %d\n", pt4.count() );
-                                pt4->go2();
-                        }
-                        printf("Count: %d\n", pt.count() );
                }
                printf("Count: %d\n", pt.count() );
        }
diff --git a/src/tests/srvstress.cpp b/src/old/tests/srvstress.cpp
index d9a9a1c..d9a9a1c 100644
--- a/src/tests/srvstress.cpp
+++ b/src/old/tests/srvstress.cpp
diff --git a/src/tests/strhash.cpp b/src/old/tests/strhash.cpp
index f6528ca..f6528ca 100644
--- a/src/tests/strhash.cpp
+++ b/src/old/tests/strhash.cpp
diff --git a/src/tests/teltest/main.cpp b/src/old/tests/teltest/main.cpp
index 5d3ec26..5d3ec26 100644
--- a/src/tests/teltest/main.cpp
+++ b/src/old/tests/teltest/main.cpp
diff --git a/src/tests/teltest/telnetmonitor.cpp b/src/old/tests/teltest/telnetmonitor.cpp
index 65954eb..65954eb 100644
--- a/src/tests/teltest/telnetmonitor.cpp
+++ b/src/old/tests/teltest/telnetmonitor.cpp
diff --git a/src/tests/teltest/telnetmonitor.h b/src/old/tests/teltest/telnetmonitor.h
index ba5761e..ba5761e 100644
--- a/src/tests/teltest/telnetmonitor.h
+++ b/src/old/tests/teltest/telnetmonitor.h
diff --git a/src/tests/xmlreadtest.cpp b/src/old/tests/xmlreadtest.cpp
index d061810..d061810 100644
--- a/src/tests/xmlreadtest.cpp
+++ b/src/old/tests/xmlreadtest.cpp
diff --git a/src/tests/xmlrepltest.cpp b/src/old/tests/xmlrepltest.cpp
index 9667705..9667705 100644
--- a/src/tests/xmlrepltest.cpp
+++ b/src/old/tests/xmlrepltest.cpp
diff --git a/src/tests/xmlwritetest.cpp b/src/old/tests/xmlwritetest.cpp
index a22d19d..a22d19d 100644
--- a/src/tests/xmlwritetest.cpp
+++ b/src/old/tests/xmlwritetest.cpp
diff --git a/src/tokenstring.cpp b/src/old/tokenstring.cpp
index e57ba69..e57ba69 100644
--- a/src/tokenstring.cpp
+++ b/src/old/tokenstring.cpp
diff --git a/src/tokenstring.h b/src/old/tokenstring.h
index 42f7309..42f7309 100644
--- a/src/tokenstring.h
+++ b/src/old/tokenstring.h
diff --git a/src/tqsort.h b/src/old/tqsort.h
index c836b4f..c836b4f 100644
--- a/src/tqsort.h
+++ b/src/old/tqsort.h
diff --git a/src/unit/hashtable/hashtable.cpp b/src/old/unit/hashtable/hashtable.cpp
index b2e1cf5..b2e1cf5 100644
--- a/src/unit/hashtable/hashtable.cpp
+++ b/src/old/unit/hashtable/hashtable.cpp
diff --git a/src/unit/xml/xml.cpp b/src/old/unit/xml/xml.cpp
index e4d779c..e4d779c 100644
--- a/src/unit/xml/xml.cpp
+++ b/src/old/unit/xml/xml.cpp
diff --git a/src/xmldocument.cpp b/src/old/xmldocument.cpp
index d7867d5..95b9788 100644
--- a/src/xmldocument.cpp
+++ b/src/old/xmldocument.cpp
@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include "xmlwriter.h"
+#include "xmldocument.h"
 XmlDocument::XmlDocument( XmlNode *pRoot )
 {
@@ -17,28 +17,23 @@ XmlDocument::~XmlDocument()
        }
 }
-void XmlDocument::addNode( const char *sName, const char *sContent, bool bClose )
+void XmlDocument::addNode( const Bu::FString &sName )
 {
        if( pRoot == NULL )
        {
                // This is the first node, so ignore position and just insert it.
-                pCurrent = pRoot = new XmlNode( sName, NULL, sContent );
+                pCurrent = pRoot = new XmlNode( sName );
        }
        else
        {
-                pCurrent = pCurrent->addChild( sName, sContent );
+                pCurrent = pCurrent->addChild( sName );
-        }
-        if( bClose )
-        {
-                closeNode();
        }
 }
+/*
 void XmlDocument::setName( const char *sName )
 {
        pCurrent->setName( sName );
-}
+}*/
 bool XmlDocument::isCompleted()
 {
@@ -143,7 +138,8 @@ void XmlDocument::setContent( const char *sContent )
 {
        if( pCurrent )
        {
-                pCurrent->setContent( sContent );
+                printf("XmlDocument::setContent:  not yet implemented.\n");
+                //pCurrent->setContent( sContent );
        }
 }
diff --git a/src/xmldocument.h b/src/old/xmldocument.h
index 6671c41..e0c36eb 100644
--- a/src/xmldocument.h
+++ b/src/old/xmldocument.h
@@ -39,13 +39,7 @@ public:
         * the node and setting the content and name.  If this is set to true the
         * node is appended, but the context node doesn't change.
         */
-        void addNode( const char *sName=NULL, const char *sContent=NULL, bool bClose=false );
+        void addNode( const Bu::FString &sName );
-        /**
-         * Set the name of the current node context.
-         *@param sName The new name of the node.
-         */
-        void setName( const char *sName );
        /**
         * Close the current node context.  This will move the current context to
diff --git a/src/xmlfilereader.cpp b/src/old/xmlfilereader.cpp
index ed674a8..ed674a8 100644
--- a/src/xmlfilereader.cpp
+++ b/src/old/xmlfilereader.cpp
diff --git a/src/xmlfilereader.h b/src/old/xmlfilereader.h
index e3e02c2..e3e02c2 100644
--- a/src/xmlfilereader.h
+++ b/src/old/xmlfilereader.h
diff --git a/src/xmlfilewriter.cpp b/src/old/xmlfilewriter.cpp
index 3c6fb41..3c6fb41 100644
--- a/src/xmlfilewriter.cpp
+++ b/src/old/xmlfilewriter.cpp
diff --git a/src/xmlfilewriter.h b/src/old/xmlfilewriter.h
index e328f96..e328f96 100644
--- a/src/xmlfilewriter.h
+++ b/src/old/xmlfilewriter.h
diff --git a/src/xmlnode.cpp b/src/old/xmlnode.cpp
index b1ed9a9..96d5850 100644
--- a/src/xmlnode.cpp
+++ b/src/old/xmlnode.cpp
@@ -1,53 +1,15 @@
 #include "xmlnode.h"
-#include "hashfunctionstring.h"
-XmlNode::XmlNode( const char *sName, XmlNode *pParent, const char *sContent ) :
+XmlNode::XmlNode( const Bu::FString &sName, XmlNode *pParent ) :
-        hProperties( new HashFunctionString(), 53, false ),
+        sName( sName ),
-        hChildren( new HashFunctionString(), 53, true )
+        pParent( pParent )
 {
-        this->pParent = pParent;
-        if( sName != NULL )
-        {
-                setName( sName );
-        }
-        if( sContent != NULL )
-        {
-                this->sPreContent = new std::string( sContent );
-        }
-        else
-        {
-                this->sPreContent = NULL;
-        }
-        nCurContent = 0;
 }
 XmlNode::~XmlNode()
 {
-        for( int j = 0; j < lChildren.getSize(); j++ )
-        {
-                delete (XmlNode *)lChildren[j];
-        }
-        for( int j = 0; j < lPropNames.getSize(); j++ )
-        {
-                delete (std::string *)lPropNames[j];
-        }
-        for( int j = 0; j < lPropValues.getSize(); j++ )
-        {
-                delete (std::string *)lPropValues[j];
-        }
-        for( int j = 0; j < lPostContent.getSize(); j++ )
-        {
-                if( lPostContent[j] != NULL )
-                {
-                        delete (std::string *)lPostContent[j];
-                }
-        }
-        if( sPreContent )
-        {
-                delete sPreContent;
-        }
 }
+/*
 void XmlNode::setName( const char *sName )
 {
        if( pParent )
@@ -120,18 +82,18 @@ const char *XmlNode::getContent( int nIndex )
        }
        return NULL;
-}
+}*/
-XmlNode *XmlNode::addChild( const char *sName, const char *sContent )
+XmlNode *XmlNode::addChild( const Bu::FString &sName )
 {
-        return addChild( new XmlNode( sName, this, sContent ) );
+        return addChild( new XmlNode( sName, this ) );
 }
 XmlNode *XmlNode::addChild( XmlNode *pNode )
 {
-        lChildren.append( pNode );
+        Child c = { typeNode };
-        lPostContent.append( NULL );
+        c.pNode = pNode;
-        nCurContent++;
+        lChildren.append( c );
        pNode->pParent = this;
        return pNode;
@@ -142,21 +104,16 @@ XmlNode *XmlNode::getParent()
        return pParent;
 }
-void XmlNode::addProperty( const char *sName, const char *sValue )
+void XmlNode::addProperty( const Bu::FString &sName, const Bu::FString &sValue )
 {
-        std::string *pName = new std::string( sName );
+        hProperties.insert( sName, sValue );
-        std::string *pValue = new std::string( sValue );
-        
-        hProperties.insert( pName->c_str(), pValue->c_str() );
-        lPropNames.append( pName );
-        lPropValues.append( pValue );
 }
 int XmlNode::getNumProperties()
 {
-        return lPropNames.getSize();
+        return hProperties.size();
 }
+/*
 const char *XmlNode::getPropertyName( int nIndex )
 {
        std::string *tmp = ((std::string *)lPropNames[nIndex]);
@@ -172,15 +129,12 @@ const char *XmlNode::getProperty( int nIndex )
                return NULL;
        return tmp->c_str();
 }
+*/
-const char *XmlNode::getProperty( const char *sName )
+Bu::FString XmlNode::getProperty( const Bu::FString &sName )
 {
-        const char *tmp = (const char *)hProperties[sName];
+        return hProperties[sName];
-        if( tmp == NULL )
-                return NULL;
-        return tmp;
 }
+/*
 void XmlNode::deleteProperty( int nIndex )
 {
        hProperties.del( ((std::string *)lPropNames[nIndex])->c_str() );
@@ -194,29 +148,33 @@ void XmlNode::deleteProperty( int nIndex )
 bool XmlNode::hasChildren()
 {
-        return lChildren.getSize()>0;
+        return hChildren.getSize()>0;
-}
+}*/
 int XmlNode::getNumChildren()
 {
        return lChildren.getSize();
 }
+/*
 XmlNode *XmlNode::getChild( int nIndex )
 {
        return (XmlNode *)lChildren[nIndex];
 }
+*/
-XmlNode *XmlNode::getChild( const char *sName, int nSkip )
+XmlNode *XmlNode::getChild( const Bu::FString &sName, int nSkip )
 {
-        return (XmlNode *)hChildren.get( sName, nSkip );
+        if( !hChildren.has( sName ) )
+                return NULL;
+        Bu::List<XmlNode *>::iterator i = hChildren[sName]->begin();
+        return *i;
 }
-const char *XmlNode::getName()
+Bu::FString XmlNode::getName()
 {
-        return sName.c_str();
+        return sName;
 }
+/*
 void XmlNode::deleteNode( int nIndex, const char *sReplacementText )
 {
        XmlNode *xRet = detatchNode( nIndex, sReplacementText );
@@ -442,4 +400,4 @@ void XmlNode::deleteNodeKeepChildren( int nIndex )
 void XmlNode::replaceNodeWithChildren( int nIndex, XmlNode *pNewNode )
 {
 }
+*/
diff --git a/src/xmlnode.h b/src/old/xmlnode.h
index 7525306..c895cd8 100644
--- a/src/xmlnode.h
+++ b/src/old/xmlnode.h
@@ -2,8 +2,9 @@
 #define XMLNODE
 #include <iostream>
-#include "linkedlist.h"
+#include "bu/list.h"
-#include "hashtable.h"
+#include "bu/hash.h"
+#include "bu/fstring.h"
 /**
 * Maintains all data pertient to an XML node, including sub-nodes and content.
@@ -25,9 +26,8 @@ public:
         *@param sContent The initial content string.
         */
        XmlNode(
-                const char *sName=NULL,
+                const Bu::FString &sName,
-                XmlNode *pParent = NULL,
+                XmlNode *pParent=NULL
-                const char *sContent=NULL
                );
        
        /**
@@ -39,7 +39,7 @@ public:
         * Change the name of the node.
         *@param sName The new name of the node.
         */
-        void setName( const char *sName );
+        //void setName( const char *sName );
        /**
         * Construct a new node and add it as a child to this node, also return a
@@ -48,7 +48,7 @@ public:
         *@param sContent The initial content of the new node.
         *@returns A pointer to the newly created child node.
         */
-        XmlNode *addChild( const char *sName, const char *sContent=NULL );
+        XmlNode *addChild( const Bu::FString &sName );
        /**
         * Add an already created XmlNode as a child to this node.  The new child
@@ -65,7 +65,7 @@ public:
         * in use will overwrite that property.
         *@param sValue The textual value of the property.
         */
-        void addProperty( const char *sName, const char *sValue );
+        void addProperty( const Bu::FString &sName, const Bu::FString &sValue );
        /**
         * Get a pointer to the parent node, if any.
@@ -86,14 +86,6 @@ public:
        int getNumChildren();
        /**
-         * Get a child node at a specific index.
-         *@param nIndex The zero-based index of the child to retreive.
-         *@returns A pointer to the child, or NULL if you requested an invalid
-         * index.
-         */
-        XmlNode *getChild( int nIndex );
-        /**
         * Get a child with the specified name, and possibly skip value.  For an
         * explination of skip values see the HashTable.
         *@param sName The name of the child to find.
@@ -101,14 +93,14 @@ public:
         *@returns A pointer to the child, or NULL if no child with that name was
         * found.
         */
-        XmlNode *getChild( const char *sName, int nSkip=0 );
+        XmlNode *getChild( const Bu::FString &sName, int nSkip=0 );
        /**
         * Get a pointer to the name of this node.  Do not change this, use setName
         * instead.
         *@returns A pointer to the name of this node.
         */
-        const char *getName();
+        Bu::FString getName();
        /**
         * Set the content of this node, optionally at a specific index.  Using the
@@ -116,14 +108,7 @@ public:
         *@param sContent The content string to use.
         *@param nIndex The index of the content.
         */
-        void setContent( const char *sContent, int nIndex=-1 );
+        //void setContent( const char *sContent, int nIndex=-1 );
-        /**
-         * Get the content string at a given index, or zero for initial content.
-         *@param nIndex The index of the content.
-         *@returns A pointer to the content at that location.
-         */
-        const char *getContent( int nIndex = 0 );
        /**
         * Get the number of properties in this node.
@@ -132,36 +117,12 @@ public:
        int getNumProperties();
        /**
-         * Get a property's name by index.
-         *@param nIndex The index of the property to examine.
-         *@returns A pointer to the name of the property specified, or NULL if none
-         * found.
-         */
-        const char *getPropertyName( int nIndex );
-        /**
-         * Get a proprty's value by index.
-         *@param nIndex The index of the property to examine.
-         *@returns A pointer to the value of the property specified, or NULL if none
-         * found.
-         */
-        const char *getProperty( int nIndex );
-        /**
         * Get a propery's value by name.
         *@param sName The name of the property to examine.
         *@returns A pointer to the value of the property specified, or NULL if none
         * found.
         */
-        const char *getProperty( const char *sName );
+        Bu::FString getProperty( const Bu::FString &sName );
-        /**
-         * Delete a property by index.
-         *@param nIndex The index of the property to delete.
-         *@returns True if the property was found and deleted, false if it wasn't
-         * found.
-         */
-        void deleteProperty( int nIndex );
        /**
         * Delete a child node, possibly replacing it with some text.  This actually
@@ -171,7 +132,7 @@ public:
         *@returns True of the node was found, and deleted, false if it wasn't
         * found.
         */
-        void deleteNode( int nIndex, const char *sReplacementText = NULL );
+        //void deleteNode( int nIndex, const char *sReplacementText = NULL );
        /**
         * Delete a given node, but move all of it's children and content up to
@@ -180,7 +141,7 @@ public:
         *@param nIndex The node to delete.
         *@returns True if the node was found and deleted, false if it wasn't.
         */
-        void deleteNodeKeepChildren( int nIndex );
+        //void deleteNodeKeepChildren( int nIndex );
        /**
         * Detatch a given child node from this node.  This effectively works just
@@ -192,7 +153,7 @@ public:
         *@returns A pointer to the newly detatched node, which then passes
         * ownership to the caller.
         */
-        XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
+        //XmlNode *detatchNode( int nIndex, const char *sReplacementText = NULL );
        /**
         * Replace a given node with a different node that is not currently owned by
@@ -201,7 +162,7 @@ public:
         *@param pNewNode The new node to replace the old node with.
         *@returns True if the node was found and replaced, false if it wasn't.
         */
-        void replaceNode( int nIndex, XmlNode *pNewNode );
+        //void replaceNode( int nIndex, XmlNode *pNewNode );
        /**
         * Replace a given node with the children and content of a given node.
@@ -210,24 +171,34 @@ public:
         * replace the node specified by nIndex.
         *@returns True if the node was found and replaced, false if it wasn't.
         */
-        void replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
+        //void replaceNodeWithChildren( int nIndex, XmlNode *pNewNode );
        /**
         * Get a copy of this node and all children.  getCopy is recursive, so
         * beware copying large trees of xml.
         *@returns A newly created copy of this node and all of it's children.
         */
-        XmlNode *getCopy();
+        //XmlNode *getCopy();
+        
+        enum ChildType
+        {
+                typeNode,
+                typeContent
+        };
 private:
-        std::string sName;      /**< The name of the node. */
+        typedef struct
-        std::string *sPreContent;       /**< The content that goes before any node. */
+        {
-        LinkedList lChildren;   /**< The children. */
+                uint8_t nType;
-        LinkedList lPostContent;        /**< The content that comes after children. */
+                union {
-        HashTable hProperties;  /**< Property hashtable. */
+                        XmlNode *pNode;
-        HashTable hChildren;    /**< Children hashtable. */
+                        Bu::FString *pContent;
-        LinkedList lPropNames;  /**< List of property names. */
+                };
-        LinkedList lPropValues; /**< List of property values. */
+        } Child;
+        Bu::FString sName;      /**< The name of the node. */
+        Bu::List<Child> lChildren;      /**< The children. */
+        Bu::Hash<Bu::FString, Bu::FString> hProperties; /**< Property hashtable. */
+        Bu::Hash<Bu::FString, Bu::List<XmlNode *> > hChildren;  /**< Children hashtable. */
        XmlNode *pParent;       /**< A pointer to the parent of this node. */
        int nCurContent;        /**< The current content we're on, for using the -1 on
                                                         setContent. */
diff --git a/src/xmlreader.cpp b/src/old/xmlreader.cpp
index 18df69c..38cad5f 100644
--- a/src/xmlreader.cpp
+++ b/src/old/xmlreader.cpp
@@ -1,32 +1,49 @@
-#include "xmlreader.h"
+#include "bu/xmlreader.h"
-#include "exceptions.h"
+#include "bu/exceptions.h"
 #include <string.h>
-#include "hashfunctionstring.h"
-XmlReader::XmlReader( bool bStrip ) :
+XmlReader::XmlReader( Bu::Stream &sIn, bool bStrip ) :
-        bStrip( bStrip ),
+        sIn( sIn ),
-        htEntity( new HashFunctionString(), 11 )
+        bStrip( bStrip )
 {
+        buildDoc();
 }
 XmlReader::~XmlReader()
 {
-        void *i = htEntity.getFirstItemPos();
+}
-        while( (i = htEntity.getNextItemPos( i ) ) )
+char XmlReader::getChar( int nIndex )
+{
+        if( sBuf.getSize() <= nIndex )
        {
-                free( (char *)(htEntity.getItemID( i )) );
+                int nInc = nIndex-sBuf.getSize()+1;
-                delete (StaticString *)htEntity.getItemData( i );
+                char *buf = new char[nInc];
+                sIn.read( buf, nInc );
+                sBuf.append( buf, nInc );
+                delete[] buf;
        }
+        return sBuf[nIndex];
 }
-void XmlReader::addEntity( const char *name, const char *value )
+void XmlReader::usedChar( int nAmnt )
 {
-        if( htEntity[name] ) return;
+        if( nAmnt >= sBuf.getSize() )
+        {
-        char *sName = strdup( name );
+                sBuf.clear();
-        StaticString *sValue = new StaticString( value );
+        }
+        else
+        {
+                char *s = sBuf.getStr();
+                memcpy( s, s+nAmnt, sBuf.getSize()-nAmnt );
+                sBuf.resize( sBuf.getSize()-nAmnt );
+        }
+}
-        htEntity.insert( sName, sValue );
+void XmlReader::addEntity( const Bu::FString &name, const Bu::FString &value )
+{
+        htEntity[name] = value;
 }
 #define gcall( x ) if( x == false ) return false;
@@ -99,7 +116,7 @@ void XmlReader::entity()
                {
                        usedChar( 2 );
                        ws();
-                        std::string buf;
+                        Bu::FString buf;
                        for(;;)
                        {
                                char chr = getChar();
@@ -111,7 +128,7 @@ void XmlReader::entity()
                        if( strcmp( buf.c_str(), "ENTITY") == 0 )
                        {
                                ws();
-                                std::string name;
+                                Bu::FString name;
                                for(;;)
                                {
                                        char chr = getChar();
@@ -124,21 +141,19 @@ void XmlReader::entity()
                                usedChar();
                                if( quot != '\'' && quot != '\"' )
                                {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                "Only quoted entity values are supported."
                                                );
                                }
-                                std::string value;
+                                Bu::FString value;
                                for(;;)
                                {
                                        char chr = getChar();
                                        usedChar();
                                        if( chr == '&' )
                                        {
-                                                StaticString *tmp = getEscape();
+                                                Bu::FString tmp = getEscape();
-                                                if( tmp == NULL ) throw XmlException("Entity thing");
+                                                value += tmp;
-                                                value += tmp->getString();
-                                                delete tmp;
                                        }
                                        else if( chr == quot )
                                        {
@@ -158,7 +173,7 @@ void XmlReader::entity()
                                }
                                else
                                {
-                                        throw XmlException(
+                                        throw Bu::XmlException(
                                                "Malformed ENTITY:  unexpected '%c' found.",
                                                getChar()
                                                );
@@ -166,7 +181,7 @@ void XmlReader::entity()
                        }
                        else
                        {
-                                throw XmlException(
+                                throw Bu::XmlException(
                                        "Unsupported header symbol: %s",
                                        buf.c_str()
                                        );
@@ -203,12 +218,12 @@ bool XmlReader::node()
                }
                else
                {
-                        throw XmlException("Close node in singleNode malformed!");
+                        throw Bu::XmlException("Close node in singleNode malformed!");
                }
        }
        else
        {
-                throw XmlException("Close node expected, but not found.");
+                throw Bu::XmlException("Close node expected, but not found.");
                return false;
        }
@@ -224,7 +239,7 @@ bool XmlReader::startNode()
                if( getChar() == '/' )
                {
                        // Heh, it's actually a close node, go figure
-                        FlexBuf fbName;
+                        Bu::FString sName;
                        usedChar();
                        gcall( ws() );
@@ -235,19 +250,19 @@ bool XmlReader::startNode()
                                {
                                        // Here we actually compare the name we got to the name
                                        // we already set, they have to match exactly.
-                                        if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                        if( getCurrent()->getName() == sName )
                                        {
                                                closeNode();
                                                break;
                                        }
                                        else
                                        {
-                                                throw XmlException("Got a mismatched node close tag.");
+                                                throw Bu::XmlException("Got a mismatched node close tag.");
                                        }
                                }
                                else
                                {
-                                        fbName.appendData( chr );
+                                        sName += chr;
                                        usedChar();
                                }
                        }
@@ -260,13 +275,13 @@ bool XmlReader::startNode()
                        }
                        else
                        {
-                                throw XmlException("Got extra junk data instead of node close tag.");
+                                throw Bu::XmlException("Got extra junk data instead of node close tag.");
                        }
                }
                else
                {
                        // We're good, format is consistant
-                        addNode();
+                        //addNode();
                        // Skip extra whitespace
                        gcall( ws() );
@@ -278,7 +293,7 @@ bool XmlReader::startNode()
        }
        else
        {
-                throw XmlException("Expected to find node opening char, '<'.");
+                throw Bu::XmlException("Expected to find node opening char, '<'.");
        }
        return true;
@@ -286,19 +301,19 @@ bool XmlReader::startNode()
 bool XmlReader::name()
 {
-        FlexBuf fbName;
+        Bu::FString sName;
        
        while( true )
        {
                char chr = getChar();
                if( isws( chr ) || chr == '>' || chr == '/' )
                {
-                        setName( fbName.getData() );
+                        addNode( sName );
                        return true;
                }
                else
                {
-                        fbName.appendData( chr );
+                        sName += chr;
                        usedChar();
                }
        }
@@ -325,7 +340,7 @@ bool XmlReader::paramlist()
        return true;
 }
-StaticString *XmlReader::getEscape()
+Bu::FString XmlReader::getEscape()
 {
        if( getChar( 1 ) == '#' )
        {
@@ -349,12 +364,12 @@ StaticString *XmlReader::getEscape()
                buf[0] = (char)strtol( buf, (char **)NULL, base );
                buf[1] = '\0';
-                return new StaticString( buf );
+                return buf;
        }
        else
        {
                // ...otherwise replace with the appropriate string...
-                std::string buf;
+                Bu::FString buf;
                usedChar();
                for(;;)
                {
@@ -364,18 +379,14 @@ StaticString *XmlReader::getEscape()
                        buf += cbuf;
                }
-                StaticString *tmp = (StaticString *)htEntity[buf.c_str()];
+                return htEntity[buf];
-                if( tmp == NULL ) return NULL;
-                StaticString *ret = new StaticString( *tmp );
-                return ret;
        }
 }
 bool XmlReader::param()
 {
-        FlexBuf fbName;
+        Bu::FString sName;
-        FlexBuf fbValue;
+        Bu::FString sValue;
        while( true )
        {
@@ -386,7 +397,7 @@ bool XmlReader::param()
                }
                else
                {
-                        fbName.appendData( chr );
+                        sName.append( chr );
                        usedChar();
                }
        }
@@ -411,21 +422,18 @@ bool XmlReader::param()
                                if( chr == '"' )
                                {
                                        usedChar();
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                        return true;
                                }
                                else
                                {
                                        if( chr == '&' )
                                        {
-                                                StaticString *tmp = getEscape();
+                                                sValue += getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
                                        }
                                        else
                                        {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                usedChar();
                                        }
                                }
@@ -439,21 +447,18 @@ bool XmlReader::param()
                                chr = getChar();
                                if( isws( chr ) || chr == '/' || chr == '>' )
                                {
-                                        addProperty( fbName.getData(), fbValue.getData() );
+                                        addProperty( sName.getStr(), sValue.getStr() );
                                        return true;
                                }
                                else
                                {
                                        if( chr == '&' )
                                        {
-                                                StaticString *tmp = getEscape();
+                                                sValue += getEscape();
-                                                if( tmp == NULL ) return false;
-                                                fbValue.appendData( tmp->getString() );
-                                                delete tmp;
                                        }
                                        else
                                        {
-                                                fbValue.appendData( chr );
+                                                sValue += chr;
                                                usedChar();
                                        }
                                }
@@ -462,7 +467,7 @@ bool XmlReader::param()
        }
        else
        {
-                throw XmlException("Expected an equals to seperate the params.");
+                throw Bu::XmlException("Expected an equals to seperate the params.");
                return false;
        }
@@ -471,7 +476,7 @@ bool XmlReader::param()
 bool XmlReader::content()
 {
-        FlexBuf fbContent;
+        Bu::FString sContent;
        if( bStrip ) gcall( ws() );
@@ -482,37 +487,37 @@ bool XmlReader::content()
                {
                        if( getChar(1) == '/' )
                        {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                {
                                        if( bStrip )
                                        {
                                                int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                sContent[j+1] = '\0';
                                        }
-                                        setContent( fbContent.getData() );
+                                        setContent( sContent.getStr() );
                                }
                                usedChar( 2 );
                                gcall( ws() );
-                                FlexBuf fbName;
+                                Bu::FString sName;
                                while( true )
                                {
                                        chr = getChar();
                                        if( isws( chr ) || chr == '>' )
                                        {
-                                                if( !strcasecmp( getCurrent()->getName(), fbName.getData() ) )
+                                                if( !strcasecmp( getCurrent()->getName().getStr(), sName.getStr() ) )
                                                {
                                                        closeNode();
                                                        break;
                                                }
                                                else
                                                {
-                                                        throw XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName(), fbName.getData() );
+                                                        throw Bu::XmlException("Mismatched close tag found: <%s> to <%s>.", getCurrent()->getName().getStr(), sName.getStr() );
                                                }
                                        }
                                        else
                                        {
-                                                fbName.appendData( chr );
+                                                sName += chr;
                                                usedChar();
                                        }
                                }
@@ -524,7 +529,7 @@ bool XmlReader::content()
                                }
                                else
                                {
-                                        throw XmlException("Malformed close tag.");
+                                        throw Bu::XmlException("Malformed close tag.");
                                }
                        }
                        else if( getChar(1) == '!' )
@@ -534,7 +539,7 @@ bool XmlReader::content()
                                        getChar(3) != '-' )
                                {
                                        // Not a valid XML comment
-                                        throw XmlException("Malformed comment start tag found.");
+                                        throw Bu::XmlException("Malformed comment start tag found.");
                                }
                                usedChar( 4 );
@@ -549,7 +554,7 @@ bool XmlReader::content()
                                                        // The next one has to be a '>' now
                                                        if( getChar( 2 ) != '>' )
                                                        {
-                                                                throw XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
+                                                                throw Bu::XmlException("Malformed comment close tag found.  You cannot have a '--' that isn't followed by a '>' in a comment.");
                                                        }
                                                        usedChar( 3 );
                                                        break;
@@ -569,16 +574,16 @@ bool XmlReader::content()
                        }
                        else
                        {
-                                if( fbContent.getLength() > 0 )
+                                if( sContent.getSize() > 0 )
                                {
                                        if( bStrip )
                                        {
                                                int j;
-                                                for( j = fbContent.getLength()-1; isws(fbContent.getData()[j]); j-- );
+                                                for( j = sContent.getSize()-1; isws(sContent[j]); j-- );
-                                                ((char *)fbContent.getData())[j+1] = '\0';
+                                                sContent[j+1] = '\0';
                                        }
-                                        setContent( fbContent.getData() );
+                                        setContent( sContent.getStr() );
-                                        fbContent.clearData();
+                                        sContent.clear();
                                }
                                gcall( node() );
                        }
@@ -587,14 +592,11 @@ bool XmlReader::content()
                }
                else if( chr == '&' )
                {
-                        StaticString *tmp = getEscape();
+                        sContent += getEscape();
-                        if( tmp == NULL ) return false;
-                        fbContent.appendData( tmp->getString() );
-                        delete tmp;
                }
                else
                {
-                        fbContent.appendData( chr );
+                        sContent += chr;
                        usedChar();
                }
        }
diff --git a/src/xmlreader.h b/src/old/xmlreader.h
index c8f7202..7c85ddb 100644
--- a/src/xmlreader.h
+++ b/src/old/xmlreader.h
@@ -2,10 +2,10 @@
 #define XMLREADER
 #include <stdio.h>
-#include "xmldocument.h"
+#include "bu/xmldocument.h"
-#include "flexbuf.h"
+#include "bu/hash.h"
-#include "hashtable.h"
+#include "bu/fstring.h"
-#include "staticstring.h"
+#include "bu/stream.h"
 /**
 * Takes care of reading in xml formatted data from a file.  This could/should
@@ -32,7 +32,7 @@ public:
         * in content, a-la html.
         *@param bStrip Strip out leading and trailing whitespace?
         */
-        XmlReader( bool bStrip=false );
+        XmlReader( Bu::Stream &sIn, bool bStrip=false );
        /**
         * Destroy this XmlReader.
@@ -54,12 +54,12 @@ private:
         *@returns A single character at the requested position, or 0 for end of
         * stream.
         */
-        virtual char getChar( int nIndex = 0 ) = 0;
+        virtual char getChar( int nIndex = 0 );
        /**
         * Called to increment the current stream position by a single character.
         */
-        virtual void usedChar( int nAmnt = 1) = 0;
+        virtual void usedChar( int nAmnt = 1 );
        /**
         * Automoton function: is whitespace.
@@ -108,9 +108,9 @@ private:
         *@param name The name of the entity
         *@param value The value of the entity
         */
-        void addEntity( const char *name, const char *value );
+        void addEntity( const Bu::FString &name, const Bu::FString &value );
-        StaticString *getEscape();
+        Bu::FString getEscape();
        /**
         * Automoton function: paramlist.  Processes a list of node params.
@@ -130,12 +130,15 @@ private:
         */
        bool content();
        
-        FlexBuf fbContent;              /**< buffer for the current node's content. */
+        Bu::FString sContent;           /**< buffer for the current node's content. */
-        FlexBuf fbParamName;    /**< buffer for the current param's name. */
+        Bu::FString sParamName;         /**< buffer for the current param's name. */
-        FlexBuf fbParamValue;   /**< buffer for the current param's value. */
+        Bu::FString sParamValue;        /**< buffer for the current param's value. */
-        bool bStrip;    /**< Are we stripping whitespace? */
+        Bu::Stream &sIn;
+        bool bStrip;                    /**< Are we stripping whitespace? */
-        HashTable htEntity;             /**< Entity type definitions. */
+        Bu::Hash<Bu::FString,Bu::FString> htEntity;             /**< Entity type definitions. */
+        Bu::FString sBuf;
 };
 #endif
diff --git a/src/xmlstringreader.cpp b/src/old/xmlstringreader.cpp
index 3956ff3..3956ff3 100644
--- a/src/xmlstringreader.cpp
+++ b/src/old/xmlstringreader.cpp
diff --git a/src/xmlstringreader.h b/src/old/xmlstringreader.h
index 1239ef4..1239ef4 100644
--- a/src/xmlstringreader.h
+++ b/src/old/xmlstringreader.h
diff --git a/src/xmlstringwriter.cpp b/src/old/xmlstringwriter.cpp
index adeed6a..adeed6a 100644
--- a/src/xmlstringwriter.cpp
+++ b/src/old/xmlstringwriter.cpp
diff --git a/src/xmlstringwriter.h b/src/old/xmlstringwriter.h
index 0d567b9..0d567b9 100644
--- a/src/xmlstringwriter.h
+++ b/src/old/xmlstringwriter.h
diff --git a/src/xmlwriter.cpp b/src/old/xmlwriter.cpp
index 56880b6..7dc6ca9 100644
--- a/src/xmlwriter.cpp
+++ b/src/old/xmlwriter.cpp
@@ -2,17 +2,10 @@
 #include <stdlib.h>
 #include "xmlwriter.h"
-XmlWriter::XmlWriter( const char *sIndent, XmlNode *pRoot ) :
+XmlWriter::XmlWriter( const Bu::FString &sIndent, XmlNode *pRoot ) :
-        XmlDocument( pRoot )
+        XmlDocument( pRoot ),
+        sIndent( sIndent )
 {
-        if( sIndent == NULL )
-        {
-                this->sIndent = "";
-        }
-        else
-        {
-                this->sIndent = sIndent;
-        }
 }
 XmlWriter::~XmlWriter()
@@ -24,7 +17,7 @@ void XmlWriter::write()
        write( getRoot(), sIndent.c_str() );
 }
-void XmlWriter::write( XmlNode *pRoot, const char *sIndent )
+void XmlWriter::write( XmlNode *pRoot, const Bu::FString &sIndent )
 {
        writeNode( pRoot, 0, sIndent );
 }
@@ -39,7 +32,7 @@ void XmlWriter::closeNode()
        }
 }
-void XmlWriter::writeIndent( int nIndent, const char *sIndent )
+void XmlWriter::writeIndent( int nIndent, const Bu::FString &sIndent )
 {
        if( sIndent == NULL ) return;
        for( int j = 0; j < nIndent; j++ )
@@ -48,26 +41,27 @@ void XmlWriter::writeIndent( int nIndent, const char *sIndent )
        }
 }
-std::string XmlWriter::escape( std::string sIn )
+Bu::FString XmlWriter::escape( const Bu::FString &sIn )
 {
-        std::string sOut;
+        Bu::FString sOut;
-        std::string::const_iterator i;
+        int nMax = sIn.getSize();
-        for( i = sIn.begin(); i != sIn.end(); i++ )
+        for( int j = 0; j < nMax; j++ )
        {
-                if( ((*i >= ' ' && *i <= '9') ||
+                char c = sIn[j];
-                        (*i >= 'a' && *i <= 'z') ||
+                if( ((c >= ' ' && c <= '9') ||
-                        (*i >= 'A' && *i <= 'Z') ) &&
+                        (c >= 'a' && c <= 'z') ||
-                        (*i != '\"' && *i != '\'' && *i != '&')
+                        (c >= 'A' && c <= 'Z') ) &&
+                        (c != '\"' && c != '\'' && c != '&')
                  )
                {
-                        sOut += *i;
+                        sOut += c;
                }
                else
                {
                        sOut += "&#";
                        char buf[4];
-                        sprintf( buf, "%u", (unsigned char)*i );
+                        sprintf( buf, "%u", (unsigned char)c );
                        sOut += buf;
                        sOut += ';';
                }
@@ -76,19 +70,19 @@ std::string XmlWriter::escape( std::string sIn )
        return sOut;
 }
-void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
        for( int j = 0; j < pNode->getNumProperties(); j++ )
        {
                writeString(" ");
-                writeString( pNode->getPropertyName( j ) );
+                //writeString( pNode->getPropertyName( j ) );
                writeString("=\"");
-                writeString( escape( pNode->getProperty( j ) ).c_str() );
+                //writeString( escape( pNode->getProperty( j ) ).c_str() );
                writeString("\"");
        }
 }
-void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
+void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent )
 {
        if( pNode->hasChildren() )
        {
@@ -96,15 +90,15 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                writeString("<");
                writeString( pNode->getName() );
                writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                        writeString(">\n");
                else
                        writeString(">");
+/*
                if( pNode->getContent( 0 ) )
                {
                        writeIndent( nIndent+1, sIndent );
-                        if( sIndent )
+                        if( sIndent != "" )
                        {
                                writeString( pNode->getContent( 0 ) );
                                writeString("\n");
@@ -129,9 +123,9 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                                        writeString( pNode->getContent( j+1 ) );
                        }
                }
-                
+*/              
                writeIndent( nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                {
                        writeString("</");
                        writeString( pNode->getName() );
@@ -143,7 +137,7 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                        writeString( pNode->getName() );
                        writeString(">");
                }
-        }
+        }/*
        else if( pNode->getContent() )
        {
                writeIndent( nIndent, sIndent );
@@ -157,14 +151,14 @@ void XmlWriter::writeNode( XmlNode *pNode, int nIndent, const char *sIndent )
                writeString(">");
                if( sIndent )
                        writeString("\n");
-        }
+        }*/
        else
        {
                writeIndent( nIndent, sIndent );
                writeString("<");
                writeString( pNode->getName() );
                writeNodeProps( pNode, nIndent, sIndent );
-                if( sIndent )
+                if( sIndent != "" )
                        writeString("/>\n");
                else
                        writeString("/>");
diff --git a/src/xmlwriter.h b/src/old/xmlwriter.h
index c48e810..7e3c876 100644
--- a/src/xmlwriter.h
+++ b/src/old/xmlwriter.h
@@ -31,7 +31,7 @@ public:
         * this to a tab or some spaces it will never effect the content of your
         * file.
         */
-        XmlWriter( const char *sIndent=NULL, XmlNode *pRoot=NULL );
+        XmlWriter( const Bu::FString &sIndent="", XmlNode *pRoot=NULL );
        /**
         * Destroy the writer.
@@ -49,16 +49,16 @@ public:
        void write();
 private:
-        std::string sIndent;    /**< The indent string */
+        Bu::FString sIndent;    /**< The indent string */
-        std::string escape( std::string sIn );
+        Bu::FString escape( const Bu::FString &sIn );
        
        /**
         * Write the file.
         *@param pNode The root node
         *@param sIndent The indent text.
         */
-        void write( XmlNode *pNode, const char *sIndent=NULL );
+        void write( XmlNode *pNode, const Bu::FString &sIndent );
        /**
         * Write a node in the file, including children.
@@ -66,7 +66,7 @@ private:
         *@param nIndent The indent level (the number of times to include sIndent)
         *@param sIndent The indent text.
         */
-        void writeNode( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNode( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
        /**
         * Write the properties of a node.
@@ -74,14 +74,14 @@ private:
         *@param nIndent The indent level of the containing node
         *@param sIndent The indent text.
         */
-        void writeNodeProps( XmlNode *pNode, int nIndent, const char *sIndent );
+        void writeNodeProps( XmlNode *pNode, int nIndent, const Bu::FString &sIndent );
        /**
         * Called to write the actual indent.
         *@param nIndent The indent level.
         *@param sIndent The indent text.
         */
-        void writeIndent( int nIndent, const char *sIndent );
+        void writeIndent( int nIndent, const Bu::FString &sIndent );
        /**
         * This is the function that must be overridden in order to use this class.
@@ -90,7 +90,7 @@ private:
         * will break the XML formatting.
         *@param sString The string data to write to the output.
         */
-        virtual void writeString( const char *sString ) = 0;
+        virtual void writeString( const Bu::FString &sString ) = 0;
 };
 #endif
diff --git a/src/paramproc.cpp b/src/paramproc.cpp
index a352e66..34e973e 100644
--- a/src/paramproc.cpp
+++ b/src/paramproc.cpp
@@ -2,10 +2,10 @@
 #include <stdio.h>
 #define ptrtype( iitype, iiname ) \
-        ParamProc::ParamPtr::ParamPtr( iitype *iiname ) :       \
+        Bu::ParamProc::ParamPtr::ParamPtr( iitype *iiname ) :   \
                type( vt ##iiname ) { val.iiname = iiname; }
-ParamProc::ParamPtr::ParamPtr()
+Bu::ParamProc::ParamPtr::ParamPtr()
 {
        val.str = NULL;
        type = vtunset;
@@ -25,7 +25,7 @@ ptrtype( double,      float64 );
 ptrtype( long double, float96 );
 ptrtype( bool,        bln     );
-ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
+Bu::ParamProc::ParamPtr &Bu::ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
 {
        val = ptr.val;
        type = ptr.type;
@@ -33,12 +33,12 @@ ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( ParamProc::ParamPtr &ptr )
        return *this;
 }
-bool ParamProc::ParamPtr::isSet()
+bool Bu::ParamProc::ParamPtr::isSet()
 {
        return type != vtunset;
 }
-ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( const char *str )
+Bu::ParamProc::ParamPtr &Bu::ParamProc::ParamPtr::operator=( const char *str )
 {
        if( !isSet() ) return *this;
        switch( type )
@@ -107,11 +107,11 @@ ParamProc::ParamPtr &ParamProc::ParamPtr::operator=( const char *str )
        return *this;
 }
-ParamProc::ParamProc()
+Bu::ParamProc::ParamProc()
 {
 }
-ParamProc::~ParamProc()
+Bu::ParamProc::~ParamProc()
 {
        for( std::list<ArgSpec *>::iterator i = lArg.begin();
                 i != lArg.end(); i++ )
@@ -127,14 +127,14 @@ ParamProc::~ParamProc()
 }
 /*
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val )
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val )
 {
        printf("Calling callback...\n");
        val = "Hello there, this is set in the ParamProc";
        (this->*proc)();
 }*/
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
        ParamPtr val, const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
@@ -161,63 +161,63 @@ void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
        }
 }
-void ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, Proc proc,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( lpWord, cChar, proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( const char *lpWord, char cChar, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, char cChar, ParamPtr val,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( lpWord, cChar, NULL, val, lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( const char *lpWord, Proc proc, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, Proc proc, ParamPtr val,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( lpWord, '\0', proc, val, lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( const char *lpWord, Proc proc,
+void Bu::ParamProc::addParam( const char *lpWord, Proc proc,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( lpWord, '\0', proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( const char *lpWord, ParamPtr val,
+void Bu::ParamProc::addParam( const char *lpWord, ParamPtr val,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( lpWord, '\0', NULL, val, lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( char cChar, Proc proc, ParamPtr val,
+void Bu::ParamProc::addParam( char cChar, Proc proc, ParamPtr val,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( NULL, cChar, proc, val, lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( char cChar, Proc proc,
+void Bu::ParamProc::addParam( char cChar, Proc proc,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( NULL, cChar, proc, ParamPtr(), lpDesc, lpExtra, lpValue );
 }
-void ParamProc::addParam( char cChar, ParamPtr val,
+void Bu::ParamProc::addParam( char cChar, ParamPtr val,
        const char *lpDesc, const char *lpExtra,
        const char *lpValue )
 {
        addParam( NULL, cChar, NULL, val, lpDesc, lpExtra, lpValue );
 }
-void ParamProc::process( int argc, char *argv[] )
+void Bu::ParamProc::process( int argc, char *argv[] )
 {
        for( int arg = 1; arg < argc; arg++ )
        {
@@ -229,23 +229,23 @@ void ParamProc::process( int argc, char *argv[] )
                                ArgSpec *s = checkWord( argv[arg]+2 );
                                if( s )
                                {
-                                        if( argv[arg][s->sWord.getLength()+2] == '=' )
+                                        if( argv[arg][s->sWord.getSize()+2] == '=' )
                                        {
                                                if( s->val.isSet() )
                                                {
-                                                        if( s->sValue.getString() == NULL )
+                                                        if( s->sValue.getStr() == NULL )
                                                        {
-                                                                s->val = argv[arg]+s->sWord.getLength()+3;
+                                                                s->val = argv[arg]+s->sWord.getSize()+3;
                                                        }
                                                        else
                                                        {
-                                                                s->val = s->sValue.getString();
+                                                                s->val = s->sValue.getStr();
                                                        }
                                                }
                                                if( s->proc )
                                                {
                                                        char **tmp = new char*[argc-arg];
-                                                        tmp[0] = argv[arg]+s->sWord.getLength()+3;
+                                                        tmp[0] = argv[arg]+s->sWord.getSize()+3;
                                                        for( int k = 1; k < argc-arg; k++ )
                                                                tmp[k] = argv[arg+k];
                                                        int ret = (this->*s->proc)( argc-arg, tmp );
@@ -261,7 +261,7 @@ void ParamProc::process( int argc, char *argv[] )
                                                int add = 0;
                                                if( s->val.isSet() )
                                                {
-                                                        if( s->sValue.getString() == NULL )
+                                                        if( s->sValue.getStr() == NULL )
                                                        {
                                                                if( arg+1 >= argc )
                                                                {
@@ -272,7 +272,7 @@ void ParamProc::process( int argc, char *argv[] )
                                                        }
                                                        else
                                                        {
-                                                                s->val = s->sValue.getString();
+                                                                s->val = s->sValue.getStr();
                                                        }
                                                }
                                                if( s->proc )
@@ -307,14 +307,14 @@ void ParamProc::process( int argc, char *argv[] )
                                                        bool bUsed = false;
                                                        if( s->val.isSet() )
                                                        {
-                                                                if( s->sValue.getString() == NULL )
+                                                                if( s->sValue.getStr() == NULL )
                                                                {
                                                                        s->val = argv[arg]+chr+1;
                                                                        bUsed = true;
                                                                }
                                                                else
                                                                {
-                                                                        s->val = s->sValue.getString();
+                                                                        s->val = s->sValue.getStr();
                                                                }
                                                        }
                                                        if( s->proc )
@@ -342,14 +342,14 @@ void ParamProc::process( int argc, char *argv[] )
                                                        bool bUsed = false;
                                                        if( s->val.isSet() )
                                                        {
-                                                                if( s->sValue.getString() == NULL )
+                                                                if( s->sValue.getStr() == NULL )
                                                                {
                                                                        s->val = argv[arg+1];
                                                                        bUsed = true;
                                                                }
                                                                else
                                                                {
-                                                                        s->val = s->sValue.getString();
+                                                                        s->val = s->sValue.getStr();
                                                                }
                                                        }
                                                        if( s->proc )
@@ -384,22 +384,22 @@ void ParamProc::process( int argc, char *argv[] )
        }
 }
-ParamProc::ArgSpec *ParamProc::checkWord( const char *arg )
+Bu::ParamProc::ArgSpec *Bu::ParamProc::checkWord( const char *arg )
 {
        //printf("Checking \"%s\"...\n", arg );
        std::list<ArgSpec *>::const_iterator i;
        for( i = lArg.begin(); i != lArg.end(); i++ )
        {
-                if( (*i)->sWord.getString() == NULL )
+                if( (*i)->sWord.getStr() == NULL )
                        continue;
-                if( !strcmp( (*i)->sWord, arg ) )
+                if( !strcmp( (*i)->sWord.getStr(), arg ) )
                        return *i;
                if( (*i)->val.isSet() )
                {
-                        if( !strncmp( (*i)->sWord, arg, (*i)->sWord.getLength() ) &&
+                        if( !strncmp( (*i)->sWord.getStr(), arg, (*i)->sWord.getSize() ) &&
-                                arg[(*i)->sWord.getLength()] == '=' )
+                                arg[(*i)->sWord.getSize()] == '=' )
                        {
                                return *i;
                        }
@@ -409,7 +409,7 @@ ParamProc::ArgSpec *ParamProc::checkWord( const char *arg )
        return NULL;
 }
-ParamProc::ArgSpec *ParamProc::checkLetr( const char arg )
+Bu::ParamProc::ArgSpec *Bu::ParamProc::checkLetr( const char arg )
 {
        //printf("Checking \'%c\'...\n", arg );
        std::list<ArgSpec *>::const_iterator i;
@@ -427,27 +427,27 @@ ParamProc::ArgSpec *ParamProc::checkLetr( const char arg )
        return NULL;
 }
-int ParamProc::cmdParam( int argc, char *argv[] )
+int Bu::ParamProc::cmdParam( int argc, char *argv[] )
 {
        printf("Unhandled command parameter \"%s\" found!\n", argv[0] );
        return 0;
 }
-int ParamProc::unknownParam( int argc, char *argv[] )
+int Bu::ParamProc::unknownParam( int argc, char *argv[] )
 {
        printf("Unknown parameter \"%s\" found!\n", argv[0] );
        return 0;
 }
-int ParamProc::help( int argc, char *argv[] )
+int Bu::ParamProc::help( int argc, char *argv[] )
 {
        std::list<Banner *>::const_iterator b = lBan.begin();
        std::list<ArgSpec *>::const_iterator i;
        int len=0;
        for( i = lArg.begin(); i != lArg.end(); i++ )
        {
-                if( len < (*i)->sWord.getLength() + (*i)->sExtra.getLength() )
+                if( len < (*i)->sWord.getSize() + (*i)->sExtra.getSize() )
-                        len = (*i)->sWord.getLength() + (*i)->sExtra.getLength();
+                        len = (*i)->sWord.getSize() + (*i)->sExtra.getSize();
        }
        char fmt[10];
        sprintf( fmt, "%%-%ds   ", len );
@@ -458,14 +458,14 @@ int ParamProc::help( int argc, char *argv[] )
                {
                        if( (*b)->pBefore == (*i) )
                        {
-                                printf( (*b)->sBanner.getString() );
+                                printf( (*b)->sBanner.getStr() );
                                b++;
                        }
                }
                printf("  ");
                if( (*i)->cChar )
                {
-                        if( (*i)->sWord.getString() )
+                        if( (*i)->sWord.getStr() )
                        {
                                printf("-%c, ", (*i)->cChar );
                        }
@@ -478,12 +478,12 @@ int ParamProc::help( int argc, char *argv[] )
                {
                        printf("    ");
                }
-                if( (*i)->sWord.getString() )
+                if( (*i)->sWord.getStr() )
                {
                        printf("--");
-                        std::string sTmp = (*i)->sWord.getString();
+                        std::string sTmp = (*i)->sWord.getStr();
-                        if( (*i)->sExtra.getString() )
+                        if( (*i)->sExtra.getStr() )
-                                sTmp += (*i)->sExtra.getString();
+                                sTmp += (*i)->sExtra.getStr();
                        printf( fmt, sTmp.c_str() );
                }
                else
@@ -491,20 +491,20 @@ int ParamProc::help( int argc, char *argv[] )
                        printf("  ");
                        printf(fmt, "" );
                }
-                printf("%s\n", (*i)->sDesc.getString() );
+                printf("%s\n", (*i)->sDesc.getStr() );
        }
        if( b != lBan.end() )
        {
                if( (*b)->pBefore == NULL )
                {
-                        printf( (*b)->sBanner.getString() );
+                        printf( (*b)->sBanner.getStr() );
                }
        }
        exit( 0 );
 }
-void ParamProc::addHelpBanner( const char *sHelpBanner )
+void Bu::ParamProc::addHelpBanner( const char *sHelpBanner )
 {
        Banner *pBan = new Banner;
        pBan->sBanner = sHelpBanner;
diff --git a/src/paramproc.h b/src/paramproc.h
index d857193..2bca588 100644
--- a/src/paramproc.h
+++ b/src/paramproc.h
@@ -1,153 +1,156 @@
-#ifndef PARAM_PROC_H
+#ifndef BU_PARAM_PROC_H
-#define PARAM_PROC_H
+#define BU_PARAM_PROC_H
 #include <stdint.h>
 #include <string>
 #include <list>
-#include "staticstring.h"
+#include "bu/fstring.h"
-class ParamProc
+namespace Bu
 {
-public:
+        class ParamProc
-        class ParamPtr
        {
        public:
-                ParamPtr();
+                class ParamPtr
-                ParamPtr( std::string *str );
-                ParamPtr( uint64_t    *uint64  );
-                ParamPtr( uint32_t    *uint32  );
-                ParamPtr( uint16_t    *uint16  );
-                ParamPtr( uint8_t     *uint8   );
-                ParamPtr( int64_t     *int64   );
-                ParamPtr( int32_t     *int32   );
-                ParamPtr( int16_t     *int16   );
-                ParamPtr( int8_t      *int8    );
-                ParamPtr( float       *float32 );
-                ParamPtr( double      *float64 );
-                ParamPtr( long double *float96 );
-                ParamPtr( bool        *bln     );
-                enum
                {
-                        vtunset,
+                public:
-                        vtstr,
+                        ParamPtr();
-                        vtuint64,
+                        ParamPtr( std::string *str );
-                        vtuint32,
+                        ParamPtr( uint64_t    *uint64  );
-                        vtuint16,
+                        ParamPtr( uint32_t    *uint32  );
-                        vtuint8,
+                        ParamPtr( uint16_t    *uint16  );
-                        vtint64,
+                        ParamPtr( uint8_t     *uint8   );
-                        vtint32,
+                        ParamPtr( int64_t     *int64   );
-                        vtint16,
+                        ParamPtr( int32_t     *int32   );
-                        vtint8,
+                        ParamPtr( int16_t     *int16   );
-                        vtfloat32,
+                        ParamPtr( int8_t      *int8    );
-                        vtfloat64,
+                        ParamPtr( float       *float32 );
-                        vtfloat96,
+                        ParamPtr( double      *float64 );
-                        vtbln,
+                        ParamPtr( long double *float96 );
-                };
+                        ParamPtr( bool        *bln     );
-                ParamPtr &operator=( ParamPtr &ptr );
-                ParamPtr &operator=( const char *str );
-                bool isSet();
+                        enum
+                        {
+                                vtunset,
+                                vtstr,
+                                vtuint64,
+                                vtuint32,
+                                vtuint16,
+                                vtuint8,
+                                vtint64,
+                                vtint32,
+                                vtint16,
+                                vtint8,
+                                vtfloat32,
+                                vtfloat64,
+                                vtfloat96,
+                                vtbln,
+                        };
+                        ParamPtr &operator=( ParamPtr &ptr );
+                        ParamPtr &operator=( const char *str );
-        private:
+                        bool isSet();
-                int type;
-                union
+                private:
-                {
+                        int type;
-                        std::string *str;
+                        union
-                        uint64_t *uint64;
+                        {
-                        uint32_t *uint32;
+                                std::string *str;
-                        uint16_t *uint16;
+                                uint64_t *uint64;
-                        uint8_t *uint8;
+                                uint32_t *uint32;
-                        int64_t *int64;
+                                uint16_t *uint16;
-                        int32_t *int32;
+                                uint8_t *uint8;
-                        int16_t *int16;
+                                int64_t *int64;
-                        int8_t *int8;
+                                int32_t *int32;
-                        float *float32;
+                                int16_t *int16;
-                        double *float64;
+                                int8_t *int8;
-                        long double *float96;
+                                float *float32;
-                        bool *bln;
+                                double *float64;
-                } val;
+                                long double *float96;
-        };
+                                bool *bln;
+                        } val;
+                };
-        typedef int (ParamProc::*Proc)( int, char *[] );
+                typedef int (ParamProc::*Proc)( int, char *[] );
-        typedef struct ArgSpec
+                typedef struct ArgSpec
-        {
+                {
-                uint8_t nFlags;
+                        uint8_t nFlags;
-                StaticString sWord;
+                        Bu::FString sWord;
-                char cChar;
+                        char cChar;
-                Proc proc;
+                        Proc proc;
-                ParamProc::ParamPtr val;
+                        ParamProc::ParamPtr val;
-                StaticString sExtra;
+                        Bu::FString sExtra;
-                StaticString sDesc;
+                        Bu::FString sDesc;
-                StaticString sValue;
+                        Bu::FString sValue;
-        } ArgSpec;
+                } ArgSpec;
-public:
+        public:
-        ParamProc();
+                ParamProc();
-        virtual ~ParamProc();
+                virtual ~ParamProc();
-        
+                
-        void addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val,
+                void addParam( const char *lpWord, char cChar, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( const char *lpWord, char cChar, Proc proc,
+                void addParam( const char *lpWord, char cChar, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( const char *lpWord, char cChar, ParamPtr val,
+                void addParam( const char *lpWord, char cChar, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( const char *lpWord, Proc proc, ParamPtr val,
+                void addParam( const char *lpWord, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( const char *lpWord, Proc proc,
+                void addParam( const char *lpWord, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( const char *lpWord, ParamPtr val,
+                void addParam( const char *lpWord, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        
+                
-        void addParam( char cChar, Proc proc, ParamPtr val,
+                void addParam( char cChar, Proc proc, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( char cChar, Proc proc,
+                void addParam( char cChar, Proc proc,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void addParam( char cChar, ParamPtr val,
+                void addParam( char cChar, ParamPtr val,
-                const char *lpDesc=NULL, const char *lpExtra=NULL,
+                        const char *lpDesc=NULL, const char *lpExtra=NULL,
-                const char *lpValue=NULL
+                        const char *lpValue=NULL
-                );
+                        );
-        void process( int argc, char *argv[] );
+                void process( int argc, char *argv[] );
-        void addHelpBanner( const char *sHelpBanner );
+                void addHelpBanner( const char *sHelpBanner );
-private:
+        private:
-        ArgSpec *checkWord( const char *arg );
+                ArgSpec *checkWord( const char *arg );
-        ArgSpec *checkLetr( const char arg );
+                ArgSpec *checkLetr( const char arg );
-public:
+        public:
-        virtual int cmdParam( int argc, char *argv[] );
+                virtual int cmdParam( int argc, char *argv[] );
-        virtual int unknownParam( int argc, char *argv[] );
+                virtual int unknownParam( int argc, char *argv[] );
-        virtual int help( int argc, char *argv[] );
+                virtual int help( int argc, char *argv[] );
-private:
+        private:
-        typedef struct Banner
+                typedef struct Banner
-        {
+                {
-                StaticString sBanner;
+                        Bu::FString sBanner;
-                ArgSpec *pBefore;
+                        ArgSpec *pBefore;
-        } Banner;
+                } Banner;
-        std::list<Banner *> lBan;
+                std::list<Banner *> lBan;
-        std::list<ArgSpec *> lArg;
+                std::list<ArgSpec *> lArg;
-};
+        };
+}
-#define mkproc( cls ) static_cast<int (ParamProc::*)( int, char *[])>(&cls)
+#define mkproc( cls ) static_cast<int (Bu::ParamProc::*)( int, char *[])>(&cls)
 #endif
diff --git a/src/plugger.h b/src/plugger.h
index d92f194..2124b7a 100644
--- a/src/plugger.h
+++ b/src/plugger.h
@@ -1,198 +1,198 @@
-#ifndef PLUGGER_H
+#ifndef BU_PLUGGER_H
-#define PLUGGER_H
+#define BU_PLUGGER_H
-#include "hashtable.h"
+#include "bu/hash.h"
-#include "list"
+#include "bu/list.h"
-#include "hashfunctionstring.h"
+#include <dlfcn.h>
-#include "hashfunctionint.h"
+#include "bu/exceptions.h"
-#include "dlfcn.h"
+#include "bu/fstring.h"
-#include "exceptions.h"
-typedef struct PluginInfo
+namespace Bu
 {
-        const char *sID;
+        typedef struct PluginInfo
-        const char *sAuthor;
+        {
-        unsigned short nVersion;
+                const char *sID;
-        unsigned short nRevision;
+                const char *sAuthor;
-        void *(*createPlugin)();
+                unsigned short nVersion;
-        void (*destroyPlugin)( void * );
+                unsigned short nRevision;
-} PluginInfo;
+                void *(*createPlugin)();
+                void (*destroyPlugin)( void * );
-typedef struct PluginReg
+        } PluginInfo;
-{
-        bool bBuiltin;
+        typedef struct PluginReg
-        void *dlHandle;
+        {
-        PluginInfo *pInfo;
+                bool bBuiltin;
-} PluginReg;
+                void *dlHandle;
+                PluginInfo *pInfo;
+        } PluginReg;
 #define PluginInterface( classname, baseclass, name, ver, rev )                 \
-extern "C" {                                                                                                                    \
+        extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                         \
+                baseclass *create ##classname()                                                         \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                return new classname();                                                                                 \
+                        return new classname();                                                                                 \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                     \
+                void destroy ##classname( baseclass *pCls )                                     \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                delete pCls;                                                                                                    \
+                        delete pCls;                                                                                                    \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        PluginInfo classname = {                                                \
+                Bu::PluginInfo classname = {                                            \
-                #classname, name, ver, rev,                                                                             \
+                        #classname, name, ver, rev,                                                                             \
-                create ##classname, destroy ##classname };                                              \
+                        create ##classname, destroy ##classname };                                              \
-}
+        }
 #define PluginInterface2( pluginname, classname, baseclass, name, ver, rev ) \
-extern "C" {                                                                                                                    \
+        extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                                         \
+                baseclass *create ##classname()                                                                         \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                return new classname();                                                                                 \
+                        return new classname();                                                                                 \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                                     \
+                void destroy ##classname( baseclass *pCls )                                                     \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                delete pCls;                                                                                                    \
+                        delete pCls;                                                                                                    \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        PluginInfo pluginname = {                                                                                       \
+                Bu::PluginInfo pluginname = {                                                                                   \
-                #pluginname, name, ver, rev,                                                                    \
+                        #pluginname, name, ver, rev,                                                                    \
-                (void *(*)())(create ##classname),                                                              \
+                        (void *(*)())(create ##classname),                                                              \
-                (void (*)( void * ))(destroy ##classname) };                                    \
+                        (void (*)( void * ))(destroy ##classname) };                                    \
-}
+        }
 #define PluginInterface3( structname, pluginname, classname, baseclass, name, ver, rev ) \
-extern "C" {                                                                                                                    \
+        extern "C" {                                                                                                                    \
-        baseclass *create ##classname()                                                                         \
+                baseclass *create ##classname()                                                                         \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                return new classname();                                                                                 \
+                        return new classname();                                                                                 \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        void destroy ##classname( baseclass *pCls )                                                     \
+                void destroy ##classname( baseclass *pCls )                                                     \
-        {                                                                                                                                       \
+                {                                                                                                                                       \
-                delete pCls;                                                                                                    \
+                        delete pCls;                                                                                                    \
-        }                                                                                                                                       \
+                }                                                                                                                                       \
-        PluginInfo structname = {                                                                                       \
+                Bu::PluginInfo structname = {                                                                                   \
-                #pluginname, name, ver, rev,                                                                    \
+                        #pluginname, name, ver, rev,                                                                    \
-                (void *(*)())(create ##classname),                                                              \
+                        (void *(*)())(create ##classname),                                                              \
-                (void (*)( void * ))(destroy ##classname) };                                    \
+                        (void (*)( void * ))(destroy ##classname) };                                    \
-}
-template<class T>
-class Plugger
-{
-public:
-public:
-        Plugger() :
-                hPlugin( new HashFunctionString(), 11 ),
-                hObj( new HashFunctionInt(), 11 )
-        {
        }
-        virtual ~Plugger()
+        template<class T>
+        class Plugger
        {
-                void *pos = hObj.getFirstItemPos();
+        public:
-                while( (pos = hObj.getNextItemPos( pos )) )
+                typedef Bu::Hash<Bu::FString, PluginReg *> PluginHash;
+                typedef Bu::Hash<int, void *> InstHash;
+        public:
+                Plugger()
                {
-                        T *pPlug = (T *)hObj.getItemID( pos );
-                        PluginReg *pReg = (PluginReg *)hObj.getItemData( pos );
-                        pReg->pInfo->destroyPlugin( pPlug );
                }
-                std::list<PluginReg *>::iterator i;
+                virtual ~Plugger()
-                for( i = lPlugin.begin(); i != lPlugin.end(); i++ )
                {
-                        if( (*i)->bBuiltin == false )
+                        for( InstHash::iterator i = hObj.begin(); i != hObj.end(); i++ )
                        {
-                                dlclose( (*i)->dlHandle );
+                                T *pPlug = (T *)i.getKey();
+                                PluginReg *pReg = (PluginReg *)*i;
+                                pReg->pInfo->destroyPlugin( pPlug );
                        }
-                        delete (*i);
-                }
-        }
-        void registerBuiltinPlugin( PluginInfo *pInfo )
+                        for( PluginHash::iterator i = hPlugin.begin();
-        {
+                                 i != hPlugin.end(); i++ )
-                PluginReg *pReg = new PluginReg;
+                        {
-                pReg->bBuiltin = true;
+                                if( (*i)->bBuiltin == false )
-                pReg->pInfo = pInfo;
+                                {
-                lPlugin.insert( lPlugin.end(), pReg );
+                                        dlclose( (*i)->dlHandle );
-                hPlugin.insert( pInfo->sID, pReg );
+                                }
-        }
+                                delete (*i);
+                        }
+                }
-        void registerExternalPlugin( const char *sFName, const char *sPluginName )
+                void registerBuiltinPlugin( PluginInfo *pInfo )
-        {
-                PluginReg *pReg = (PluginReg *)hPlugin[sPluginName];
-                if( pReg != NULL )
                {
-                        hPlugin.del( sPluginName );
+                        PluginReg *pReg = new PluginReg;
-                        dlclose( pReg->dlHandle );
+                        pReg->bBuiltin = true;
-                        delete pReg;
+                        pReg->pInfo = pInfo;
-                        pReg = NULL;
+                        hPlugin.insert( pInfo->sID, pReg );
                }
-                pReg = new PluginReg;
+                void registerExternalPlugin( const char *sFName, const char *sPluginName )
-                pReg->bBuiltin = false;
-                pReg->dlHandle = dlopen( sFName, RTLD_NOW );
-                if( pReg->dlHandle == NULL )
                {
-                        throw PluginException( 1, "Error on %s: %s", sFName, dlerror() );
+                        PluginReg *pReg;
+                        try {
+                                pReg = (PluginReg *)hPlugin[sPluginName];
+                                hPlugin.erase( sPluginName );
+                                dlclose( pReg->dlHandle );
+                                delete pReg;
+                                pReg = NULL;
+                        } catch( Bu::HashException &e )
+                        {
+                        }
+                        pReg = new PluginReg;
+                        pReg->bBuiltin = false;
+                        pReg->dlHandle = dlopen( sFName, RTLD_NOW );
+                        if( pReg->dlHandle == NULL )
+                        {
+                                throw PluginException( 1, "Error on %s: %s", sFName, dlerror() );
+                        }
+                        pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, sPluginName );
+                        if( pReg->pInfo == NULL )
+                        {
+                                throw PluginException( 2, "Error on %s: %s", sFName, dlerror() );
+                        }
+                        hPlugin.insert( pReg->pInfo->sID, pReg );
                }
-                pReg->pInfo = (PluginInfo *)dlsym( pReg->dlHandle, sPluginName );
-                if( pReg->pInfo == NULL )
+                T *instantiate( const char *lpName )
                {
-                        throw PluginException( 2, "Error on %s: %s", sFName, dlerror() );
+                        PluginReg *pReg = (PluginReg *)hPlugin[lpName];
+                        if( pReg == NULL )
+                                return NULL;
+                        T *p = (T *)pReg->pInfo->createPlugin();
+                        hObj.insert( (int )p, pReg );
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
+                
+                        return p;
                }
-                hPlugin.insert( pReg->pInfo->sID, pReg );
-                lPlugin.insert( lPlugin.end(), pReg );
-        }
-        T *instantiate( const char *lpName )
-        {
-                PluginReg *pReg = (PluginReg *)hPlugin[lpName];
-                if( pReg == NULL )
-                        return NULL;
-                T *p = (T *)pReg->pInfo->createPlugin();
-                hObj.insert( p, pReg );
-                //printf("pReg:  %08X, pPlug: %08X\n", pReg, p );
-        
-                return p;
-        }
-        bool hasPlugin( const char *lpName )
+                bool hasPlugin( const char *lpName )
-        {
+                {
-                if( hPlugin[lpName] == NULL )
+                        if( hPlugin[lpName] == NULL )
-                        return false;
+                                return false;
-                return true;
+                        return true;
-        }
+                }
-        void destroy( T *pPlug )
+                void destroy( T *pPlug )
-        {
+                {
-                PluginReg *pReg = (PluginReg *)hObj[pPlug];
+                        PluginReg *pReg = (PluginReg *)hObj.get((int)pPlug);
-                //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
+                        //printf("pReg:  %08X, pPlug: %08X\n", pReg, pPlug );
-                if( pReg == NULL )
+                        if( pReg == NULL )
-                        return;
+                                return;
-                pReg->pInfo->destroyPlugin( pPlug );
+                        pReg->pInfo->destroyPlugin( pPlug );
-                hObj.del( pPlug );
+                        hObj.erase( (int)pPlug );
-        }
+                }
-        void unloadAll()
+                void unloadAll()
-        {
-                std::list<PluginReg *>::iterator i;
-                for( i = lPlugin.begin(); i != lPlugin.end(); i++ )
                {
-                        if( (*i)->bBuiltin == false )
+                        for( PluginHash::iterator i = hPlugin.begin();
+                                 i != hPlugin.end(); i++ )
                        {
-                                dlclose( (*i)->dlHandle );
+                                if( (*i)->bBuiltin == false )
+                                {
+                                        dlclose( (*i)->dlHandle );
+                                }
+                                delete (*i);
                        }
-                        delete (*i);
+                        hPlugin.clear();
                }
-                hPlugin.clear();
-        }
-private:
+        private:
-        std::list<PluginReg *> lPlugin;
+                PluginHash hPlugin;
-        HashTable hPlugin;
+                InstHash hObj;
-        HashTable hObj;
+        };
-};
+}
 #endif
diff --git a/src/programchain.cpp b/src/programchain.cpp
index 6120d58..0bb7a77 100644
--- a/src/programchain.cpp
+++ b/src/programchain.cpp
@@ -1,17 +1,18 @@
 #include <stdlib.h>
-#include "programchain.h"
+#include "bu/programchain.h"
+#include "bu/programlink.h"
-ProgramChain::ProgramChain() :
+using namespace Bu;
-        xLog( MultiLog::getInstance() )
+Bu::ProgramChain::ProgramChain()
 {
-        xLog.LineLog( MultiLog::LStatus, "Program Chain Initialized." );
 }
-ProgramChain::~ProgramChain()
+Bu::ProgramChain::~ProgramChain()
 {
 }
-bool ProgramChain::addLink( ProgramLink *pLink )
+bool Bu::ProgramChain::addLink( ProgramLink *pLink )
 {
        if( pLink->init() == false )
        {
@@ -26,26 +27,25 @@ bool ProgramChain::addLink( ProgramLink *pLink )
        return true;
 }
-ProgramLink *ProgramChain::getLink( const char *lpName )
+ProgramLink *Bu::ProgramChain::getLink( const char *lpName )
 {
        char a;
        a = lpName[0];
        return NULL;
 }
-ProgramLink *ProgramChain::getBaseLink()
+ProgramLink *Bu::ProgramChain::getBaseLink()
 {
        return NULL;
 }
-bool ProgramChain::execChainOnce()
+bool Bu::ProgramChain::execChainOnce()
 {
-        int nLen = lLink.getSize();
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
-        for( int j = 0; j < nLen; j++ )
+                 i != lLink.end(); i++ )
        {
-                if( ((ProgramLink *)lLink[j])->timeSlice() == false )
+                if( (*i)->timeSlice() == false )
                {
-                        xLog.LineLog( MultiLog::LInfo, "Shutting down due to signal from link #%d", j );
                        emergencyShutdown();
                        return false;
                }
@@ -54,7 +54,7 @@ bool ProgramChain::execChainOnce()
        return true;
 }
-bool ProgramChain::enterChainLoop()
+bool Bu::ProgramChain::enterChainLoop()
 {
        for(;;)
        {
@@ -67,23 +67,23 @@ bool ProgramChain::enterChainLoop()
        return true;
 }
-void ProgramChain::emergencyShutdown()
+void Bu::ProgramChain::emergencyShutdown()
 {
-        int nLen = lLink.getSize();
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
-        for( int j = 0; j < nLen; j++ )
+                 i != lLink.end(); i++ )
        {
-                ((ProgramLink *)lLink[j])->deInit();
+                (*i)->deInit();
-                delete (ProgramLink *)lLink[j];
+                delete *i;
        }
-        lLink.empty();
+        lLink.clear();
 }
-LinkMessage *ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender )
+LinkMessage *Bu::ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender )
 {
-        int nLen = lLink.getSize();
+        for( Bu::List<Bu::ProgramLink *>::iterator i = lLink.begin();
-        for( int j = 0; j < nLen; j++ )
+                 i != lLink.end(); i++ )
        {
-                LinkMessage *pMsg = ((ProgramLink *)lLink[j])->processIRM( pMsgOut );
+                LinkMessage *pMsg = (*i)->processIRM( pMsgOut );
                if( pMsg != NULL )
                {
                        delete pMsgOut;
@@ -94,3 +94,4 @@ LinkMessage *ProgramChain::broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSen
        delete pMsgOut;
        return NULL;
 }
diff --git a/src/programchain.h b/src/programchain.h
index 2bdfeee..336a9f1 100644
--- a/src/programchain.h
+++ b/src/programchain.h
@@ -1,95 +1,98 @@
-#ifndef PROGRAMCHAIN_H
+#ifndef BU_PROGRAMCHAIN_H
-#define PROGRAMCHAIN_H
+#define BU_PROGRAMCHAIN_H
-#include "linkedlist.h"
+#include "bu/list.h"
-#include "multilog.h"
+#include "bu/linkmessage.h"
-#include "programlink.h"
-/**
+namespace Bu
- * The Program Chain links together program "chunks" to more easily facilitate
- * a generalized program loop with modular extensions.
- *@author Mike Buland
- */
-class ProgramChain
 {
-public:
+        class ProgramLink;
        /**
-         * Construct an empty chain.
+         * The Program Chain links together program "chunks" to more easily facilitate
+         * a generalized program loop with modular extensions.
+         *@author Mike Buland
         */
-        ProgramChain();
+        class ProgramChain
+        {
+        public:
+                /**
+                 * Construct an empty chain.
+                 */
+                ProgramChain();
-        /**
+                /**
-         * Destroy your chain.
+                 * Destroy your chain.
-         */
+                 */
-        virtual ~ProgramChain();
+                virtual ~ProgramChain();
-        /**
+                /**
-         * Adds a link to the end of the chain.
+                 * Adds a link to the end of the chain.
-         *@param pLink A pointer to the link to add to the chain.
+                 *@param pLink A pointer to the link to add to the chain.
-         *@returns True if adding the link was successful, otherwise false
+                 *@returns True if adding the link was successful, otherwise false
-         *@author Mike Buland
+                 *@author Mike Buland
-         */
+                 */
-        bool addLink( ProgramLink *pLink );
+                bool addLink( Bu::ProgramLink *pLink );
-        /**
+                /**
-         * Gets a link by name.
+                 * Gets a link by name.
-         *@param lpName The name of the link you're looking for.  Every link has a
+                 *@param lpName The name of the link you're looking for.  Every link has a
-         * name, apparently.
+                 * name, apparently.
-         *@returns A pointer to the specified ProgramLink, or NULL if none were
+                 *@returns A pointer to the specified ProgramLink, or NULL if none were
-         * found matching your criteria.
+                 * found matching your criteria.
-         *@author Mike Buland
+                 *@author Mike Buland
-         */
+                 */
-        class ProgramLink *getLink( const char *lpName );
+                class ProgramLink *getLink( const char *lpName );
-        /**
+                /**
-         * Gets the very first link in the chain.
+                 * Gets the very first link in the chain.
-         *@returns A pointer to the first link in the chain.
+                 *@returns A pointer to the first link in the chain.
-         *@author Mike Buland
+                 *@author Mike Buland
-         */
+                 */
-        class ProgramLink *getBaseLink();
+                class ProgramLink *getBaseLink();
-        /**
+                /**
-         * Runs through the chain once.  Useful if you want to have more control
+                 * Runs through the chain once.  Useful if you want to have more control
-         * over the operation of the chain.
+                 * over the operation of the chain.
-         *@returns true if every link returned true.  If at least one link returns
+                 *@returns true if every link returned true.  If at least one link returns
-         * false, then returns false.
+                 * false, then returns false.
-         *@author Mike Buland
+                 *@author Mike Buland
-         */
+                 */
-        bool execChainOnce();
+                bool execChainOnce();
-        /**
+                /**
-         * Enters the master chain loop, looping over the entire chain and
+                 * Enters the master chain loop, looping over the entire chain and
-         * executing every link's TimeSlice routine in order, over and over, until
+                 * executing every link's TimeSlice routine in order, over and over, until
-         * a link returns a false value.
+                 * a link returns a false value.
-         *@returns False, always.  It returns true unless a link returned false,
+                 *@returns False, always.  It returns true unless a link returned false,
-         * but loops until a link does return false.
+                 * but loops until a link does return false.
-         *@author Mike Buland
+                 *@author Mike Buland
-         **/
+                 **/
-        bool enterChainLoop();
+                bool enterChainLoop();
-        /**
+                /**
-         * Broadcasts an Immediate Response Message to all active links, save the
+                 * Broadcasts an Immediate Response Message to all active links, save the
-         * sender.  Whatever link first responds with a non-null response message
+                 * sender.  Whatever link first responds with a non-null response message
-         * will have it's messages sent back to the broadcasting link as the returns
+                 * will have it's messages sent back to the broadcasting link as the returns
-         * of this function call.  Therefore it is very important that all message
+                 * of this function call.  Therefore it is very important that all message
-         * processing code is handled in a fairly timely fasion.
+                 * processing code is handled in a fairly timely fasion.
-         *@param pMsgOut The message to broadcast in hopes of a response.
+                 *@param pMsgOut The message to broadcast in hopes of a response.
-         *@param pSender The message that sent out the message and doesn't want to
+                 *@param pSender The message that sent out the message and doesn't want to
-         * receive it's own message.  This should always just be "this".
+                 * receive it's own message.  This should always just be "this".
-         *@returns The message that was returned by the first link to return a
+                 *@returns The message that was returned by the first link to return a
-         * non-null response.  If all messages return null responses then this also
+                 * non-null response.  If all messages return null responses then this also
-         * returns null.  Please note that whoever calls this will be responsible
+                 * returns null.  Please note that whoever calls this will be responsible
-         * for deleting the message returned by it, if non-null.
+                 * for deleting the message returned by it, if non-null.
-         */
+                 */
-        class LinkMessage *broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender );
+                class LinkMessage *broadcastIRM( LinkMessage *pMsgOut, ProgramLink *pSender );
+        private:
+                /**
+                 * Shuts down all operation no matter what point in the operation we were.
+                 */
+                void emergencyShutdown();
+                Bu::List<Bu::ProgramLink *> lLink; /**< The linked list that contains all of the links. */
+        };
+}
-private:
-        /**
-         * Shuts down all operation no matter what point in the operation we were.
-         */
-        void emergencyShutdown();
-        MultiLog &xLog; /**< A reference to the log. */
-        LinkedList lLink; /**< The linked list that contains all of the links. */
-};
 #endif
diff --git a/src/programlink.cpp b/src/programlink.cpp
index 21c6fe4..e5c624c 100644
--- a/src/programlink.cpp
+++ b/src/programlink.cpp
@@ -1,20 +1,22 @@
-#include "programlink.h"
+#include "bu/programlink.h"
-#include "programchain.h"
+#include "bu/programchain.h"
-ProgramLink::ProgramLink()
+using namespace Bu;
+Bu::ProgramLink::ProgramLink()
 {
 }
-ProgramLink::~ProgramLink()
+Bu::ProgramLink::~ProgramLink()
 {
 }
-LinkMessage *ProgramLink::sendIRM( LinkMessage *pMsgOut )
+LinkMessage *Bu::ProgramLink::sendIRM( LinkMessage *pMsgOut )
 {
        return pChain->broadcastIRM( pMsgOut, this );
 }
-void ProgramLink::setChain( ProgramChain *pNewChain )
+void Bu::ProgramLink::setChain( ProgramChain *pNewChain )
 {
        pChain = pNewChain;
 }
diff --git a/src/programlink.h b/src/programlink.h
index f93edcc..07d7489 100644
--- a/src/programlink.h
+++ b/src/programlink.h
@@ -1,99 +1,100 @@
-#ifndef PROGRAMLINK_H
+#ifndef BU_PROGRAMLINK_H
-#define PROGRAMLINK_H
+#define BU_PROGRAMLINK_H
-class ProgramLink;
+#include "bu/linkmessage.h"
-#include "queue.h"
+#include "bu/programchain.h"
-#include "linkmessage.h"
-#include "programchain.h"
-/**
+namespace Bu
- * Program Link is the base class for any object that will be a piece of the
- * main program chain loop.
- *@author Mike Buland
- */
-class ProgramLink
 {
-friend class ProgramChain;
-public:
        /**
-         * Construct a program link.
+         * Program Link is the base class for any object that will be a piece of the
+         * main program chain loop.
+         *@author Mike Buland
         */
-        ProgramLink();
+        class ProgramLink
+        {
+        friend class Bu::ProgramChain;
+        public:
+                /**
+                 * Construct a program link.
+                 */
+                ProgramLink();
-        /**
+                /**
-         * Deconstruct.
+                 * Deconstruct.
-         */
+                 */
-        virtual ~ProgramLink();
+                virtual ~ProgramLink();
-        /**
+                /**
-         * Initialization code required for a link that wasn't performed in the
+                 * Initialization code required for a link that wasn't performed in the
-         * constructor.
+                 * constructor.
-         *@returns true if initialization was successful.  A false value will halt
+                 *@returns true if initialization was successful.  A false value will halt
-         * the chain.
+                 * the chain.
-         */
+                 */
-        virtual bool init()=0;
+                virtual bool init()=0;
-        /**
+                /**
-         * DeInitialization code that should happen, but doesn't belong in the
+                 * DeInitialization code that should happen, but doesn't belong in the
-         * destructor.
+                 * destructor.
-         *@returns true means everything worked, false means failure, but is
+                 *@returns true means everything worked, false means failure, but is
-         * meaningless.
+                 * meaningless.
-         */
+                 */
-        virtual bool deInit()=0;
+                virtual bool deInit()=0;
-        /**
+                /**
-         * Executed once per link per chain pass.  Contains the guts of the program.
+                 * Executed once per link per chain pass.  Contains the guts of the program.
-         *@returns true if everything went well.  A false value will halt the chain.
+                 *@returns true if everything went well.  A false value will halt the chain.
-         */
+                 */
-        virtual bool timeSlice()=0;
+                virtual bool timeSlice()=0;
-        /**
+                /**
-         * This must be handled in order to process Instant Response Messages.
+                 * This must be handled in order to process Instant Response Messages.
-     * This function should return null on all messages that it doesn't
+                 * This function should return null on all messages that it doesn't
-     * understand how to handle, and construct new messages to return to sender
+                 * understand how to handle, and construct new messages to return to sender
-         * in the cases where it does understand.
+                 * in the cases where it does understand.
-         *@param pMsgIn The message that must be processed.
+                 *@param pMsgIn The message that must be processed.
-         *@returns Either a new message in cases where a response is required,
+                 *@returns Either a new message in cases where a response is required,
-         * or null if nothing needs to be done by this link.
+                 * or null if nothing needs to be done by this link.
-         */
+                 */
-        virtual LinkMessage *processIRM( LinkMessage *pMsgIn ) = 0;
+                virtual LinkMessage *processIRM( LinkMessage *pMsgIn ) = 0;
-        /**
+                /**
-         * Broadcast a LinkMessage to all other links in the system.  Each other
+                 * Broadcast a LinkMessage to all other links in the system.  Each other
-         * link will get a call of their processIRM function.  If the message gets
+                 * link will get a call of their processIRM function.  If the message gets
-         * a response then you will regain control immediately, otherwise the system
+                 * a response then you will regain control immediately, otherwise the system
-         * will give all other Links a chance to respond before returning NULL.
+                 * will give all other Links a chance to respond before returning NULL.
-         *@param pMsgOut The message to broadcast.
+                 *@param pMsgOut The message to broadcast.
-         *@returns The message response, or NULL if no Link understood your message.
+                 *@returns The message response, or NULL if no Link understood your message.
-         */
+                 */
-        LinkMessage *sendIRM( LinkMessage *pMsgOut );
+                LinkMessage *sendIRM( LinkMessage *pMsgOut );
-private:
+        private:
-        /**
+                /**
-         * Set which chain we're assosiated with.  This is how IRM messages make
+                 * Set which chain we're assosiated with.  This is how IRM messages make
-         * it out to the rest of the world.
+                 * it out to the rest of the world.
-         *@param pNewChain A pointer to the containing program chain.
+                 *@param pNewChain A pointer to the containing program chain.
-         */
+                 */
-        void setChain( class ProgramChain *pNewChain );
+                void setChain( class ProgramChain *pNewChain );
-        /**
+                /**
-         * The pointer to the containing chain.
+                 * The pointer to the containing chain.
-         */
+                 */
-        class ProgramChain *pChain;
+                class ProgramChain *pChain;
-/*
+        /*
-        void postMessage( LinkMessage *pMsg, int nLvl );
+                void postMessage( LinkMessage *pMsg, int nLvl );
-        LinkMessage *getMessage( int nLvl );
+                LinkMessage *getMessage( int nLvl );
-        enum
+                enum
-        {
+                {
-                msgToChain,
+                        msgToChain,
-                msgToLink
+                        msgToLink
-        };
+                };
-private:
+        private:
-        Queue qMsgToChain;
+                Queue qMsgToChain;
-        Queue qMsgToLink;
+                Queue qMsgToLink;
-*/
+        */
-};
+        };
+}
 #endif
diff --git a/src/protocol.cpp b/src/protocol.cpp
index 78b3ee2..0976b3b 100644
--- a/src/protocol.cpp
+++ b/src/protocol.cpp
@@ -1,20 +1,12 @@
-#include "protocol.h"
+#include "bu/protocol.h"
-Protocol::Protocol()
+using namespace Bu;
-{
-        pConnection = NULL;
-}
-Protocol::~Protocol()
+Bu::Protocol::Protocol()
 {
 }
-void Protocol::setConnection( Connection *pNewConnection )
+Bu::Protocol::~Protocol()
 {
-        pConnection = pNewConnection;
 }
-Connection *Protocol::getConnection()
-{
-        return pConnection;
-}
diff --git a/src/protocol.h b/src/protocol.h
index 09e1c98..bca337f 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -1,62 +1,27 @@
-#ifndef PROTOCOL_H
+#ifndef BU_PROTOCOL_H
-#define PROTOCOL_H
+#define BU_PROTOCOL_H
-#include "connection.h"
+#include <stdint.h>
-/** This is the template for a class that handles specialized input and output
+namespace Bu
-  * to connections of different types with different protocols.
-  *@author Mike Buland
-  */
-class Protocol
 {
-public:
+        class Client;
-        /** Constructor */
-    Protocol();
-        /** Deconstructor */
-    virtual ~Protocol();
        /**
-         * Function is called every time there is new data on the line.  This is
+         *
-         * called directly from the Connection class to process data.  This is not
-         * called whever there is pending data on the input, but every time new data
-         * is added to the input buffer.
-         *@returns True if processing went alright, false if something went wrong,
-         * I suppose.  In truth this value is thrown away right now.
-         *@todo Either make a return value of false mean something, or make these
-         * void.
         */
-        virtual bool onNewData()=0;
+        class Protocol
+        {
+        public:
+                Protocol();
+                virtual ~Protocol();
-        /**
+                virtual void onNewConnection( Bu::Client *pClient )=0;
-         * Function is called when there is a new connection.  This should only
+                virtual void onNewData( Bu::Client *pClient )=0;
-         * happen once per Protocol object, but gives each protocol object a
-         * chance to perform connection handshaking and initialization at a point
-         * where they know that they have a handle to an active Connection.
-         *@returns See onNewData
-         */
-        virtual bool onNewConnection()=0;
-        virtual void onNewClientConnection(){};
-        virtual void poll(){};
+        private:
-        /**
-         * Sets the Protocol's Connection object.  This is rather important, and
-         * handled usually by the ConnectionManager.
-         *@param pNewConnection The Connection object that this protocol will use to
-         * deal with the outside world.
-         */
-        void setConnection( class Connection *pNewConnection );
-        /**
-         * Get a pointer to this object's Connection object, or NULL if one was
-         * never set.  If used with the ConnectionManager that should never happen.
-         *@returns A pointer to the active Connection.
-         */
-        Connection *getConnection();
-private:
+        };
-        class Connection *pConnection; /**< The pointer to the Connection. */
+}
-};
 #endif
diff --git a/src/ringbuffer.cpp b/src/ringbuffer.cpp
new file mode 100644
index 0000000..feb9bc7
--- /dev/null
+++ b/src/ringbuffer.cpp
@@ -0,0 +1,2 @@
+#include "bu/ringbuffer.h"
diff --git a/src/ringbuffer.h b/src/ringbuffer.h
new file mode 100644
index 0000000..be80e2f
--- /dev/null
+++ b/src/ringbuffer.h
@@ -0,0 +1,97 @@
+#ifndef BU_RING_BUFFER_H
+#define BU_RING_BUFFER_H
+#include <memory>
+#include "bu/exceptionbase.h"
+namespace Bu
+{
+        template<typename value, typename valuealloc=std::allocator<value> >
+        class RingBuffer
+        {
+        public:
+                RingBuffer( int nCapacity ) :
+                        nCapacity( nCapacity ),
+                        nStart( -1 ),
+                        nEnd( -2 )
+                {
+                        aData = va.allocate( nCapacity );
+                }
+                virtual ~RingBuffer()
+                {
+                        for( int j = nStart; j < nEnd; j=(j+1%nCapacity) )
+                        {
+                                va.destroy( &aData[j] );
+                        }
+                        va.deallocate( aData, nCapacity );
+                }
+                int getCapacity()
+                {
+                        return nCapacity;
+                }
+                bool isFilled()
+                {
+                        return (nStart == nEnd);
+                }
+                bool isEmpty()
+                {
+                        return (nStart == -1);
+                }
+                void enqueue( const value &v )
+                {
+                        if( nStart == -1 )
+                        {
+                                nStart = 0;
+                                nEnd = 1;
+                                va.construct( &aData[0], v );
+                        }
+                        else if( nStart == nEnd )
+                        {
+                                throw ExceptionBase("Hey, it's full!");
+                        }
+                        else
+                        {
+                                va.construct( &aData[nEnd], v );
+                                nEnd = (nEnd+1)%nCapacity;
+                        }
+                }
+                value dequeue()
+                {
+                        if( nStart == -1 )
+                        {
+                                throw ExceptionBase("No data");
+                        }
+                        else
+                        {
+                                value &v = aData[nStart];
+                                va.destroy( &aData[nStart] );
+                                nStart = (nStart+1)%nCapacity;
+                                if( nStart == nEnd )
+                                {
+                                        nStart = -1;
+                                        nEnd = -2;
+                                }
+                                return v;
+                        }
+                }
+                value &operator[]( int nIndex )
+                {
+                        return aData[(nIndex+nStart)%nCapacity];
+                }
+        private:
+                int nCapacity;
+                value *aData;
+                valuealloc va;
+                int nStart, nEnd;
+        };
+}
+#endif
diff --git a/src/serializable.cpp b/src/serializable.cpp
deleted file mode 100644
index fd50943..0000000
--- a/src/serializable.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "serializable.h"
-Serializable::Serializable()
-{
-}
-Serializable::~Serializable()
-{
-}
diff --git a/src/serializable.h b/src/serializable.h
deleted file mode 100644
index 06def29..0000000
--- a/src/serializable.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef SERIALIZER_H
-#define SERIALIZER_H
-//#include "serializer.h"
-/**
- * The base class for any class you want to serialize.  Simply include this as
- * a base class, implement the purely virtual serialize function and you've got
- * an easily serializable class.
- */
-class Serializable
-{
-public:
-        /**
-         * Does nothing, here for completeness.
-         */
-        Serializable();
-        /**
-         * Here to ensure the deconstructor is virtual.
-         */
-        virtual ~Serializable();
-        /**
-         * This is the main workhorse of the serialization system, just override and
-         * you've got a serializable class.  A reference to the Serializer archive
-         * used is passed in as your only parameter, query it to discover if you are
-         * loading or saving.
-         * @param ar A reference to the Serializer object to use.
-         */
-        virtual void serialize( class Serializer &ar )=0;
-};
-#endif
diff --git a/src/serializer.cpp b/src/serializer.cpp
deleted file mode 100644
index 636224e..0000000
--- a/src/serializer.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-#include "serializer.h"
-#include "serializable.h"
-#include <list>
-Serializer::Serializer(bool bLoading):
-        bLoading(bLoading)
-{
-}
-Serializer::~Serializer()
-{
-}
-bool Serializer::isLoading()
-{
-        return bLoading;
-}
-Serializer &Serializer::operator<<(bool p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int8_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int16_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int32_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(int64_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint8_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint16_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint32_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(uint64_t p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(long p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(float p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(double p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator<<(long double p)
-{
-        write( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(bool &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int8_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int16_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int32_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(int64_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint8_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint16_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint32_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(uint64_t &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(long &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(float &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(double &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator>>(long double &p)
-{
-        read( &p, sizeof(p) );
-        return *this;
-}
-Serializer &Serializer::operator&&(bool &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(int8_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(int16_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(int32_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(int64_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(uint8_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(uint16_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(uint32_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(uint64_t &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(float &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(double &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &Serializer::operator&&(long double &p)
-{
-        if (bLoading)
-        {
-                return *this >> p;
-        }
-        else
-        {
-                return *this << p;
-        }
-}
-Serializer &operator<<(Serializer &s, Serializable &p)
-{
-        p.serialize( s );
-        return s;
-}
-Serializer &operator>>(Serializer &s, Serializable &p)
-{
-        p.serialize( s );
-        return s;
-}
-Serializer &operator&&(Serializer &s, Serializable &p)
-{
-        if (s.isLoading())
-        {
-                return s >> p;
-        }
-        else
-        {
-                return s << p;
-        }
-}
-Serializer &operator<<( Serializer &ar, std::string &s )
-{
-        ar << (uint32_t)s.length();
-        ar.write( s.c_str(), s.length() );
-        return ar;
-}
-Serializer &operator>>( Serializer &ar, std::string &s )
-{
-        uint32_t l;
-        ar >> l;
-        char *tmp = new char[l+1];
-        tmp[l] = '\0';
-        ar.read( tmp, l );
-        s = tmp;
-        delete[] tmp;
-        return ar;
-}
diff --git a/src/serializer.h b/src/serializer.h
deleted file mode 100644
index 3af489c..0000000
--- a/src/serializer.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef SERIALIZABLE_H
-#define SERIALIZABLE_H
-#include <stdint.h>
-#include <string>
-#include <list>
-//#include "serializable.h"
-class Serializer
-{
-private:
-        bool bLoading;
-public:
-        bool isLoading();
-        enum
-        {
-                load    =       true,
-                save    =       false
-        };
-        
-        Serializer(bool bLoading);
-        virtual ~Serializer();
-        virtual void close()=0;
-        virtual void write(const void *, int32_t)=0;
-        virtual void read(void *, int32_t)=0;
-        
-        virtual Serializer &operator<<(bool);
-        virtual Serializer &operator<<(int8_t);
-        virtual Serializer &operator<<(int16_t);
-        virtual Serializer &operator<<(int32_t);
-        virtual Serializer &operator<<(int64_t);
-        virtual Serializer &operator<<(uint8_t);
-        virtual Serializer &operator<<(uint16_t);
-        virtual Serializer &operator<<(uint32_t);
-        virtual Serializer &operator<<(uint64_t);
-        virtual Serializer &operator<<(long);
-        virtual Serializer &operator<<(float);
-        virtual Serializer &operator<<(double);
-        virtual Serializer &operator<<(long double);
-        virtual Serializer &operator>>(bool &);
-        virtual Serializer &operator>>(int8_t &);
-        virtual Serializer &operator>>(int16_t &);
-        virtual Serializer &operator>>(int32_t &);
-        virtual Serializer &operator>>(int64_t &);
-        virtual Serializer &operator>>(uint8_t &);
-        virtual Serializer &operator>>(uint16_t &);
-        virtual Serializer &operator>>(uint32_t &);
-        virtual Serializer &operator>>(uint64_t &);
-        virtual Serializer &operator>>(long &);
-        virtual Serializer &operator>>(float &);
-        virtual Serializer &operator>>(double &);
-        virtual Serializer &operator>>(long double &);
-        
-        virtual Serializer &operator&&(bool &);
-        virtual Serializer &operator&&(int8_t &);
-        virtual Serializer &operator&&(int16_t &);
-        virtual Serializer &operator&&(int32_t &);
-        virtual Serializer &operator&&(int64_t &);
-        virtual Serializer &operator&&(uint8_t &);
-        virtual Serializer &operator&&(uint16_t &);
-        virtual Serializer &operator&&(uint32_t &);
-        virtual Serializer &operator&&(uint64_t &);
-        virtual Serializer &operator&&(float &);
-        virtual Serializer &operator&&(double &);
-        virtual Serializer &operator&&(long double &);
-        //virtual Serializer &operator&(Serializable &);
-};
-Serializer &operator<<(Serializer &, class Serializable &);
-Serializer &operator>>(Serializer &, class Serializable &);
-Serializer &operator&&(Serializer &s, class Serializable &p);
-Serializer &operator<<(Serializer &, std::string &);
-Serializer &operator>>(Serializer &, std::string &);
-#endif
diff --git a/src/server.cpp b/src/server.cpp
new file mode 100644
index 0000000..d07a597
--- /dev/null
+++ b/src/server.cpp
@@ -0,0 +1,96 @@
+#include "bu/server.h"
+#include <errno.h>
+#include "bu/serversocket.h"
+#include "bu/client.h"
+#include "bu/socket.h"
+Bu::Server::Server() :
+        nTimeoutSec( 0 ),
+        nTimeoutUSec( 0 )
+{
+        FD_ZERO( &fdActive );
+}
+Bu::Server::~Server()
+{
+}
+void Bu::Server::addPort( int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+void Bu::Server::addPort( const FString &sAddr, int nPort, int nPoolSize )
+{
+        ServerSocket *s = new ServerSocket( sAddr, nPort, nPoolSize );
+        int nSocket = s->getSocket();
+        FD_SET( nSocket, &fdActive );
+        hServers.insert( nSocket, s );
+}
+void Bu::Server::setTimeout( int nTimeoutSec, int nTimeoutUSec )
+{
+        this->nTimeoutSec = nTimeoutSec;
+        this->nTimeoutUSec = nTimeoutUSec;
+}
+void Bu::Server::scan()
+{
+        struct timeval xTimeout = { nTimeoutSec, nTimeoutUSec };
+        
+        fd_set fdRead = fdActive;
+        fd_set fdWrite = fdActive;
+        fd_set fdException = fdActive;
+        if( TEMP_FAILURE_RETRY( select( FD_SETSIZE, &fdRead, NULL, &fdException, &xTimeout ) ) < 0 )
+        {
+                throw ExceptionBase("Error attempting to scan open connections.");
+        }
+        for( int j = 0; j < FD_SETSIZE; j++ )
+        {
+                if( FD_ISSET( j, &fdRead ) )
+                {
+                        if( hServers.has( j ) )
+                        {
+                                ServerSocket *pSrv = hServers.get( j );
+                                addClient( pSrv->accept(), pSrv->getPort() );
+                        }
+                        else
+                        {
+                                Client *pClient = hClients.get( j );
+                                pClient->processInput();
+                                if( !pClient->isOpen() )
+                                {
+                                        onClosedConnection( pClient );
+                                        hClients.erase( j );
+                                        FD_CLR( j, &fdActive );
+                                }
+                        }
+                }
+        }
+        // Now we just try to write all the pending data on all the sockets.
+        // this could be done better eventually, if we care about the socket
+        // wanting to accept writes (using a select).
+        for( ClientHash::iterator i = hClients.begin(); i != hClients.end(); i++ )
+        {
+                (*i)->processOutput();
+        }
+}
+void Bu::Server::addClient( int nSocket, int nPort )
+{
+        FD_SET( nSocket, &fdActive );
+        Client *c = new Client(
+                new Bu::Socket( nSocket )
+                );
+        hClients.insert( nSocket, c );
+        onNewConnection( c, nPort );
+}
diff --git a/src/server.h b/src/server.h
new file mode 100644
index 0000000..302b6e3
--- /dev/null
+++ b/src/server.h
@@ -0,0 +1,61 @@
+#ifndef BU_SERVER_H
+#define BU_SERVER_H
+#include <stdint.h>
+#include "bu/fstring.h"
+#include "bu/list.h"
+namespace Bu
+{
+        class ServerSocket;
+        class Socket;
+        class Client;
+        /**
+         * Core of a network server.  This class is distinct from a ServerSocket in
+         * that a ServerSocket is one listening socket, nothing more.  Socket will
+         * manage a pool of both ServerSockets and connected Sockets along with
+         * their protocols and buffers.
+         *
+         * To start serving on a new port, use the addPort functions.  Each call to
+         * addPort creates a new ServerSocket, starts it listening, and adds it to
+         * the server pool.
+         *
+         * All of the real work is done by scan, which will wait for up
+         * to the timeout set by setTimeout before returning if there is no data
+         * pending.  scan should probably be called in some sort of tight
+         * loop, possibly in it's own thread, or in the main control loop.
+         *
+         * In order to use a Server you must subclass it and implement the pure
+         * virtual functions.  These allow you to receive notification of events
+         * happening within the server itself, and actually makes it useful.
+         */
+        class Server
+        {
+        public:
+                Server();
+                virtual ~Server();
+                void addPort( int nPort, int nPoolSize=40 );
+                void addPort( const FString &sAddr, int nPort, int nPoolSize=40 );
+                void scan();
+                void setTimeout( int nTimeoutSec, int nTimeoutUSec=0 );
+                void addClient( int nSocket, int nPort );
+                virtual void onNewConnection( Client *pClient, int nPort )=0;
+                virtual void onClosedConnection( Client *pClient )=0;
+        private:
+                int nTimeoutSec;
+                int nTimeoutUSec;
+                fd_set fdActive;
+                Hash<int,ServerSocket *> hServers;
+                typedef Hash<int,Client *> ClientHash;
+                ClientHash hClients;
+        };
+}
+#endif
diff --git a/src/serversocket.cpp b/src/serversocket.cpp
new file mode 100644
index 0000000..1424630
--- /dev/null
+++ b/src/serversocket.cpp
@@ -0,0 +1,158 @@
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <termios.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include "serversocket.h"
+#include "exceptions.h"
+Bu::ServerSocket::ServerSocket( int nPort, int nPoolSize ) :
+        nPort( nPort )
+{
+        /* Create the socket and set it up to accept connections. */
+        struct sockaddr_in name;
+        /* Give the socket a name. */
+        name.sin_family = AF_INET;
+        name.sin_port = htons( nPort );
+        // I think this specifies who we will accept connections from,
+        // a good thing to make configurable later on
+        name.sin_addr.s_addr = htonl( INADDR_ANY );
+        startServer( name, nPoolSize );
+}
+Bu::ServerSocket::ServerSocket(const FString &sAddr,int nPort, int nPoolSize) :
+        nPort( nPort )
+{
+        /* Create the socket and set it up to accept connections. */
+        struct sockaddr_in name;
+        /* Give the socket a name. */
+        name.sin_family = AF_INET;
+        name.sin_port = htons( nPort );
+        inet_aton( sAddr.getStr(), &name.sin_addr );
+        startServer( name, nPoolSize );
+}
+Bu::ServerSocket::~ServerSocket()
+{
+}
+void Bu::ServerSocket::startServer( struct sockaddr_in &name, int nPoolSize )
+{
+        /* Create the socket. */
+        nServer = socket( PF_INET, SOCK_STREAM, 0 );
+        if( nServer < 0 )
+        {
+                throw Bu::SocketException("Couldn't create a listen socket.");
+        }
+        int opt = 1;
+        setsockopt(
+                nServer,
+                SOL_SOCKET,
+                SO_REUSEADDR,
+                (char *)&opt,
+                sizeof( opt )
+                );
+        if( bind( nServer, (struct sockaddr *) &name, sizeof(name) ) < 0 )
+        {
+                throw Bu::SocketException("Couldn't bind to the listen socket.");
+        }
+        if( listen( nServer, nPoolSize ) < 0 )
+        {
+                throw Bu::SocketException(
+                        "Couldn't begin listening to the server socket."
+                        );
+        }
+        FD_ZERO( &fdActive );
+        /* Initialize the set of active sockets. */
+        FD_SET( nServer, &fdActive );
+}
+int Bu::ServerSocket::getSocket()
+{
+        return nServer;
+}
+int Bu::ServerSocket::accept( int nTimeoutSec, int nTimeoutUSec )
+{
+        fd_set fdRead = fdActive;
+        struct timeval xT;
+        xT.tv_sec = nTimeoutSec;
+        xT.tv_usec = nTimeoutUSec;      
+        if( TEMP_FAILURE_RETRY(select( nServer+1, &fdRead, NULL, NULL, &xT )) < 0 )
+        {
+                throw SocketException(
+                        "Error scanning for new connections: %s", strerror( errno )
+                        );
+        }
+        if( FD_ISSET( nServer, &fdRead ) )
+        {
+                struct sockaddr_in clientname;
+                size_t size;
+                int nClient;
+                size = sizeof( clientname );
+#ifdef __CYGWIN__
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname,
+                                (int *)&size
+                                );
+#else
+                nClient = ::accept( nServer, (struct sockaddr *)&clientname, &size );
+#endif
+                if( nClient < 0 )
+                {
+                        throw SocketException(
+                                "Error accepting a new connection: %s", strerror( errno )
+                                );
+                }
+                char tmpa[20];
+                inet_ntop( AF_INET, (void *)&clientname.sin_addr, tmpa, 20 );
+                //"New connection from host %s, port %hd.",
+                //  tmpa, ntohs (clientname.sin_port) );
+                
+                {
+                        int flags;
+                        flags = fcntl( nClient, F_GETFL, 0 );
+                        flags |= O_NONBLOCK;
+                        if( fcntl( nClient, F_SETFL, flags ) < 0)
+                        {
+                                throw SocketException(
+                                        "Error setting option on client socket: %s",
+                                        strerror( errno )
+                                        );
+                        }
+                }
+                return nClient;
+        }
+        return -1;
+}
+int Bu::ServerSocket::getPort()
+{
+        return nPort;
+}
diff --git a/src/serversocket.h b/src/serversocket.h
new file mode 100644
index 0000000..b4ee247
--- /dev/null
+++ b/src/serversocket.h
@@ -0,0 +1,39 @@
+#ifndef BU_SERVER_SOCKET_H
+#define BU_SERVER_SOCKET_H
+#include <stdint.h>
+#include "bu/fstring.h"
+namespace Bu
+{
+        /**
+         * A single tcp/ip server socket.  When created the server socket will bind
+         * to the specified interface and port, and immediately begin listening for
+         * connections.  When connections come in they are pooled by the networking
+         * drivers in the kernel until they are accepted, this means that failure
+         * to keep space in the connection pool will result in connection refusals.
+         *
+         * Although the accept function returns an integral file descriptor, it is
+         * designed to be used with the Socket class.
+         */
+        class ServerSocket
+        {
+        public:
+                ServerSocket( int nPort, int nPoolSize=40 );
+                ServerSocket( const FString &sAddr, int nPort, int nPoolSize=40 );
+                virtual ~ServerSocket();
+                int accept( int nTimeoutSec=0, int nTimeoutUSec=0 );
+                int getSocket();
+                int getPort();
+        private:
+                void startServer( struct sockaddr_in &name, int nPoolSize );
+                fd_set fdActive;
+                int nServer;
+                int nPort;
+        };
+}
+#endif
diff --git a/src/sfile.cpp b/src/sfile.cpp
deleted file mode 100644
index f1de03c..0000000
--- a/src/sfile.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "sfile.h"
-#include "exceptions.h"
-SFile::SFile( const char *sName, const char *sFlags )
-{
-        fh = fopen( sName, sFlags );
-}
-SFile::~SFile()
-{
-}
-void SFile::close()
-{
-        if( fh )
-        {
-                fclose( fh );
-                fh = NULL;
-        }
-}
-size_t SFile::read( char *pBuf, size_t nBytes )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        return fread( pBuf, 1, nBytes, fh );
-}
-size_t SFile::write( const char *pBuf, size_t nBytes )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        return fwrite( pBuf, 1, nBytes, fh );
-}
-long SFile::tell()
-{
-        if( !fh )
-                throw FileException("File not open.");
-        return ftell( fh );
-}
-void SFile::seek( long offset )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        fseek( fh, offset, SEEK_CUR );
-}
-void SFile::setPos( long pos )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        fseek( fh, pos, SEEK_SET );
-}
-void SFile::setPosEnd( long pos )
-{
-        if( !fh )
-                throw FileException("File not open.");
-        
-        fseek( fh, pos, SEEK_END );
-}
-bool SFile::isEOS()
-{
-        return feof( fh );
-}
diff --git a/src/sfile.h b/src/sfile.h
deleted file mode 100644
index b51e5bc..0000000
--- a/src/sfile.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef SFILE_H
-#define SFILE_H
-#include <stdint.h>
-#include "stream.h"
-class SFile : public Stream
-{
-public:
-        SFile( const char *sName, const char *sFlags );
-        virtual ~SFile();
-        virtual void close();
-        virtual size_t read( char *pBuf, size_t nBytes );
-        virtual size_t write( const char *pBuf, size_t nBytes );
-        virtual long tell();
-        virtual void seek( long offset );
-        virtual void setPos( long pos );
-        virtual void setPosEnd( long pos );
-        virtual bool isEOS();
-private:
-        FILE *fh;
-};
-#endif
diff --git a/src/singleton.h b/src/singleton.h
index 47adbd5..c43d71b 100644
--- a/src/singleton.h
+++ b/src/singleton.h
@@ -1,59 +1,62 @@
-#ifndef SINGLETON_H
+#ifndef BU_SINGLETON_H
-#define SINGLETON_H
+#define BU_SINGLETON_H
 #include <stdio.h>
-/**
+namespace Bu
- * Provides singleton functionality in a modular sort of way.  Make this the
- * base class of any other class and you immediately gain singleton
- * functionality.  Be sure to make your constructor and various functions use
- * intellegent scoping.  Cleanup and instantiation are performed automatically
- * for you at first use and program exit.  There are two things that you must
- * do when using this template, first is to inherit from it with the name of
- * your class filling in for T and then make this class a friend of your class.
- *@code
- * // Making the Single Singleton:
- * class Single : public Singleton<Single>
- * {
- *              friend class Singleton<Single>;
- *      protected:
- *              Single();
- *              ...
- * };
- @endcode
- * You can still add public functions and variables to your new Singleton child
- * class, but your constructor should be protected (hence the need for the
- * friend decleration).
- *@author Mike Buland
- */
-template <class T>
-class Singleton
 {
-protected:
        /**
-         * Private constructor.  This constructor is empty but has a body so that
+         * Provides singleton functionality in a modular sort of way.  Make this the
-         * you can make your own override of it.  Be sure that you're override is
+         * base class of any other class and you immediately gain singleton
-         * also protected.
+         * functionality.  Be sure to make your constructor and various functions use
+         * intellegent scoping.  Cleanup and instantiation are performed automatically
+         * for you at first use and program exit.  There are two things that you must
+         * do when using this template, first is to inherit from it with the name of
+         * your class filling in for T and then make this class a friend of your class.
+         *@code
+         * // Making the Single Singleton:
+         * class Single : public Singleton<Single>
+         * {
+         *              friend class Singleton<Single>;
+         *      protected:
+         *              Single();
+         *              ...
+         * };
+         @endcode
+         * You can still add public functions and variables to your new Singleton child
+         * class, but your constructor should be protected (hence the need for the
+         * friend decleration).
+         *@author Mike Buland
         */
-        Singleton() {};
+        template <class T>
+        class Singleton
+        {
+        protected:
+                /**
+                 * Private constructor.  This constructor is empty but has a body so that
+                 * you can make your own override of it.  Be sure that you're override is
+                 * also protected.
+                 */
+                Singleton() {};
-private:
+        private:
-        /**
+                /**
-         * Copy constructor, defined so that you could write your own as well.
+                 * Copy constructor, defined so that you could write your own as well.
-         */
+                 */
-        Singleton( const Singleton& );
+                Singleton( const Singleton& );
-public:
+        public:
-        /**
+                /**
-         * Get a handle to the contained instance of the contained class.  It is
+                 * Get a handle to the contained instance of the contained class.  It is
-         * a reference.
+                 * a reference.
-         *@returns A reference to the contained object.
+                 *@returns A reference to the contained object.
-         */
+                 */
-        static T &getInstance()
+                static T &getInstance()
-        {
+                {
-                static T i;
+                        static T i;
-                return i;
+                        return i;
-        }
+                }
-};
+        };
+}
 #endif
diff --git a/src/socket.cpp b/src/socket.cpp
new file mode 100644
index 0000000..e567061
--- /dev/null
+++ b/src/socket.cpp
@@ -0,0 +1,294 @@
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include "socket.h"
+#include "exceptions.h"
+#define RBS (1024*2)
+Bu::Socket::Socket( int nSocket ) :
+        nSocket( nSocket ),
+        bActive( true )
+{
+}
+Bu::Socket::Socket( const Bu::FString &sAddr, int nPort, int nTimeout )
+{
+        struct sockaddr_in xServerName;
+        bActive = false;
+     
+        /* Create the socket. */
+        nSocket = socket( PF_INET, SOCK_STREAM, 0 );
+        
+        if( nSocket < 0 )
+        {
+                throw ExceptionBase("Couldn't create socket.\n");
+        }
+        // These lines set the socket to non-blocking, a good thing?
+        int flags;
+        flags = fcntl(nSocket, F_GETFL, 0);
+        flags |= O_NONBLOCK;
+        if (fcntl(nSocket, F_SETFL, flags) < 0)
+        {
+                throw ExceptionBase("Couldn't set socket options.\n");
+        }
+     
+        /* Connect to the server. */
+        //printf("Resolving hostname (%s)...\n", sAddr );
+        {
+                struct hostent *hostinfo;
+     
+                xServerName.sin_family = AF_INET;
+                xServerName.sin_port = htons( nPort );
+                hostinfo = gethostbyname( sAddr.getStr() );
+                if (hostinfo == NULL)
+                {
+                        throw ExceptionBase("Couldn't resolve hostname.\n");
+                }
+                xServerName.sin_addr = *(struct in_addr *) hostinfo->h_addr;
+        }
+        //printf("Making actual connection...");
+        //fflush( stdout );
+        connect(
+                nSocket,
+                (struct sockaddr *)&xServerName,
+                sizeof(xServerName)
+                );
+        //printf("Connected.\n");
+        
+        bActive = true;
+        if( nTimeout > 0 )
+        {
+                fd_set rfds, wfds, efds;
+                int retval;
+                
+                FD_ZERO(&rfds);
+                FD_SET(nSocket, &rfds);
+                FD_ZERO(&wfds);
+                FD_SET(nSocket, &wfds);
+                FD_ZERO(&efds);
+                FD_SET(nSocket, &efds);
+                struct timeval tv;
+                tv.tv_sec = nTimeout;
+                tv.tv_usec = 0;
+                
+                retval = select( nSocket+1, &rfds, &wfds, &efds, &tv );
+                if( retval == 0 )
+                {
+                        close();
+                        throw ExceptionBase("Connection timeout.\n");
+                }
+                
+        }
+}
+Bu::Socket::~Socket()
+{
+}
+void Bu::Socket::close()
+{
+        if( bActive )
+        {
+                fsync( nSocket );
+                ::close( nSocket );
+        }
+        bActive = false;
+}
+/*
+void Bu::Socket::read()
+{
+        char buffer[RBS];
+        int nbytes;
+        int nTotalRead=0;
+        for(;;)
+        {
+                //memset( buffer, 0, RBS );
+                nbytes = ::read( nSocket, buffer, RBS );
+                if( nbytes < 0 && errno != 0 && errno != EAGAIN )
+                {
+                        //printf("errno: %d, %s\n", errno, strerror( errno ) );
+                        //perror("readInput");
+                        throw ConnectionException(
+                                excodeReadError,
+                                "Read error: %s",
+                                strerror( errno )
+                                );
+                }
+                else
+                {
+                        if( nbytes <= 0 )
+                                break;
+                        nTotalRead += nbytes;
+                        sReadBuf.append( buffer, nbytes );
+                        if( nbytes < RBS )
+                        {
+                                break;
+                        }
+                        // New test, if data is divisible by RBS bytes on some libs the
+                        // read could block, this keeps it from happening.
+                        {
+                                fd_set rfds;
+                                FD_ZERO(&rfds);
+                                FD_SET(nSocket, &rfds);
+                                struct timeval tv = { 0, 0 };
+                                int retval = select( nSocket+1, &rfds, NULL, NULL, &tv );
+                                if( retval == -1 )
+                                        throw ConnectionException(
+                                                excodeBadReadError,
+                                                "Bad Read error"
+                                                );
+                                if( !FD_ISSET( nSocket, &rfds ) )
+                                        break;
+                        }
+                }
+        }
+}*/
+size_t Bu::Socket::read( void *pBuf, size_t nBytes )
+{
+        int nRead = TEMP_FAILURE_RETRY( ::read( nSocket, pBuf, nBytes ) );
+        if( nRead < 0 )
+        {
+                throw ConnectionException( excodeReadError, strerror(errno) );
+        }
+        return nRead;
+}
+//size_t Bu::Socket::read( void *pBuf, size_t nBytes, uint32_t nTimeout )
+//{
+//}
+size_t Bu::Socket::write( const void *pBuf, size_t nBytes )
+{
+        int nWrote = TEMP_FAILURE_RETRY( ::write( nSocket, pBuf, nBytes ) );
+        if( nWrote < 0 )
+        {
+                throw ConnectionException( excodeWriteError, strerror(errno) );
+        }
+        return nWrote;
+}
+long Bu::Socket::tell()
+{
+        throw UnsupportedException();
+}
+void Bu::Socket::seek( long offset )
+{
+        throw UnsupportedException();
+}
+void Bu::Socket::setPos( long pos )
+{
+        throw UnsupportedException();
+}
+void Bu::Socket::setPosEnd( long pos )
+{
+        throw UnsupportedException();
+}
+bool Bu::Socket::isEOS()
+{
+        return !bActive;
+}
+bool Bu::Socket::canRead()
+{
+        fd_set rfds;
+        FD_ZERO(&rfds);
+        FD_SET(nSocket, &rfds);
+        struct timeval tv = { 0, 0 };
+        int retval = select( nSocket+1, &rfds, NULL, NULL, &tv );
+        if( retval == -1 )
+                throw ConnectionException(
+                        excodeBadReadError,
+                        "Bad Read error"
+                        );
+        if( !FD_ISSET( nSocket, &rfds ) )
+                return false;
+        return true;
+}
+bool Bu::Socket::canWrite()
+{
+        fd_set wfds;
+        FD_ZERO(&wfds);
+        FD_SET(nSocket, &wfds);
+        struct timeval tv = { 0, 0 };
+        int retval = select( nSocket+1, NULL, &wfds, NULL, &tv );
+        if( retval == -1 )
+                throw ConnectionException(
+                        excodeBadReadError,
+                        "Bad Read error"
+                        );
+        if( !FD_ISSET( nSocket, &wfds ) )
+                return false;
+        return true;
+}
+bool Bu::Socket::isReadable()
+{
+        return true;
+}
+bool Bu::Socket::isWritable()
+{
+        return true;
+}
+bool Bu::Socket::isSeekable()
+{
+        return false;
+}
+bool Bu::Socket::isBlocking()
+{
+        return false;
+}
+void Bu::Socket::setBlocking( bool bBlocking )
+{
+}
+void Bu::Socket::flush()
+{
+}
+bool Bu::Socket::isOpen()
+{
+        return bActive;
+}
+Bu::FString Bu::Socket::getAddress() const
+{
+        struct sockaddr_in addr;
+        socklen_t len = sizeof(addr);
+        addr.sin_family = AF_INET;
+        getsockname( nSocket, (sockaddr *)(&addr), &len );
+        char buf[150];
+        sprintf( buf, "%s", inet_ntoa( addr.sin_addr ) );
+        return buf;
+}
diff --git a/src/socket.h b/src/socket.h
new file mode 100644
index 0000000..c291549
--- /dev/null
+++ b/src/socket.h
@@ -0,0 +1,55 @@
+#ifndef BU_SOCKET_H
+#define BU_SOCKET_H
+#include <stdint.h>
+#include "stream.h"
+#include "fstring.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        class Socket : public Stream
+        {
+        public:
+                Socket( int nSocket );
+                Socket( const FString &sAddr, int nPort, int nTimeout=30 );
+                virtual ~Socket();
+                
+                virtual void close();
+                //virtual void read();
+                virtual size_t read( void *pBuf, size_t nBytes );
+                virtual size_t read( void *pBuf, size_t nBytes, uint32_t nTimeout );
+                virtual size_t write( const void *pBuf, size_t nBytes );
+                virtual long tell();
+                virtual void seek( long offset );
+                virtual void setPos( long pos );
+                virtual void setPosEnd( long pos );
+                virtual bool isEOS();
+                virtual bool isOpen();
+                virtual void flush();
+                virtual bool canRead();
+                virtual bool canWrite();
+                virtual bool isReadable();
+                virtual bool isWritable();
+                virtual bool isSeekable();
+                virtual bool isBlocking();
+                virtual void setBlocking( bool bBlocking=true );
+                Bu::FString getAddress() const;
+        private:
+                int nSocket;
+                bool bActive;
+                FString sReadBuf;
+        };
+}
+#endif
diff --git a/src/sptr.cpp b/src/sptr.cpp
index 7f5e894..8ea7f8f 100644
--- a/src/sptr.cpp
+++ b/src/sptr.cpp
@@ -1 +1 @@
-#include "sptr.h"
+#include "bu/sptr.h"
diff --git a/src/sptr.h b/src/sptr.h
index a3e6dc7..75851a6 100644
--- a/src/sptr.h
+++ b/src/sptr.h
@@ -1,144 +1,192 @@
-#ifndef SPTR_H
+#ifndef BU_SPTR_H
-#define SPTR_H
+#define BU_SPTR_H
 #include <stdint.h>
 #include <stdio.h>
-template<typename T> class SPtr;
+namespace Bu
-template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
-template<typename T>
-class SPtr
 {
-        template<typename Tb, typename Ta>
+        template<typename T> class SPtr;
-        friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src );
-public:
-        SPtr() :
+        template<typename T>
-                pRefCnt( NULL ),
+        class SPtr
-                pData( NULL )
+        {
-        {
+                template<typename Tb, typename Ta>
-        }
+                friend SPtr<Tb> SPtrCast( SPtr<Ta> pt );
+        public:
+                SPtr() :
+                        pRefCnt( NULL ),
+                        pData( NULL )
+                {
+                }
-        ~SPtr()
+                ~SPtr()
-        {
+                {
-                decCount();
+                        decCount();
-        }
+                }
-        SPtr( const SPtr<T> &src ) :
+                SPtr( const SPtr<T> &src ) :
-                pRefCnt( src.pRefCnt ),
+                        pRefCnt( src.pRefCnt ),
-                pData( src.pData )
+                        pData( src.pData )
-        {
+                {
-                if( pRefCnt )
+                        if( pRefCnt )
-                        (*pRefCnt) += 1;
+                                (*pRefCnt) += 1;
-        }
+                }
-        SPtr( T *pSrc ) :
+                SPtr( T *pSrc ) :
-                pRefCnt( NULL ),
+                        pRefCnt( NULL ),
-                pData( pSrc )
+                        pData( pSrc )
-        {
-                if( pData )
                {
-                        pRefCnt = new int32_t;
+                        if( pData )
-                        (*pRefCnt) = 1;
+                        {
+                                pRefCnt = new int32_t;
+                                (*pRefCnt) = 1;
+                        }
                }
-        }
-        int32_t count() const
+                /**
-        {
+                 * Get the number of references to this pointer.
-                return *pRefCnt;
+                 *@returns (int32_t) The number of references to this pointer.
-        }
+                 */
+                int32_t count() const
+                {
+                        return *pRefCnt;
+                }
-        const T *operator->() const
+                /**
-        {
+                 * Pointer access operator.
-                return pData;
+                 *@returns (const T *)
-        }
+                 */
+                const T *operator->() const
+                {
+                        return pData;
+                }
-        const T &operator*() const
+                /**
-        {
+                 * Dereference operator.
-                return *pData;
+                 *@returns (const T &) The value at the end of the pointer.
-        }
+                 */
-        
+                const T &operator*() const
-        T *operator->()
+                {
-        {
+                        return *pData;
-                return pData;
+                }
-        }
+                
+                /**
+                 * Pointer access operator.
+                 *@returns (T *)
+                 */
+                T *operator->()
+                {
+                        return pData;
+                }
-        T &operator*()
+                /**
-        {
+                 * Dereference operator.
-                return *pData;
+                 *@returns (T &) The value at the end of the pointer.
-        }
+                 */
+                T &operator*()
+                {
+                        return *pData;
+                }
-        SPtr<T> operator=( const SPtr<T> &src )
+                /**
-        {
+                 * Assignment operator.
-                decCount();
+                 *@param src (const SPtr<T> &)
-                pRefCnt = src.pRefCnt;
+                 */
-                pData = src.pData;
+                SPtr<T> operator=( const SPtr<T> &src )
-                if( pRefCnt )
+                {
-                        (*pRefCnt) += 1;
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
-                return *this;
+                        return *this;
-        }
+                }
-        const SPtr<T> operator=( const SPtr<T> &src ) const
+                /**
-        {
+                 * Assignment operator.
-                decCount();
+                 *@param src (const SPtr<T> &)
-                pRefCnt = src.pRefCnt;
+                 */
-                pData = src.pData;
+                const SPtr<T> operator=( const SPtr<T> &src ) const
-                if( pRefCnt )
+                {
-                        (*pRefCnt) += 1;
+                        decCount();
+                        pRefCnt = src.pRefCnt;
+                        pData = src.pData;
+                        if( pRefCnt )
+                                (*pRefCnt) += 1;
-                return *this;
+                        return *this;
-        }
+                }
-        bool operator==( const SPtr<T> &src ) const
+                /**
-        {
+                 * Equals comparison operator.
-                return pData == src.pData;
+                 *@param src (const SPtr<T> &) The SPtr to compare to.
-        }
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const SPtr<T> &src ) const
+                {
+                        return pData == src.pData;
+                }
-        bool operator==( const T *src ) const
+                /**
-        {
+                 * Equals comparison operator.
-                return pData == src;
+                 *@param src (const T *) The pointer to compare to.
-        }
+                 *@returns (bool) Are the equal?
+                 */
+                bool operator==( const T *src ) const
+                {
+                        return pData == src;
+                }
-        operator bool() const
+                /**
-        {
+                 * Boolean cast operator. Do we have a pointer?
-                return pRefCnt != NULL;
+                 */
-        }
+                operator bool() const
+                {
+                        return pRefCnt != NULL;
+                }
-        bool isSet() const
+                /**
-        {
+                 * Do we have a pointer?
-                return pRefCnt != NULL;
+                 *@returns (bool) Do we have a pointer?
-        }
+                 */
+                bool isSet() const
+                {
+                        return pRefCnt != NULL;
+                }
-private:
+        private:
-        void decCount() const
+                void decCount() const
-        {
-                if( pRefCnt )
                {
-                        (*pRefCnt) -= 1;
+                        if( pRefCnt )
-                        //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                        if( (*pRefCnt) == 0 )
                        {
-                                delete pRefCnt;
+                                (*pRefCnt) -= 1;
-                                delete pData;
+                                //printf("Decrementing ref-count to %d\n", *pRefCnt );
-                                pRefCnt = NULL;
+                                if( (*pRefCnt) == 0 )
-                                pData = NULL;
+                                {
+                                        delete pRefCnt;
+                                        delete pData;
+                                        pRefCnt = NULL;
+                                        pData = NULL;
+                                }
                        }
                }
-        }
-        mutable int32_t *pRefCnt;
+                mutable int32_t *pRefCnt;
-        mutable T *pData;
+                mutable T *pData;
-};
+        };
-template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
+        template< typename Tb, typename Ta > SPtr<Tb> SPtrCast( SPtr<Ta> src )
-{
+        {
-        SPtr<Tb> ret;
+                SPtr<Tb> ret;
-        ret.pRefCnt = src.pRefCnt;
+                ret.pRefCnt = src.pRefCnt;
-        ret.pData = dynamic_cast<Tb *>(src.pData);
+                ret.pData = dynamic_cast<Tb *>(src.pData);
-        if( ret.pRefCnt )
+                if( ret.pRefCnt )
-                (*(ret.pRefCnt)) += 1;
+                        (*(ret.pRefCnt)) += 1;
-        return ret;
+                return ret;
+        }
 }
 #endif
diff --git a/src/stream.cpp b/src/stream.cpp
index 856a58d..267a7d1 100644
--- a/src/stream.cpp
+++ b/src/stream.cpp
@@ -1,10 +1,10 @@
 #include "stream.h"
-Stream::Stream()
+Bu::Stream::Stream()
 {
 }
-Stream::~Stream()
+Bu::Stream::~Stream()
 {
 }
diff --git a/src/stream.h b/src/stream.h
index e086e28..1e236a6 100644
--- a/src/stream.h
+++ b/src/stream.h
@@ -1,27 +1,143 @@
-#ifndef STREAM_H
+#ifndef BU_STREAM_H
-#define STREAM_H
+#define BU_STREAM_H
 #include <stdint.h>
 #include <stdio.h>
-class Stream
+namespace Bu
 {
-public:
+        /**
-        Stream();
+         * The basis for a completely general data transport mechanism.  Anything
-        virtual ~Stream();
+         * that inherits from this should provide at least the basic read and/or
+         * write functions, and very probably the close function.  Any functions
+         * that aren't supported should throw an exception if called.
+         *
+         * The constructor of a child class should pretty much universally be used
+         * to open the stream.  I can't think of anything that should require an
+         * exception.
+         */
+        class Stream
+        {
+        public:
+                Stream();
+                virtual ~Stream();
-        virtual void close() = 0;
+                /**
-        virtual size_t read( char *pBuf, size_t nBytes ) = 0;
+                 * Close the stream.
-        virtual size_t write( const char *pBuf, size_t nBytes ) = 0;
+                 */
+                virtual void close() = 0;
-        virtual long tell() = 0;
+                /**
-        virtual void seek( long offset ) = 0;
+                 * Read data from the stream into a buffer.
-        virtual void setPos( long pos ) = 0;
+                 *@param pBuf (void *) Buffer which will be filled.
-        virtual void setPosEnd( long pos ) = 0;
+                 *@param nBytes (size_t) Max data to read.
-        virtual bool isEOS() = 0;
+                 *@returns (size_t) Amount of data read.
+                 */
+                virtual size_t read( void *pBuf, size_t nBytes ) = 0;
-private:
+                /**
+                 * Write data to the stream.
+                 *@param pBuf (const void *) The data to be written.
+                 *@param nBytes (size_t) Amount of data to write from pBuf.
+                 *@returns (size_t) Amount of data actually written.
+                 */
+                virtual size_t write( const void *pBuf, size_t nBytes ) = 0;
-};
+                /**
+                 * Get the current position in the stream.
+                 *@returns (long) The current position in the stream.
+                 */
+                virtual long tell() = 0;
+                /**
+                 * Seek to a position in the stream relative to the current position.
+                 *@param offset (long) Offset from current position to seek to.
+                 */
+                virtual void seek( long offset ) = 0;
+                /**
+                 * Set position in the stream relative to the start of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPos( long pos ) = 0;
+                /**
+                 * Set position in the stream relative to the end of the stream.
+                 *@param pos (long) The position.
+                 */
+                virtual void setPosEnd( long pos ) = 0;
+                /**
+                 * Are we at the end of the stream?
+                 *@returns (bool) Are we at the end of the stream?
+                 */
+                virtual bool isEOS() = 0;
+                /**
+                 * Is the stream open?
+                 *@returns (bool) Is the stream open?
+                 */
+                virtual bool isOpen() = 0;
+                /**
+                 * Flush any data still held in buffers.
+                 */
+                virtual void flush() = 0;
+                /**
+                 * In non-blocking streams this indicates if a read operation will
+                 * return data at the moment or not.  In blocking streams this should
+                 * return the same value as isEOS().
+                 */
+                virtual bool canRead() = 0;
+                /**
+                 * In non-blocking streams this indicates if a write operation will
+                 * succeed or fail.  In some cases writing is not allowed (e.g. 
+                 * internal buffers are full) temporarilly.  In blocking streams this
+                 * should return the same value as isWritable.
+                 */
+                virtual bool canWrite() = 0;
+                /**
+                 * Indicates if the stream is capable of read operations.  This does not
+                 * indicate if such operations will return useful data, see canRead for
+                 * that.
+                 */
+                virtual bool isReadable() = 0;
+                /**
+                 * Indicates if the stream is capable of write operations.  This does
+                 * not indicate if such operations will succeed or fail, see canWrite
+                 * for that.
+                 */
+                virtual bool isWritable() = 0;
+                /**
+                 * Indicates if the stream is capable of seek operations.  This is
+                 * generally false for non-blocking streams.  Some buffered streams may
+                 * support limited in-buffer seeking.
+                 */
+                virtual bool isSeekable() = 0;
+                /**
+                 * Are we currently set to block mode?
+                 *@returns (bool)
+                 */
+                virtual bool isBlocking() = 0;
+                /**
+                 * Set stream to blocking or non-blocking mode.
+                 *@param bBlocking (bool) Whether we should block or not.
+                 */
+                virtual void setBlocking( bool bBlocking=true ) = 0;
+        public: // Filters
+        private:
+        };
+}
 #endif
diff --git a/src/tafnode.cpp b/src/tafnode.cpp
new file mode 100644
index 0000000..53b782e
--- /dev/null
+++ b/src/tafnode.cpp
@@ -0,0 +1,165 @@
+#include "tafnode.h"
+Bu::TafNode::TafNode( NodeType eType ) :
+        eType( eType )
+{
+}
+Bu::TafNode::~TafNode()
+{
+}
+const Bu::TafNode::NodeType Bu::TafNode::getType() const
+{
+        return eType;
+}
+/*
+const Bu::TafNode::PropList &Bu::TafNode::getProperties( const Bu::FString &sName ) const
+{
+        return hProp.get( sName );
+}
+const Bu::TafNode::NodeList &Bu::TafNode::getChildren( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName );
+}
+const Bu::FString &Bu::TafNode::getProperty( const Bu::FString &sName ) const
+{
+        return getProperties( sName ).first();
+}
+const Bu::TafNode *Bu::TafNode::getChild( const Bu::FString &sName ) const
+{
+        return getChildren( sName ).first();
+}
+*/
+Bu::TafGroup::TafGroup( const Bu::FString &sName ) :
+        TafNode( typeGroup ),
+        sName( sName )
+{
+}
+Bu::TafGroup::~TafGroup()
+{
+        //printf("Entering Bu::TafNode::~TafNode() \"%s\"\n", sName.getStr() );
+        for( NodeList::iterator i = lChildren.begin(); i != lChildren.end(); i++ )
+        {
+                delete (*i);
+        }
+}
+const Bu::FString &Bu::TafGroup::getName() const
+{
+        return sName;
+}
+Bu::TafNode *Bu::TafGroup::addChild( Bu::TafNode *pNode )
+{
+        switch( pNode->getType() )
+        {
+                case typeGroup:
+                        addChild( (Bu::TafGroup *)pNode );
+                        break;
+                case typeProperty:
+                        addChild( (Bu::TafProperty *)pNode );
+                        break;
+                case typeComment:
+                        addChild( (Bu::TafComment *)pNode );
+                        break;
+        }
+        return pNode;
+}
+Bu::TafGroup *Bu::TafGroup::addChild( TafGroup *pNode )
+{
+        TafGroup *pGroup = (TafGroup *)pNode;
+        if( !hChildren.has( pGroup->getName() ) )
+                hChildren.insert( pGroup->getName(), GroupList() );
+        hChildren.get( pGroup->getName() ).append( pGroup );
+        lChildren.append( pNode );
+        return pNode;
+}
+Bu::TafProperty *Bu::TafGroup::addChild( TafProperty *pNode )
+{
+        TafProperty *pProperty = (TafProperty *)pNode;
+        if( !hProp.has( pProperty->getName() ) )
+                hProp.insert( pProperty->getName(), PropList() );
+        hProp.get( pProperty->getName() ).append( pProperty->getValue() );
+        lChildren.append( pNode );
+        return pNode;
+}
+Bu::TafComment *Bu::TafGroup::addChild( TafComment *pNode )
+{
+        lChildren.append( pNode );
+        return pNode;
+}
+const Bu::TafGroup::GroupList &Bu::TafGroup::getChildren( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName );
+}
+const Bu::TafGroup::NodeList &Bu::TafGroup::getChildren() const
+{
+        return lChildren;
+}
+const Bu::TafGroup *Bu::TafGroup::getChild( const Bu::FString &sName ) const
+{
+        return hChildren.get( sName ).first();
+}
+const Bu::TafGroup::PropList &Bu::TafGroup::getProperties( const Bu::FString &sName ) const
+{
+        return hProp.get( sName );
+}
+const Bu::FString &Bu::TafGroup::getProperty( const Bu::FString &sName ) const
+{
+        return hProp.get( sName ).first();
+}
+Bu::TafProperty::TafProperty( const Bu::FString &sName, const Bu::FString &sValue ) :
+        TafNode( typeProperty ),
+        sName( sName ),
+        sValue( sValue )
+{
+}
+Bu::TafProperty::~TafProperty()
+{
+}
+const Bu::FString &Bu::TafProperty::getName() const
+{
+        return sName;
+}
+const Bu::FString &Bu::TafProperty::getValue() const
+{
+        return sValue;
+}
+Bu::TafComment::TafComment( const Bu::FString &sText ) :
+        TafNode( typeComment ),
+        sText( sText )
+{
+}
+Bu::TafComment::~TafComment()
+{
+}
+const Bu::FString &Bu::TafComment::getText() const
+{
+        return sText;
+}
diff --git a/src/tafnode.h b/src/tafnode.h
new file mode 100644
index 0000000..cb4093f
--- /dev/null
+++ b/src/tafnode.h
@@ -0,0 +1,94 @@
+#ifndef BU_TAF_NODE_H
+#define BU_TAF_NODE_H
+#include <stdint.h>
+#include "bu/fstring.h"
+#include "bu/hash.h"
+#include "bu/list.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafNode
+        {
+        public:
+                enum NodeType
+                {
+                        typeGroup,
+                        typeProperty,
+                        typeComment
+                };
+        public:
+                TafNode( NodeType eType );
+                virtual ~TafNode();
+                const NodeType getType() const;
+        private:
+                NodeType eType;
+        };
+        class TafProperty;
+        class TafComment;
+        class TafGroup : public TafNode
+        {
+        public:
+                typedef Bu::List<Bu::FString> PropList;
+                typedef Bu::Hash<Bu::FString, PropList> PropHash;
+                typedef Bu::List<class Bu::TafGroup *> GroupList;
+                typedef Bu::Hash<Bu::FString, GroupList> GroupHash;
+                typedef Bu::List<class Bu::TafNode *> NodeList;
+                TafGroup( const Bu::FString &sName );
+                virtual ~TafGroup();
+                const Bu::FString &getName() const;
+                const Bu::FString &getProperty( const Bu::FString &sName ) const;
+                const PropList &getProperties( const Bu::FString &sName ) const;
+                const TafGroup *getChild( const Bu::FString &sName ) const;
+                const GroupList &getChildren( const Bu::FString &sName ) const;
+                TafNode *addChild( TafNode *pNode );
+                TafGroup *addChild( TafGroup *pNode );
+                TafProperty *addChild( TafProperty *pNode );
+                TafComment *addChild( TafComment *pNode );
+                const NodeList &getChildren() const;
+        private:
+                Bu::FString sName;
+                PropHash hProp;
+                GroupHash hChildren;
+                NodeList lChildren;
+        };
+        class TafProperty : public TafNode
+        {
+        public:
+                TafProperty( const Bu::FString &sName, const Bu::FString &sValue );
+                virtual ~TafProperty();
+                const Bu::FString &getName() const;
+                const Bu::FString &getValue() const;
+        private:
+                Bu::FString sName;
+                Bu::FString sValue;
+        };
+        class TafComment : public TafNode
+        {
+        public:
+                TafComment( const Bu::FString &sText );
+                virtual ~TafComment();
+                const Bu::FString &getText() const;
+        private:
+                Bu::FString sText;
+        };
+}
+#endif
diff --git a/src/tafreader.cpp b/src/tafreader.cpp
new file mode 100644
index 0000000..db465e9
--- /dev/null
+++ b/src/tafreader.cpp
@@ -0,0 +1,155 @@
+#include "bu/tafreader.h"
+#include "bu/exceptions.h"
+#include "bu/fstring.h"
+using namespace Bu;
+Bu::TafReader::TafReader( Bu::Stream &sIn ) :
+        c( 0 ),
+        sIn( sIn )
+{
+        next(); next();
+}
+Bu::TafReader::~TafReader()
+{
+}
+Bu::TafGroup *Bu::TafReader::readGroup()
+{
+        ws();
+        if( c != '{' )
+                throw TafException("Expected '{'");
+        next();
+        ws();
+        FString sName = readStr();
+        TafGroup *pGroup = new TafGroup( sName );
+        next();
+        //printf("Node[%s]:\n", sName.getStr() );
+        groupContent( pGroup );
+        if( c != '}' )
+                throw TafException("Expected '}'");
+        next();
+        return pGroup;
+}
+void Bu::TafReader::groupContent( Bu::TafGroup *pGroup )
+{
+        for(;;)
+        {
+                ws();
+                if( c == '{' )
+                        pGroup->addChild( readGroup() );
+                else if( c == '}' )
+                        return;
+                else if( c == '/' && la == '*' )
+                        pGroup->addChild( readComment() );
+                else
+                        pGroup->addChild( readProperty() );
+        }
+}
+Bu::TafProperty *Bu::TafReader::readProperty()
+{
+        FString sName = readStr();
+        ws();
+        if( c != '=' )
+        {
+                //printf("  %s (true)\n", sName.getStr() );
+                return new Bu::TafProperty( sName, "" );
+        }
+        next();
+        FString sValue = readStr();
+        return new Bu::TafProperty( sName, sValue );
+        //printf("  %s = %s\n", sName.getStr(), sValue.getStr() );
+}
+Bu::TafComment *Bu::TafReader::readComment()
+{
+        next();
+        FString sCmnt;
+        for(;;)
+        {
+                next();
+                if( c == '*' && la == '/' )
+                        break;
+                sCmnt += c;
+        }
+        return new TafComment( sCmnt );
+}
+Bu::FString Bu::TafReader::readStr()
+{
+        ws();
+        FString s;
+        if( c == '"' )
+        {
+                next();
+                for(;;)
+                {
+                        if( c == '\\' )
+                        {
+                                next();
+                                if( c == 'x' )
+                                {
+                                        char code[3]={'\0','\0','\0'};
+                                        next();
+                                        code[0] = c;
+                                        next();
+                                        code[1] = c;
+                                        c = (unsigned char)strtol( code, NULL, 16 );
+                                }
+                                else if( c == '"' )
+                                        c = '"';
+                                else
+                                        throw TafException("Invalid escape sequence.");
+                        }
+                        else if( c == '"' )
+                                break;
+                        s += c;
+                        next();
+                }
+                next();
+        }
+        else
+        {
+                for(;;)
+                {
+                        if( isws() || c == '}' || c == '{' || c == ':' || c == '=' )
+                                break;
+                        s += c;
+                        next();
+                }
+        }
+        return s;
+}
+void Bu::TafReader::ws()
+{
+        for(;;)
+        {
+                if( !isws() )
+                        return;
+                next();
+        }
+}
+bool Bu::TafReader::isws()
+{
+        return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
+}
+void Bu::TafReader::next()
+{
+        c = la;
+        sIn.read( &la, 1 );
+}
diff --git a/src/tafreader.h b/src/tafreader.h
new file mode 100644
index 0000000..eeaafb3
--- /dev/null
+++ b/src/tafreader.h
@@ -0,0 +1,35 @@
+#ifndef BU_TAF_READER_H
+#define BU_TAF_READER_H
+#include <stdint.h>
+#include "bu/tafnode.h"
+#include "bu/stream.h"
+#include "bu/fstring.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafReader
+        {
+        public:
+                TafReader( Bu::Stream &sIn );
+                virtual ~TafReader();
+                Bu::TafGroup *readGroup();
+        private:
+                void groupContent( Bu::TafGroup *pNode );
+                Bu::TafProperty *readProperty();
+                Bu::TafComment *readComment();
+                void ws();
+                bool isws();
+                void next();
+                Bu::FString readStr();
+                char c, la;
+                Bu::Stream &sIn;
+        };
+}
+#endif
diff --git a/src/tafwriter.cpp b/src/tafwriter.cpp
new file mode 100644
index 0000000..6b505ef
--- /dev/null
+++ b/src/tafwriter.cpp
@@ -0,0 +1,70 @@
+#include "tafwriter.h"
+Bu::TafWriter::TafWriter( Bu::Stream &sOut ) :
+        sOut( sOut )
+{
+}
+Bu::TafWriter::~TafWriter()
+{
+}
+void Bu::TafWriter::writeGroup( const Bu::TafGroup *pRoot )
+{
+        sOut.write("{", 1 );
+        writeString( pRoot->getName() );
+        sOut.write(": ", 2 );
+        const Bu::TafGroup::NodeList &nl = pRoot->getChildren();
+        for( Bu::TafGroup::NodeList::const_iterator i = nl.begin(); i != nl.end(); i++ )
+        {
+                switch( (*i)->getType() )
+                {
+                        case Bu::TafNode::typeGroup:
+                                writeGroup( (Bu::TafGroup *)(*i) );
+                                break;
+                        case Bu::TafNode::typeProperty:
+                                writeProperty( (Bu::TafProperty *)(*i) );
+                                break;
+                        case Bu::TafNode::typeComment:
+                                writeComment( (Bu::TafComment *)(*i) );
+                                break;
+                }
+        }
+        sOut.write("}", 1 );
+}
+void Bu::TafWriter::writeProperty( const Bu::TafProperty *pProp )
+{
+        writeString( pProp->getName() );
+        if( pProp->getValue().getStr() != NULL )
+        {
+                sOut.write("=", 1 );
+                writeString( pProp->getValue() );
+        }
+        sOut.write(" ", 1 );
+}
+void Bu::TafWriter::writeComment( const Bu::TafComment *pComment )
+{
+        sOut.write("/*", 2 );
+        sOut.write( pComment->getText().getStr(), pComment->getText().getSize() );
+        sOut.write("*/ ", 3 );
+}
+void Bu::TafWriter::writeString( const Bu::FString &str )
+{
+        if( str.getStr() == NULL )
+                return;
+        sOut.write("\"", 1 );
+        for( const char *s = str.getStr(); *s; s++ )
+        {
+                if( *s == '\"' )
+                        sOut.write("\\\"", 2 );
+                else
+                        sOut.write( s, 1 );
+        }
+        sOut.write("\"", 1 );
+}
diff --git a/src/tafwriter.h b/src/tafwriter.h
new file mode 100644
index 0000000..5f80504
--- /dev/null
+++ b/src/tafwriter.h
@@ -0,0 +1,30 @@
+#ifndef BU_TAF_WRITER_H
+#define BU_TAF_WRITER_H
+#include <stdint.h>
+#include "bu/tafnode.h"
+#include "bu/stream.h"
+#include "bu/fstring.h"
+namespace Bu
+{
+        /**
+         *
+         */
+        class TafWriter
+        {
+        public:
+                TafWriter( Bu::Stream &sOut );
+                virtual ~TafWriter();
+                void writeGroup( const Bu::TafGroup *pRoot );
+        private:
+                void writeProperty( const Bu::TafProperty *pProp );
+                void writeComment( const Bu::TafComment *pComment );
+                void writeString( const Bu::FString &str );
+                Bu::Stream &sOut;
+        };
+}
+#endif
diff --git a/src/tests/archive.cpp b/src/tests/archive.cpp
new file mode 100644
index 0000000..2035aa6
--- /dev/null
+++ b/src/tests/archive.cpp
@@ -0,0 +1,16 @@
+#include "archive.h"
+#include "file.h"
+using namespace Bu;
+int main()
+{
+        File f("test.dat", "wb");
+        Archive ar( f, Archive::save );
+        std::string s("Hello there");
+        ar << s;
+        return 0;
+}
diff --git a/src/tests/atom.cpp b/src/tests/atom.cpp
new file mode 100644
index 0000000..2077bfd
--- /dev/null
+++ b/src/tests/atom.cpp
@@ -0,0 +1,25 @@
+#include "bu/atom.h"
+#include <stdio.h>
+#include <stdlib.h>
+typedef struct bob
+{
+        int a, b;
+} bob;
+int main()
+{
+        Bu::Atom<int> aInt;
+        Bu::Atom<char *> aStr;
+        Bu::Atom<bob> aBob;
+        aBob = bob();
+        aBob->a = 5;
+        aStr.set("Hey there, dude");
+        aInt.set( 55 );
+        int me = aInt;
+        aInt = 12;
+        printf("%d, %d\n", aInt.get(), me );
+        printf("%s\n", aStr.get() );
+}
diff --git a/src/tests/bzip2.cpp b/src/tests/bzip2.cpp
new file mode 100644
index 0000000..683d3d7
--- /dev/null
+++ b/src/tests/bzip2.cpp
@@ -0,0 +1,23 @@
+#include "bu/bzip2.h"
+#include "bu/file.h"
+int main( int argc, char *argv[] )
+{
+        char buf[1024];
+        size_t nRead;
+        Bu::File f( "test.bz2", "wb" );
+        Bu::BZip2 bz2( f );
+        Bu::File fin( argv[1], "rb");
+        for(;;)
+        {
+                nRead = fin.read( buf, 1024 );
+                if( nRead > 0 )
+                        bz2.write( buf, nRead );
+                if( fin.isEOS() )
+                        break;
+        }
+}
diff --git a/src/tests/constsptr.cpp b/src/tests/constsptr.cpp
deleted file mode 100644
index e6f87c7..0000000
--- a/src/tests/constsptr.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-#include <stdio.h>
-#include "sptr.h"
-template <typename T>
-class DataBase
-{
-public:
-        DataBase():
-                _bHas(false)
-        {
-        }
-        
-        virtual ~DataBase()
-        {
-                clr();
-        }
-        
-        virtual bool has() const
-        {
-                return _bHas;
-        }
-        
-        virtual void clr()
-        {
-                _bHas = false;
-        }
-        virtual void set(T d)
-        {
-                _tVal = d;
-                _bHas = true;
-        }
-        virtual T const &get() const
-        {
-                if(!has())
-                        throw "no data";
-                return _tVal;
-        }
-        virtual T &get()
-        {
-                if(!has())
-                        throw "no data";
-                return _tVal;
-        }
-        
-protected:
-        bool _bHas;
-        T _tVal;
-};
-class Test
-{
-public:
-        Test(){};
-        virtual ~Test(){};
-        void set(int i)
-        {
-                _i = i;
-        }
-        
-        int get() const
-        {
-                return _i;
-        }
-        
-private:
-        int _i;
-};
-int main()
-{
-        typedef SPtr<Test> TestPtr;
-        TestPtr t1(new Test);
-        t1->set(42);
-        printf("t1: %d.\n", t1->get());
-        const TestPtr t2 = t1;
-        printf("t2: %d.\n", t2->get());
-        typedef DataBase<const TestPtr> DBTP;
-        DBTP db;
-        db.set(t1);
-        printf("dbt1: %d.\n", db.get()->get());
-}
diff --git a/src/tests/constsptr2.cpp b/src/tests/constsptr2.cpp
deleted file mode 100644
index 8ccb20c..0000000
--- a/src/tests/constsptr2.cpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "sptr.h"
-void nonsptr()
-{
-        int a = 5;
-        int b = 10;
-        const int *p = &a;
-        p = &b;
-        printf("p = %d\n", (*p) );
-        //(*p)++;
-}
-void sptr()
-{
-        int a = 5;
-        int b = 10;
-        const SPtr<int> p = new int(a);
-        p = new int(b);
-        printf("p = %d\n", (*p) );
-        //(*p)++;
-}
-int main()
-{
-        printf("Non-sptr:\n");
-        nonsptr();
-        printf("sptr:\n");
-        sptr();
-}
diff --git a/src/tests/fstring.cpp b/src/tests/fstring.cpp
index 271738c..48dfc5f 100644
--- a/src/tests/fstring.cpp
+++ b/src/tests/fstring.cpp
@@ -1,9 +1,28 @@
-#include "hash.h"
+#include "bu/hash.h"
-#include "fstring.h"
+#include "bu/fstring.h"
+#include <sys/time.h>
+#include <string>
-FString genThing()
+#ifndef WIN32
+inline double getTime()
 {
-        FString bob;
+        struct timeval tv;
+        gettimeofday( &tv, NULL );
+        return ((double)tv.tv_sec) + ((double)tv.tv_usec/1000000.0);
+}
+#else
+#include "windows.h"
+#include "winbase.h"
+inline double getTime()
+{
+       uint32_t t = (uint32_t) GetTickCount();
+       return (double) t / 1000.0;
+}
+#endif
+Bu::FString genThing()
+{
+        Bu::FString bob;
        bob.append("ab ");
        bob += "cd ";
        bob += "efg";
@@ -12,20 +31,91 @@ FString genThing()
        return bob;
 }
-void thing( FString str )
+void thing( Bu::FString str )
 {
        printf("Hey:  %s\n", str.c_str() );
 }
+void copyfunc( std::string temp )
+{
+        temp += "Hi";
+}
+void copyfunc( Bu::FString temp )
+{
+        temp += "Hi";
+}
+void doTimings()
+{
+        Bu::FString fs1, fs2;
+        std::string ss1, ss2;
+        double dStart, dEnd, tfs1, tfs2, tfs3, tss1, tss2, tss3;
+        int nChars = 500000, nChunks=5000, nCopies=5000000, nChunkSize=1024*4;
+        char *buf = new char[nChunkSize];
+        memset( buf, '!', nChunkSize );
+        printf("Timing Bu::FString single chars...\n");
+        dStart = getTime();
+        for( int j = 0; j < nChars; j++ ) fs1 += (char)('a'+(j%26));
+        fs1.getStr();
+        dEnd = getTime();
+        tfs1 = dEnd-dStart;
+        printf("Timing std::string single chars...\n");
+        dStart = getTime();
+        for( int j = 0; j < nChars; j++ ) ss1 += (char)('a'+(j%26));
+        ss1.c_str();
+        dEnd = getTime();
+        tss1 = dEnd-dStart;
+        printf("Timing Bu::FString %d char chunks...\n", nChunkSize);
+        dStart = getTime();
+        for( int j = 0; j < nChunks; j++ ) fs2.append(buf, nChunkSize);
+        fs2.getStr();
+        dEnd = getTime();
+        tfs2 = dEnd-dStart;
+        printf("Timing std::string %d char chunks...\n", nChunkSize);
+        dStart = getTime();
+        for( int j = 0; j < nChunks; j++ ) ss2.append(buf, nChunkSize);
+        ss2.c_str();
+        dEnd = getTime();
+        tss2 = dEnd-dStart;
+        fs2 = "Hello there.";
+        ss2 = "Hello there.";
+        printf("Timing Bu::FString copies...\n");
+        dStart = getTime();
+        for( int j = 0; j < nCopies; j++ ) Bu::FString stmp = fs2;
+        dEnd = getTime();
+        tfs3 = dEnd-dStart;
+        printf("Timing std::string copies...\n");
+        dStart = getTime();
+        for( int j = 0; j < nCopies; j++ ) std::string stpm = ss2;
+        dEnd = getTime();
+        tss3 = dEnd-dStart;
+        printf(
+                "Results:       singles:        chunks:         copies:\n"
+                "Bu::FString    %10.2f/s   %10.2f/s   %10.2f/s\n"
+                "std::string    %10.2f/s   %10.2f/s   %10.2f/s\n",
+                nChars/tfs1, nChunks/tfs2, nCopies/tfs3,
+                nChars/tss1, nChunks/tss2, nCopies/tss3 );
+        delete[] buf;
+}
 #define pem printf("---------\n%08X: %s\n%08X: %s\n", (unsigned int)str.c_str(), str.c_str(), (unsigned int)str2.c_str(), str2.c_str() );
 int main( int argc, char *argv )
 {
-        FString str("th");
+        Bu::FString str("th");
        str.prepend("Hello ");
        str.append("ere.");
-        FString str2( str );
+        Bu::FString str2( str );
        pem;
        str += "  What's up?";
        pem;
@@ -43,6 +133,8 @@ int main( int argc, char *argv )
        thing( str2 );
        thing("test.");
        
-        printf("%d == %d\n", __calcHashCode( str ), __calcHashCode( str.c_str() ) );
+        printf("%d == %d\n", Bu::__calcHashCode( str ), Bu::__calcHashCode( str.c_str() ) );
+        doTimings();
 }
diff --git a/src/tests/hash.cpp b/src/tests/hash.cpp
index 2fc6968..73cfb27 100644
--- a/src/tests/hash.cpp
+++ b/src/tests/hash.cpp
@@ -1,116 +1,24 @@
-#include "hash.h"
+#include "bu/hash.h"
-#include "staticstring.h"
+#include "bu/sptr.h"
-int main()
+typedef struct Bob
 {
-        const char *names[]={
+        int nID;
-                "Homer the Great",
+} Bob;
-                "And Maggie Makes Three",
-                "Bart's Comet",
-                "Homie The Clown",
-                "Bart Vs Australia",
-                "Homer vs Patty and Selma",
-                "A star is burns",
-                "Lisa's Wedding",
-                "Two Dozen and One Greyhounds",
-                "The PTA Disbands",
-                "Round Springfield",
-                "The Springfield connection",
-                "Lemon of Troy",
-                "Who Shot Mr. Burns (Pt. 1)",
-                "Who Shot Mr. Burns (pt. 2)",
-                "Radioactive Man",
-                "Home Sweet Homediddly-dum-doodly",
-                "Bart Sells His Soul",
-                "Lisa the Vegetarian",
-                "Treehouse of horror VI",
-                "King Size Homer",
-                "Mother Simpson",
-                "Sideshow Bob's Last Gleaming",
-                "The Simpson's 138th Show Spectacular",
-                "Marge Be Not Proud",
-                "Team Homer",
-                "Two Bad Neighbors",
-                "Scenes From the Class Struggle in Springfield",
-                "Bart the Fink",
-                "Lisa the Iconoclast",
-                "Homer the Smithers",
-                "The Day the Violence Died",
-                "A Fish Called Selma",
-                "Bart on the road",
-                "22 Short Films about Springfield",
-                "The Curse of the Flying Hellfish",
-                "Much Apu about Nothing",
-                "Homerpalooza",
-                "The Summer of 4 Ft 2",
-                "Treehouse of Horror VII",
-                "You Only Move Twice",
-                "The Homer They Fall",
-                "Burns Baby Burns",
-                "Bart After Dark",
-                "A Millhouse Divided",
-                "Lisas Date With Destiny",
-                "Hurricane Neddy",
-                "The Mysterious Voyage of Our Homer",
-                "The Springfield Files",
-                "The Twisted World of Marge Simpson",
-                "Mountain of Madness",
-                NULL
-        };
-        Hash<const char *, int> sTest;
-        printf("Inserting\n-------------------\n\n");
-        for( int j = 0; j < 33; j++ )
-        {
-                sTest[names[j]] = j;
-        }
-        
-        printf("Test1: %d, Test2: %d\n", sTest.has("Lemon of Troy"), sTest.has(std::string("Lemon of Troy").c_str() ) );
-        sTest.has(std::string("Lemon of Troy").c_str() );
-        printf("Getting\n-------------------\n\n");
-        sTest.erase("Homer the Great");
-        sTest["Bart's Comet"].erase();
-        for( Hash<const char *, int>::iterator i = sTest.begin();
+int main()
-                 i != sTest.end(); i++ )
+{
-        {
+        Bu::Hash<int, Bu::SPtr<const Bob> > lb;
-                Hash<const char *, int>::iterator j = i;
+        for( int j = 0; j < 10; j++ )
-                printf("%d: %s\n", (*j).second, (*j).first );
-        }
-        printf("Testing\n-------------------\n\n");
-        for( int j = 0; j < 33; j++ )
        {
-                if( sTest.has(names[j]) )
+                Bob *b = new Bob;
-                {
+                b->nID = j;
-                        if( sTest[names[j]] != j )
+                lb.insert( j, b );
-                        {
-                                printf("'%s' should be %d, is %d\n",
-                                        names[j], j,
-                                        sTest[names[j]].value()
-                                        );
-                        }
-                }
-                else
-                {
-                        printf("Missing element %d, '%s'\n", j, names[j] );
-                }
        }
-        printf("Clearing\n-------------------\n\n");
+        for( int j = 0; j < 10; j++ )
-        sTest.clear();
-        
-        for( Hash<const char *, int>::iterator i = sTest.begin();
-                 i != sTest.end(); i++ )
        {
-                Hash<const char *, int>::iterator j = i;
+                printf("%d\n", lb[j].value()->nID );
-                printf("%d: %s\n", (*j).second, (*j).first );
        }
 }
diff --git a/src/tests/itoqueue1.cpp b/src/tests/itoqueue1.cpp
new file mode 100644
index 0000000..f73f4d3
--- /dev/null
+++ b/src/tests/itoqueue1.cpp
@@ -0,0 +1,110 @@
+#include <string>
+#include "bu/ito.h"
+#include "bu/itoqueue.h"
+class Reader : public Bu::Ito
+{
+public:
+        Reader( Bu::ItoQueue<std::string *> &q, int id ) :
+                q( q ),
+                id( id )
+        {
+        }
+        void *run()
+        {
+                for( int i = 0; i < 10; i++ )
+                {
+                        std::string *pStr = q.dequeue( true );
+                        if( pStr == NULL )
+                        {
+                                printf("Null received...\n");
+                        }
+                        else
+                        {
+                                printf("[%d] read:  %s\n", id, pStr->c_str() );
+                                delete pStr;
+                        }
+                        usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) );
+                }
+                return NULL;
+        }
+private:
+        Bu::ItoQueue<std::string *> &q;
+        int id;
+};
+class Writer : public Bu::Ito
+{
+public:
+        Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) :
+                q( q ),
+                strbase( strbase ),
+                id( id )
+        {
+        }
+        void *run()
+        {
+                for( int i = 0; i < 11; i++ )
+                {
+                        usleep( (int)(((double)rand())/((double)RAND_MAX)*2000000.0) );
+                        q.enqueue( new std::string( strbase ) );
+                        printf("[%d] write: %s\n", id, strbase );
+                }
+                return NULL;
+        }
+private:
+        Bu::ItoQueue<std::string *> &q;
+        const char *strbase;
+        int id;
+};
+int main()
+{
+        Writer *wr[5];
+        Reader *rd[5];
+        const char bob[][7]={
+                {"Test 1"},
+                {"Test 2"},
+                {"Test 3"},
+                {"Test 4"},
+                {"Test 5"}
+        };
+        Bu::ItoQueue<std::string *> q;
+        for( int j = 0; j < 5; j++ )
+        {
+                wr[j] = new Writer( q, j, bob[j] );
+                rd[j] = new Reader( q, j );
+        }
+        for( int j = 0; j < 5; j++ )
+        {
+                rd[j]->start();
+        }
+        for( int j = 0; j < 5; j++ )
+        {
+                wr[j]->start();
+        }
+        for( int j = 0; j < 5; j++ )
+        {
+                rd[j]->join();
+        }
+        for( int j = 0; j < 5; j++ )
+        {
+                delete wr[j];
+                delete rd[j];
+        }
+        return 0;
+}
diff --git a/src/tests/itoqueue2.cpp b/src/tests/itoqueue2.cpp
new file mode 100644
index 0000000..f4b5e19
--- /dev/null
+++ b/src/tests/itoqueue2.cpp
@@ -0,0 +1,83 @@
+#include <string>
+#include "bu/ito.h"
+#include "bu/itoqueue.h"
+#include <errno.h>
+class Reader : public Bu::Ito
+{
+public:
+        Reader( Bu::ItoQueue<std::string *> &q, int id ) :
+                q( q ),
+                id( id )
+        {
+        }
+        void *run()
+        {
+                for( int i = 0; i < 10; i++ )
+                {
+                        std::string *pStr = q.dequeue( 0, 500000 );
+                        if( pStr == NULL )
+                        {
+                                printf("Null received...\n");
+                                i--;
+                        }
+                        else
+                        {
+                                printf("[%d] read:  %s\n", id, pStr->c_str() );
+                                delete pStr;
+                        }
+                }
+                return NULL;
+        }
+private:
+        Bu::ItoQueue<std::string *> &q;
+        int id;
+};
+class Writer : public Bu::Ito
+{
+public:
+        Writer( Bu::ItoQueue<std::string *> &q, int id, const char *strbase ) :
+                q( q ),
+                strbase( strbase ),
+                id( id )
+        {
+        }
+        void *run()
+        {
+                for( int i = 0; i < 11; i++ )
+                {
+                        sleep( 2 );
+                        printf("[%d] write: %s\n", id, strbase );
+                        q.enqueue( new std::string( strbase ) );
+                }
+                return NULL;
+        }
+private:
+        Bu::ItoQueue<std::string *> &q;
+        const char *strbase;
+        int id;
+};
+int main()
+{
+        printf("ETIMEDOUT: %d\n", ETIMEDOUT );
+        Bu::ItoQueue<std::string *> q;
+        Writer wr( q, 0, "writer" );
+        Reader rd( q, 0 );
+        rd.start();
+        wr.start();
+        rd.join();
+        wr.join();
+        return 0;
+}
diff --git a/src/tests/list.cpp b/src/tests/list.cpp
new file mode 100644
index 0000000..12807a5
--- /dev/null
+++ b/src/tests/list.cpp
@@ -0,0 +1,53 @@
+#include "bu/list.h"
+#include <list>
+typedef struct Bob
+{
+        int nID;
+} Bob;
+int main()
+{
+        Bu::List<int> l;
+        l.append( 0 );
+        for( int j = 3; j <= 21; j += 3 )
+        {
+                l.append( j );
+                l.prepend( -j );
+        }
+        for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+                printf("%d ", *i );
+        }
+        printf("\n");
+        for( Bu::List<int>::iterator i = l.begin(); i != l.end(); i++ )
+        {
+                l.erase( i );
+                if( i != l.end() )
+                        printf("%d ", *i );
+        }
+        printf("\n\n");
+        Bu::List<Bob> lb;
+        for( int j = 0; j < 10; j++ )
+        {
+                Bob b;
+                b.nID = j;
+                lb.append( b );
+        }
+        const Bu::List<Bob> rb = lb;
+        for( Bu::List<Bob>::const_iterator i = rb.begin(); i != rb.end(); i++ )
+        {
+                //i->nID += 2;
+                //(*i).nID = 4;
+                printf("%d ", i->nID );
+        }
+        printf("\n\n");
+}
diff --git a/src/tests/logger.cpp b/src/tests/logger.cpp
new file mode 100644
index 0000000..290f479
--- /dev/null
+++ b/src/tests/logger.cpp
@@ -0,0 +1,28 @@
+#include "bu/logger.h"
+#include <errno.h>
+#include <stdlib.h>
+class Thing
+{
+        public:
+                Thing()
+                {
+                        lineLog( 2, "Want a thing?");
+                }
+                void go( int i )
+                {
+                        lineLog( 1, "GO!!!!");
+                }
+};
+int main()
+{
+        setLogLevel( 4 );
+        setLogFormat("%L: %y-%02m-%02d %h:%02M:%02s %f:%l:%F: %t");
+        lineLog( 5, "Hey, error: %s", strerror( errno ) );
+        Thing gh;
+        gh.go( 6);
+}
diff --git a/src/tests/ringbuffer.cpp b/src/tests/ringbuffer.cpp
new file mode 100644
index 0000000..259ec1f
--- /dev/null
+++ b/src/tests/ringbuffer.cpp
@@ -0,0 +1,29 @@
+#include "bu/ringbuffer.h"
+#include <stdlib.h>
+int main()
+{
+        Bu::RingBuffer<uint32_t> ibuf( 10 );
+        for( int k = 0; k < 2; k++ )
+        {
+                int j = 1;
+                for(; j < 7; j++ )
+                {
+                        ibuf.enqueue( j );
+                }
+                for(; j < 20; j++ )
+                {
+                        ibuf.enqueue( j );
+                        printf("- %d\n", ibuf.dequeue() );
+                }
+                for(;;)
+                {
+                        if( ibuf.isEmpty() ) break;
+                        printf(". %d\n", ibuf.dequeue() );
+                }
+        }
+}
diff --git a/src/tests/taf.cpp b/src/tests/taf.cpp
new file mode 100644
index 0000000..e3da120
--- /dev/null
+++ b/src/tests/taf.cpp
@@ -0,0 +1,24 @@
+#include "bu/tafreader.h"
+#include "bu/tafwriter.h"
+#include "bu/file.h"
+int main()
+{
+        Bu::File f("test.taf", "rb");
+        Bu::TafReader tr( f );
+        Bu::TafGroup *pGroup = tr.readGroup();
+        const Bu::TafGroup *pStats = pGroup->getChild("stats");
+        printf("%s\n", pStats->getName().getStr() );
+        printf("  str = %s\n", pStats->getProperty("str").getStr() );
+        {
+                Bu::File fo("out.taf", "wb");
+                Bu::TafWriter tw( fo );
+                tw.writeGroup( pGroup );
+        }
+        delete pGroup;
+}
diff --git a/src/unit/entities/unit b/src/unit/entities/unit
new file mode 100644
index 0000000..28db45f
--- /dev/null
+++ b/src/unit/entities/unit
@@ -0,0 +1,30 @@
+<?xml version="1.1" ?>
+<entity desc="Unit test framework">
+        <param name="name" required="yes" desc="Name of the class"/>
+        <file
+                name="source"
+                filename="{=name:%tolower}.cpp"
+>#include "bu/unitsuite.h"
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("{=name}");
+                addTest( Unit::test01 );
+        }
+        virtual ~Unit()
+        {
+        }
+        void test01()
+        {
+                unitTest( 0 == 5 );
+        }
+};
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }
+</file>
+</entity>
diff --git a/src/unit/file.cpp b/src/unit/file.cpp
new file mode 100644
index 0000000..1eaaf36
--- /dev/null
+++ b/src/unit/file.cpp
@@ -0,0 +1,111 @@
+#include "unitsuite.h"
+#include "file.h"
+#include "exceptions.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("File");
+                addTest( Unit::writeFull );
+                addTest( Unit::readBlocks );
+                addTest( Unit::readError1 );
+                addTest( Unit::readError2 );
+        }
+        virtual ~Unit() { }
+        //
+        // Tests go here
+        //
+        void writeFull()
+        {
+                Bu::File sf("testfile1", "wb");
+                for( int c = 0; c < 256; c++ )
+                {
+                        unsigned char ch = (unsigned char)c;
+                        sf.write( &ch, 1 );
+                        unitTest( sf.tell() == c+1 );
+                }
+                //unitTest( sf.canRead() == false );
+                //unitTest( sf.canWrite() == true );
+                //unitTest( sf.canSeek() == true );
+                sf.close();
+                struct stat sdat;
+                stat("testfile1", &sdat );
+                unitTest( sdat.st_size == 256 );
+        }
+        void readBlocks()
+        {
+                Bu::File sf("testfile1", "rb");
+                unsigned char buf[50];
+                size_t total = 0;
+                for(;;)
+                {
+                        size_t s = sf.read( buf, 50 );
+                        for( size_t c = 0; c < s; c++ )
+                        {
+                                unitTest( buf[c] == (unsigned char)(c+total) );
+                        }
+                        total += s;
+                        if( s < 50 )
+                        {
+                                unitTest( total == 256 );
+                                unitTest( sf.isEOS() == true );
+                                break;
+                        }
+                }
+                sf.close();
+        }
+        void readError1()
+        {
+                try
+                {
+                        Bu::File sf("doesn'texist", "rb");
+                        unitFailed("No exception thrown");
+                }
+                catch( Bu::FileException &e )
+                {
+                        return;
+                }
+        }
+        void readError2()
+        {
+                Bu::File sf("testfile1", "rb");
+                char buf[256];
+                int r = sf.read( buf, 256 );
+                unitTest( r == 256 );
+                // You have to read past the end to set the EOS flag.
+                unitTest( sf.isEOS() == false );
+                try
+                {
+                        if( sf.read( buf, 5 ) > 0 )
+                        {
+                                unitFailed("Non-zero read result");
+                        }
+                        else
+                        {
+                                sf.close();
+                        }
+                }
+                catch( Bu::FileException &e )
+                {
+                        sf.close();
+                        return;
+                }
+        }
+};
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
diff --git a/src/unit/fstring.cpp b/src/unit/fstring.cpp
new file mode 100644
index 0000000..72755eb
--- /dev/null
+++ b/src/unit/fstring.cpp
@@ -0,0 +1,28 @@
+#include "fstring.h"
+#include "unitsuite.h"
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("FString");
+                addTest( Unit::test1 );
+        }
+        virtual ~Unit()
+        {
+        }
+        void test1()
+        {
+                unitTest( 1 == 1 );
+                unitTest( 1 == 0 );
+        }
+};
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
diff --git a/src/unit/hash.cpp b/src/unit/hash.cpp
new file mode 100644
index 0000000..9ea933f
--- /dev/null
+++ b/src/unit/hash.cpp
@@ -0,0 +1,40 @@
+#include "bu/fstring.h"
+#include "bu/hash.h"
+#include "bu/unitsuite.h"
+#include <stdio.h>
+class Unit : public Bu::UnitSuite
+{
+private:
+        typedef Bu::Hash<Bu::FString, int> StrIntHash;
+public:
+        Unit()
+        {
+                setName("Hash");
+                addTest( Unit::test_probe );
+        }
+        virtual ~Unit()
+        {
+        }
+        void test_probe()
+        {
+                StrIntHash h;
+                char buf[20];
+                for(int i=1;i<10000;i++)
+                {
+                        sprintf(buf,"%d",i);
+                        Bu::FString sTmp(buf);
+                        h[sTmp] = i;
+                        unitTest( h.has(sTmp) );
+                }
+        }
+};
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
diff --git a/src/unit/membuf.cpp b/src/unit/membuf.cpp
new file mode 100644
index 0000000..65ba82a
--- /dev/null
+++ b/src/unit/membuf.cpp
@@ -0,0 +1,37 @@
+#include "bu/unitsuite.h"
+#include "bu/membuf.h"
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("MemBuf");
+                addTest( Unit::testWriteRead01 );
+        }
+        virtual ~Unit()
+        {
+        }
+        void testWriteRead01()
+        {
+                Bu::MemBuf mb;
+                unitTest( mb.write("ab", 2 ) == 2 );
+                unitTest( mb.write("cde", 3 ) == 3 );
+                unitTest( mb.write("FG", 2 ) == 2 );
+                mb.setPos( 0 );
+                char buf[8];
+                buf[7] = '\0';
+                unitTest( mb.read( buf, 7 ) == 7 );
+                unitTest( !strncmp( buf, "abcdeFG", 7 ) );
+                unitTest( mb.read( buf, 7 ) == 0 );
+                mb.seek( -3 );
+                unitTest( mb.read( buf, 7 ) == 3 );
+                unitTest( !strncmp( buf, "eFG", 3 ) );
+        }
+};
+int main( int argc, char *argv[] ){ return Unit().run( argc, argv ); }
diff --git a/src/unit/taf.cpp b/src/unit/taf.cpp
new file mode 100644
index 0000000..5e0e914
--- /dev/null
+++ b/src/unit/taf.cpp
@@ -0,0 +1,48 @@
+#include "unitsuite.h"
+#include "file.h"
+#include "tafreader.h"
+#include <string.h>
+#include <unistd.h>
+class Unit : public Bu::UnitSuite
+{
+public:
+        Unit()
+        {
+                setName("taf");
+                addTest( Unit::read1 );
+        }
+        virtual ~Unit()
+        {
+        }
+        void read1()
+        {
+#define FN_TMP ("/tmp/tmpXXXXXXXX")
+                Bu::FString sFnTmp(FN_TMP);
+                Bu::File fOut = Bu::File::tempFile( sFnTmp, "wb" );
+                const char *data =
+"{test: name=\"Bob\"}"
+;
+                fOut.write(data,strlen(data));
+                fOut.close();
+                Bu::File fIn(sFnTmp.c_str(), "rb");
+                Bu::TafReader tr(fIn);
+                
+                Bu::TafGroup *tn = tr.readGroup();
+                unitTest( !strcmp("Bob", tn->getProperty("name").c_str()) );
+                delete tn;
+                unlink(sFnTmp.c_str());
+#undef FN_TMP
+        }
+};
+int main( int argc, char *argv[] )
+{
+        return Unit().run( argc, argv );
+}
diff --git a/src/unitsuite.cpp b/src/unitsuite.cpp
new file mode 100644
index 0000000..2a28eb5
--- /dev/null
+++ b/src/unitsuite.cpp
@@ -0,0 +1,67 @@
+#include "unitsuite.h"
+Bu::UnitSuite::UnitSuite()
+{
+}
+Bu::UnitSuite::~UnitSuite()
+{
+}
+int Bu::UnitSuite::run( int argc, char *argv[] )
+{
+        for( TestList::iterator i = lTests.begin(); i != lTests.end(); i++ )
+        {
+                printf("%s: ", i->sName.getStr() );
+                fflush( stdout );
+                try
+                {
+                        (this->*(i->fTest))();
+                        printf("passed.\n");
+                }
+                catch( Failed &e )
+                {
+                        if( e.bFile )
+                        {
+                                printf("unitTest(%s) failed. (%s:%d)\n",
+                                        e.str.getStr(),
+                                        e.sFile.getStr(),
+                                        e.nLine
+                                        );
+                        }
+                        else
+                        {
+                                printf("unitTest(%s) failed.\n",
+                                        e.str.getStr()
+                                        );
+                        }
+                }
+                catch( ... )
+                {
+                        printf("failed with external exception.\n");
+                }
+        }
+        return 0;
+}
+void Bu::UnitSuite::add( Test fTest, Bu::FString sName )
+{
+        TestInfo ti;
+        ti.sName = sName;
+        long index = ti.sName.rfind("::");
+        if( index != -1 )
+        {
+                FString tmp = sSuiteName;
+                tmp += ti.sName.getStr()+index;
+                ti.sName = tmp;
+        }
+        ti.fTest = fTest;
+        lTests.push_back( ti );
+}
+void Bu::UnitSuite::setName( const FString &sName )
+{
+        sSuiteName = sName;
+}
diff --git a/src/unitsuite.h b/src/unitsuite.h
new file mode 100644
index 0000000..578b4cc
--- /dev/null
+++ b/src/unitsuite.h
@@ -0,0 +1,96 @@
+#ifndef BU_UNIT_SUITE_H
+#define BU_UNIT_SUITE_H
+#include <stdint.h>
+#include <list>
+#include "fstring.h"
+namespace Bu
+{
+        /**
+         * Provides a unit testing framework.  This is pretty easy to use, probably
+         * the best way to get started is to use ch to generate a template, or use
+         * the code below with appropriate tweaks:
+         *@code
+         * #include "unitsuite.h"
+         * 
+         * class Unit : public Bu::UnitSuite
+         * {
+         * public:
+         *      Unit()
+         *      {
+         *              setName("Example");
+         *              addTest( Unit::test );
+         *      }
+         * 
+         *      virtual ~Unit() { }
+         * 
+         *      //
+         *      // Tests go here
+         *      //
+         *      void test()
+         *      {
+         *              unitTest( 1 == 1 );
+         *      }
+         * };
+         * 
+         * int main( int argc, char *argv[] )
+         * {
+         *      return Unit().run( argc, argv );
+         * }
+         *
+         @endcode
+         * The main function can contain other things, but using this one exactly
+         * makes all of the test suites work exactly the same.  Using the optional
+         * setName at the top of the constructor replaces the class name with the
+         * chosen name when printing out stats and info.
+         */
+        class UnitSuite
+        {
+        public:
+                UnitSuite();
+                virtual ~UnitSuite();
+                int run( int argc=0, char *argv[]=NULL );
+                typedef void (UnitSuite::*Test)();
+                class Failed
+                {
+                public:
+                        Failed() : str(""), bFile( false ) { }
+                        Failed( const FString &s ) : str( s ), bFile( false ) { }
+                        Failed( const FString &s, const FString &sFile, int nLine ) :
+                                str( s ), sFile( sFile ), nLine( nLine ), bFile( true ) { }
+                        FString str;
+                        FString sFile;
+                        int nLine;
+                        bool bFile;
+                };
+                
+        protected:
+                void add( Test fTest, Bu::FString sName );
+                void setName( const FString &sName );
+        private:
+                typedef struct TestInfo
+                {
+                        FString sName;
+                        Test fTest;
+                } TestInfo;
+                typedef std::list<TestInfo> TestList;
+                TestList lTests;
+                FString sSuiteName;
+        };
+}
+#define addTest( fn ) add( static_cast<Bu::UnitSuite::Test>(&fn), #fn )
+#define unitTest( tst ) if( !(tst) )                                                    \
+{                                                                                                                               \
+        throw Bu::UnitSuite::Failed( #tst, __FILE__, __LINE__ );        \
+}
+#define unitFailed( msg ) throw Bu::UnitSuite::Failed(msg, __FILE__, __LINE__);
+#endif
diff --git a/test.taf b/test.taf
new file mode 100644
index 0000000..1d4e7d1
--- /dev/null
+++ b/test.taf
@@ -0,0 +1,7 @@
+{"player": "password"="aoeuaoeuao" "userclass"="implementor" "species"="human" "sex"="male" "active" "startroom"="Salourn::Xagafinelle's Room" {"stats": "str"="14" "dex"="12" "spd"="12" "enr"="7" "rea"="12" "wil"="10" "int"="13" "cha"="14" }{"hp": "cur"="100" "max"="100" }{"en": "cur"="100" "max"="100" }"attackrate"="30" "gold"="0"
+        /* Hey, the inventory is next...isn't that cool?  Oooooh yeah! */
+{"inventory": {: "count"="1" "id"="Salourn::Dark Blade" }{: "count"="1" "id"="Salourn::Dark Suit" }{: "count"="3" "id"="Salourn::Small Fig" }}{"aliases": {: "key"="." "value"="say" }{: "key"="," "value"="yell" }{: "key"="li" "value"="lightning" }}"description"="They appear to be rather average looking, not particularly
+                tall or short, with facial features that are difficult to remember even
+                seconds after witnessing them." }
diff --git a/tests/comments.xml b/tests/comments.xml
deleted file mode 100644
index df05b3b..0000000
--- a/tests/comments.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0"?>
-<test>
-        <!----><stuff/><guy>
-        <!-- euntaho esutnaho .rucaho. u
-        ao.rcuh aor uasrcoh
-        rohaor
-        c.uha
-        orchu
-        aroch.ua.
-        -->Aaaugh!
-        </guy>
-</test>
diff --git a/tests/guy.cpp b/tests/guy.cpp
deleted file mode 100644
index 6510771..0000000
--- a/tests/guy.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "stdio.h"
-#include "plugin.h"
-#include "plugger.h"
-class Guy : public Plugin
-{
-public:
-        Guy()
-        {
-                printf("I'm guy!\n");
-        }
-        virtual ~Guy()
-        {
-                printf("Guy is dead...\n");
-        }
-private:
-};
-PluginInterface( Guy, Plugin, "Mike", 0, 1 )
diff --git a/tests/makeplugin.sh b/tests/makeplugin.sh
deleted file mode 100755
index 086fefd..0000000
--- a/tests/makeplugin.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/sh
-g++ -fPIC -shared -Wl,-soname,guy.so -o guy.so -I../src -I../src/test/plugin guy.cpp ../src/test/plugin/plugin.cpp
author	Mike Buland <eichlan@xagasoft.com>	2007-07-03 00:28:59 +0000
committer	Mike Buland <eichlan@xagasoft.com>	2007-07-03 00:28:59 +0000
commit	ac517a2b7625e0aa0862679e961c6349f859ea3b (patch)
tree	e3e27a6b9bd5e2be6150088495c91fc91786ad9d
parent	f8d4301e9fa4f3709258505941e37fab2eadadc6 (diff)
parent	bd865cee5f89116c1f054cd0e5c275e97c2d0a9b (diff)
download	libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.gz libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.bz2 libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.tar.xz libbu++-ac517a2b7625e0aa0862679e961c6349f859ea3b.zip