inline char const *Options::classHeaderSpec()
{
    return "class-header";
}

inline char const *Options::baseclassHeaderSpec()
{
    return "baseclass-header";
}

inline char const *Options::implementationHeaderSpec()
{
    return "implementation-header";
}

inline char const *Options::lexSourceSpec()
{
    return "lex-source";
}

inline void Options::regexCall(char const *funName)
{
    (*s_regexCall)(funName);
}

inline size_t Options::maxDepth() const
{
    return d_maxDepth;
}

inline bool Options::caseSensitive() const
{
    return d_caseSensitive;
}

inline std::string const &Options::constructionPath() const
{
    return d_constructionPath;
}

inline std::string const &Options::inputInline() const
{
    return d_inputInlinePath;
}

inline std::string const &Options::inputInterface() const
{
    return d_inputInterfacePath;
}

inline std::string const &Options::filenames() const
{
    return d_filenames;
}

inline std::string const &Options::inputImplementation() const
{
    return d_inputImplementation;
}

inline std::string const &Options::baseclassPreinclude() const
{
    return d_baseClassPreinclude;
}

inline std::string const &Options::baseclassSkeleton() const
{
    return d_baseClassSkeleton;
}

inline std::string const &Options::classSkeleton() const
{
    return d_classSkeleton;
}

inline std::string const &Options::implementationSkeleton() const
{
    return d_implementationSkeleton;
}

inline std::string const &Options::lexSkeleton() const
{
    return d_lexSkeleton;
}

inline std::string const &Options::baseclassHeaderPath() const
{
    return d_baseClassHeader;
}

inline std::string const &Options::classHeaderPath() const
{
    return d_classHeader;
}

inline std::string const &Options::implementationHeaderPath() const
{
    return d_implementationHeader;
}

inline std::string const &Options::lexSourcePath() const
{
    return d_lexSource;
}

inline std::string const &Options::lexFunctionName() const
{
    return d_lexFunctionName;
}

inline std::string const &Options::className() const
{
    return d_className;
}

inline std::string const &Options::nameSpace() const
{
    return d_nameSpace;
}

inline std::string const &Options::nameSpaceIdentifier() const
{
    return d_nameSpaceIdentifier;
}

inline std::string const &Options::infile() const
{
    return d_infile;
}

inline std::string const &Options::startConditionName() const
{
    return d_startConditionName;
}

inline void Options::setSkeletonDirectory(TextType textType)
{
    assign(textType, &d_skeletonDirectory, PATHNAME, "skeleton-directory");
}

inline void Options::setTokenPath(TextType textType)
{
    assign(textType, &d_tokenPath, PATHNAME, "token-path");
}

inline void Options::setTargetDirectory(TextType textType)
{
    assign(textType, &d_targetDirectory, PATHNAME, "target-directory");
}

inline void Options::setNameSpace(TextType textType)
{
    assign(textType, &d_nameSpace, FILENAME, "namespace");
}

inline void Options::setInputImplementationPath(TextType textType)
{
    assign(textType, &d_inputImplementation, PATHNAME, "input-implementation");
}
   
inline void Options::setInputInlinePath(TextType textType)
{
    assign(textType, &d_inputInlinePath, PATHNAME, "input-inline");
}
   
inline void Options::setInputInterfacePath(TextType textType)
{
    assign(textType, &d_inputInterfacePath, PATHNAME, "input-interface");
}
   
inline void Options::setBaseClassHeader(TextType textType)
{
    assign(textType, &d_baseClassHeader, FILENAME, baseclassHeaderSpec());
}
   
inline void Options::setBaseClassPreinclude(TextType textType)
{
    assign(textType, &d_baseClassPreinclude, PATHNAME, 
                                                    "baseclass-preinclude");
}
inline void Options::setClassHeader(TextType textType)
{
    assign(textType, &d_classHeader, FILENAME, classHeaderSpec());
}
   
inline void Options::setImplementationHeader(TextType textType)
{
    assign(textType, &d_implementationHeader, FILENAME, 
           implementationHeaderSpec());
}
   
inline void Options::setLexSource(TextType textType)
{
    assign(textType, &d_lexSource, FILENAME, "lex-source");
}
   
inline void Options::setInteractive()
{   
    d_interactive = true;
}

inline void Options::setCaseInsensitive()
{   
    d_caseSensitive = false;
}

inline void Options::setLines(bool yesNo)
{   
    d_lines = yesNo;
}

inline void Options::setDebug()
{
    d_debug = true;
}

inline void Options::setPrint()
{
    d_print = true;
}

inline bool Options::interactive() const
{   
    return d_interactive;
}


inline bool Options::verbose() const
{   
    return d_verbose;
}

inline bool Options::print() const
{   
    return d_print;
}

inline bool Options::lines() const
{   
    return d_lines;
}

inline bool Options::debug() const
{
    return d_debug;
}

inline bool Options::ownParserDebug() const
{
    return d_ownParser;
}

inline bool Options::specified(std::string const &option) const
{
    return s_warnOptions.find(option) != s_warnOptions.end();
}

inline std::string const &Options::tokenPath() const
{
    return d_tokenPath;
}

