When polymorphic semantic values are used then, in addition to the parser and parse-base classes, several more classes are defined. Some of them are class templates; most are defined in tt(parserbase.h); an occasional implementation is added to the tt(parse.cc) source file. To minimize namespace pollution most of the extra code is contained in a namespace of its own: tt(Meta_). If the tt(%namespace) directive was used then tt(Meta_) is nested under the namespace declared by that directive. The name tt(Meta_) is used because much of the code implementing polymorphic semantic values uses template meta programming. bf(The enumeration 'enum class Tag_') One notable exception to the above is the enumeration tt(Tag_). To simplify its use it is declared outside of tt(Meta_) (but inside the tt(%namespace) namespace, if specified). Its tags are declared at the tt(%polymorphic) directive. tt(Targs_) is a strongly typed enumeration. The tt(%weak-tags) directive can be used to declare a pre C++-11 standard `tt(enum Tag_)'. bf(The namespace Meta_) Below, tt(DataType) refers to the semantic value's data type that is associated with a tt(Tag_) identifier. Several classes are defined in the namespace tt(Meta_). The most important class is tt(SType), providing the interface to the semantic value types. The class tt(SType) becomes the parser's tt(STYPE_) type. Each tt(SType) object is either a default tt(SType) object, not containing a semantic value, or it contains a semantic value of a single tt(DataType). All operations related to semantic values are handled by this class. The class tt(SType) provides the following public interface: includefile(stypeinterface)