element. */ /* Can we use `rpt` here? No; `element` has a value in every case. */ return TY_(tidyMessageCreateWithNode)(doc, node, code, doc->badForm ? TidyError : TidyWarning, nodedesc ); break; } return NULL; } /********************************************************************* * High Level Message Writing Functions * When adding new reports to LibTidy, preference should be given * to one of the existing, general purpose message writing functions * above, if possible, otherwise try to use one of these, or as a * last resort add a new one in this section. *********************************************************************/ /* This function performs the heavy lifting for TY_(Report)(). Critically we ** can accept the va_list needed for recursion. */ static void vReport(TidyDocImpl* doc, Node *element, Node *node, uint code, va_list args) { int i = 0; va_list args_copy; while ( dispatchTable[i].code != 0 ) { if ( dispatchTable[i].code == code ) { TidyMessageImpl *message; messageFormatter *handler = dispatchTable[i].handler; TidyReportLevel level = dispatchTable[i].level; va_copy(args_copy, args); message = handler( doc, element, node, code, level, args_copy ); va_end(args_copy); messageOut( message ); if ( dispatchTable[i].next ) { va_copy(args_copy, args); vReport(doc, element, node, dispatchTable[i].next, args_copy); va_end(args_copy); } break; } i++; } } /* This single Report output function uses the correct formatter with all ** possible, relevant data that can be reported. The only real drawbacks are ** having to pass NULL when some of the values aren't used, and the lack of ** type safety by using the variable arguments. To counter this some convenience ** report output functions exist, too. Any new reports you wish to create must ** be able to use this function signature, although convenience functions should ** be added to abstract the full function signature and to preserve type safety. */ void TY_(Report)(TidyDocImpl* doc, Node *element, Node *node, uint code, ...) { va_list args; va_start(args, code); vReport(doc, element, node, code, args); va_end(args); } /********************************************************************* * Convenience Reporting Functions * Functions that don't require the full signature of TY_(Report), * and help protect type safety by avoiding variable arguments in the * rest of Tidy's code. *********************************************************************/ void TY_(ReportAccessError)( TidyDocImpl* doc, Node* node, uint code ) { TY_(Report)( doc, NULL, node, code ); } void TY_(ReportAttrError)(TidyDocImpl* doc, Node *node, AttVal *av, uint code) { TY_(Report)( doc, NULL, node, code, av ); } void TY_(ReportBadArgument)( TidyDocImpl* doc, ctmbstr option ) { assert( option != NULL ); TY_(Report)( doc, NULL, NULL, STRING_MISSING_MALFORMED, option ); } void TY_(ReportEntityError)( TidyDocImpl* doc, uint code, ctmbstr entity, int ARG_UNUSED(c) ) { /* Note that the report formatter currently doesn't use argument c */ TY_(Report)( doc, NULL, NULL, code, entity, c ); } void TY_(ReportFileError)( TidyDocImpl* doc, ctmbstr file, uint code ) { TY_(Report)( doc, NULL, NULL, code, file ); } void TY_(ReportEncodingError)(TidyDocImpl* doc, uint code, uint c, Bool discarded) { TY_(Report)( doc, NULL, NULL, code, c, discarded ); } void TY_(ReportEncodingWarning)(TidyDocImpl* doc, uint code, uint encoding) { /* va_list in formatter expects trailing `no` argument */ TY_(Report)( doc, NULL, NULL, code, encoding, no ); } void TY_(ReportMissingAttr)( TidyDocImpl* doc, Node* node, ctmbstr name ) { TY_(Report)( doc, NULL, node, MISSING_ATTRIBUTE, name ); } void TY_(ReportSurrogateError)(TidyDocImpl* doc, uint code, uint c1, uint c2) { TY_(Report)( doc, NULL, NULL, code, c1,c2 ); } void TY_(ReportUnknownOption)( TidyDocImpl* doc, ctmbstr option ) { /* lexer is not defined when this is called */ TY_(Report)( doc, NULL, NULL, STRING_UNKNOWN_OPTION, option ); } /********************************************************************* * Dialogue Output Functions * As for issuing reports, Tidy manages all dialogue output from a * single source in order to manage message categories in a simple * an consistent manner. *********************************************************************/ /* This structure ties together for each dialogue Code the default ** TidyReportLevel. This it makes it simple to output new dialogue ** messages, or to change report level by modifying this array. */ static struct _dialogueDispatchTable { uint code; /**< The message code. */ TidyReportLevel level; /**< The default TidyReportLevel of the message. */ } dialogueDispatchTable[] = { { STRING_HELLO_ACCESS, TidyDialogueInfo }, /* AccessibilityChecks() */ { TEXT_GENERAL_INFO, TidyDialogueInfo }, /* tidyGeneralInfo() */ { TEXT_GENERAL_INFO_PLEA, TidyDialogueInfo }, /* tidyGeneralInfo() */ { STRING_NEEDS_INTERVENTION, TidyDialogueSummary }, /* tidyDocRunDiagnostics() */ { STRING_ERROR_COUNT, TidyDialogueSummary }, /* ReportNumWarnings() */ { STRING_NO_ERRORS, TidyDialogueSummary }, /* ReportNumWarnings() */ { STRING_NOT_ALL_SHOWN, TidyDialogueSummary }, /* ReportNumWarnings() */ { FOOTNOTE_TRIM_EMPTY_ELEMENT, TidyDialogueFootnote }, { TEXT_ACCESS_ADVICE1, TidyDialogueFootnote }, /* errorSummary() */ { TEXT_ACCESS_ADVICE2, TidyDialogueFootnote }, { TEXT_BAD_FORM, TidyDialogueFootnote }, { TEXT_BAD_MAIN, TidyDialogueFootnote }, { TEXT_HTML_T_ALGORITHM, TidyDialogueFootnote }, { TEXT_INVALID_URI, TidyDialogueFootnote }, { TEXT_INVALID_UTF8, TidyDialogueFootnote }, { TEXT_INVALID_UTF16, TidyDialogueFootnote }, { TEXT_M_IMAGE_ALT, TidyDialogueFootnote }, { TEXT_M_IMAGE_MAP, TidyDialogueFootnote }, { TEXT_M_LINK_ALT, TidyDialogueFootnote }, { TEXT_M_SUMMARY, TidyDialogueFootnote }, { TEXT_SGML_CHARS, TidyDialogueFootnote }, { TEXT_USING_BODY, TidyDialogueFootnote }, { TEXT_USING_FONT, TidyDialogueFootnote }, { TEXT_USING_FRAMES, TidyDialogueFootnote }, { TEXT_USING_LAYER, TidyDialogueFootnote }, { TEXT_USING_NOBR, TidyDialogueFootnote }, { TEXT_USING_SPACER, TidyDialogueFootnote }, { TEXT_VENDOR_CHARS, TidyDialogueFootnote }, { 0, 0 } }; /* This message formatter for dialogue messages should be capable of formatting ** every message, because they're not all the complex and there aren't that ** many. */ static TidyMessageImpl *formatDialogue( TidyDocImpl* doc, uint code, TidyReportLevel level, va_list args ) { switch (code) { case TEXT_SGML_CHARS: case TEXT_VENDOR_CHARS: { ctmbstr str = va_arg(args, ctmbstr); return TY_(tidyMessageCreate)( doc, code, level, str ); } case STRING_ERROR_COUNT: case STRING_NOT_ALL_SHOWN: return TY_(tidyMessageCreate)( doc, code, level, doc->warnings, tidyLocalizedStringN( STRING_ERROR_COUNT_WARNING, doc->warnings ), doc->errors, tidyLocalizedStringN( STRING_ERROR_COUNT_ERROR, doc->errors ) ); case FOOTNOTE_TRIM_EMPTY_ELEMENT: case STRING_HELLO_ACCESS: case STRING_NEEDS_INTERVENTION: case STRING_NO_ERRORS: case TEXT_ACCESS_ADVICE1: case TEXT_ACCESS_ADVICE2: case TEXT_BAD_FORM: case TEXT_BAD_MAIN: case TEXT_GENERAL_INFO: case TEXT_GENERAL_INFO_PLEA: case TEXT_HTML_T_ALGORITHM: case TEXT_INVALID_URI: case TEXT_INVALID_UTF8: case TEXT_INVALID_UTF16: case TEXT_M_IMAGE_ALT: case TEXT_M_IMAGE_MAP: case TEXT_M_LINK_ALT: case TEXT_M_SUMMARY: case TEXT_USING_BODY: case TEXT_USING_FONT: case TEXT_USING_FRAMES: case TEXT_USING_LAYER: case TEXT_USING_NOBR: case TEXT_USING_SPACER: default: return TY_(tidyMessageCreate)( doc, code, level ); } return NULL; } /* This single Dialogue output function determines the correct message level ** and formats the message with the appropriate formatter, and then outputs it. ** This one dialogue function should be sufficient for every use case. */ void TY_(Dialogue)(TidyDocImpl* doc, uint code, ...) { int i = 0; va_list args; while ( dialogueDispatchTable[i].code != 0 ) { if ( dialogueDispatchTable[i].code == code ) { TidyMessageImpl *message; TidyReportLevel level = dialogueDispatchTable[i].level; va_start(args, code); message = formatDialogue( doc, code, level, args ); va_end(args); messageOut( message ); break; } i++; } } /********************************************************************* * Output Dialogue Information * In addition to reports that are added to the table, Tidy emits * various dialogue type information. Most of these are specific to * exact circumstances, although `TY_(Dialogue)` should be used * instead of adding a new function, if possible. *********************************************************************/ /* Outputs the footnotes and other dialogue information after document cleanup ** is complete. LibTidy users might consider capturing these individually in ** the message callback rather than capturing this entire buffer. ** Called by tidyErrorSummary(), in console. ** @todo: This name is a bit misleading and should probably be renamed to ** indicate its focus on printing footnotes. */ void TY_(ErrorSummary)( TidyDocImpl* doc ) { ctmbstr encnam = tidyLocalizedString(STRING_SPECIFIED); int charenc = cfg( doc, TidyCharEncoding ); if ( charenc == WIN1252 ) encnam = "Windows-1252"; else if ( charenc == MACROMAN ) encnam = "MacRoman"; else if ( charenc == IBM858 ) encnam = "ibm858"; else if ( charenc == LATIN0 ) encnam = "latin0"; /* adjust badAccess to that it is 0 if frames are ok */ if ( doc->badAccess & (BA_USING_FRAMES | BA_USING_NOFRAMES) ) { if (!((doc->badAccess & BA_USING_FRAMES) && !(doc->badAccess & BA_USING_NOFRAMES))) { doc->badAccess &= ~(BA_USING_FRAMES | BA_USING_NOFRAMES); } } if (doc->badChars) { if (doc->badChars & BC_VENDOR_SPECIFIC_CHARS) TY_(Dialogue)( doc, TEXT_VENDOR_CHARS, encnam ); if ((doc->badChars & BC_INVALID_SGML_CHARS) || (doc->badChars & BC_INVALID_NCR)) TY_(Dialogue)( doc, TEXT_SGML_CHARS, encnam ); if (doc->badChars & BC_INVALID_UTF8) TY_(Dialogue)( doc, TEXT_INVALID_UTF8 ); if (doc->badChars & BC_INVALID_UTF16) TY_(Dialogue)( doc, TEXT_INVALID_UTF16 ); if (doc->badChars & BC_INVALID_URI) TY_(Dialogue)( doc, TEXT_INVALID_URI ); } if (doc->badForm) { if (doc->badForm & flg_BadForm) /* Issue #166 - changed to BIT flag to support other errors */ TY_(Dialogue)( doc, TEXT_BAD_FORM ); if (doc->badForm & flg_BadMain) /* Issue #166 - repeated

element */ TY_(Dialogue)( doc, TEXT_BAD_MAIN ); } if (doc->badAccess) { /* Tidy "classic" accessibility tests */ if ( cfg(doc, TidyAccessibilityCheckLevel) == 0 ) { if (doc->badAccess & BA_MISSING_SUMMARY) TY_(Dialogue)( doc, TEXT_M_SUMMARY ); if (doc->badAccess & BA_MISSING_IMAGE_ALT) TY_(Dialogue)( doc, TEXT_M_IMAGE_ALT ); if (doc->badAccess & BA_MISSING_IMAGE_MAP) TY_(Dialogue)( doc, TEXT_M_IMAGE_MAP ); if (doc->badAccess & BA_MISSING_LINK_ALT) TY_(Dialogue)( doc, TEXT_M_LINK_ALT ); if ((doc->badAccess & BA_USING_FRAMES) && !(doc->badAccess & BA_USING_NOFRAMES)) TY_(Dialogue)( doc, TEXT_USING_FRAMES ); } if ( cfg(doc, TidyAccessibilityCheckLevel) > 0 ) TY_(Dialogue)( doc, TEXT_ACCESS_ADVICE2 ); else TY_(Dialogue)( doc, TEXT_ACCESS_ADVICE1 ); } if (doc->badLayout) { if (doc->badLayout & USING_LAYER) TY_(Dialogue)( doc, TEXT_USING_LAYER ); if (doc->badLayout & USING_SPACER) TY_(Dialogue)( doc, TEXT_USING_SPACER ); if (doc->badLayout & USING_FONT) TY_(Dialogue)( doc, TEXT_USING_FONT ); if (doc->badLayout & USING_NOBR) TY_(Dialogue)( doc, TEXT_USING_NOBR ); if (doc->badLayout & USING_BODY) TY_(Dialogue)( doc, TEXT_USING_BODY ); } if (doc->footnotes) { if (doc->footnotes & FN_TRIM_EMPTY_ELEMENT) TY_(Dialogue)( doc, FOOTNOTE_TRIM_EMPTY_ELEMENT ); } } /* Outputs document HTML version and version-related information. ** Called by tidyRunDiagnostics(), from console. ** Called by tidyDocReportDoctype(), currently unused. */ void TY_(ReportMarkupVersion)( TidyDocImpl* doc ) { if ( doc->givenDoctype ) TY_(Report)( doc, NULL, NULL, STRING_DOCTYPE_GIVEN, doc->givenDoctype ); if ( ! cfgBool(doc, TidyXmlTags) ) { Bool isXhtml = doc->lexer->isvoyager; uint apparentVers = TY_(ApparentVersion)( doc ); ctmbstr vers = TY_(HTMLVersionNameFromCode)( apparentVers, isXhtml ); if ( !vers ) vers = tidyLocalizedString(STRING_HTML_PROPRIETARY); TY_(Report)( doc, NULL, NULL, STRING_CONTENT_LOOKS, vers ); /* Warn about missing system identifier (SI) in emitted doctype */ if ( TY_(WarnMissingSIInEmittedDocType)( doc ) ) TY_(Report)( doc, NULL, NULL, STRING_NO_SYSID ); } } /* Reports the number of warnings and errors found in the document. ** Called by tidyRunDiagnostics(), from console. */ void TY_(ReportNumWarnings)( TidyDocImpl* doc ) { if ( doc->warnings > 0 || doc->errors > 0 ) { if ( doc->errors > cfg(doc, TidyShowErrors) || !cfgBool(doc, TidyShowWarnings) ) { TY_(Dialogue)( doc, STRING_NOT_ALL_SHOWN ); } else { TY_(Dialogue)( doc, STRING_ERROR_COUNT ); } } else { TY_(Dialogue)( doc, STRING_NO_ERRORS ); } } /********************************************************************* * Message Muting *********************************************************************/ void TY_(FreeMutedMessageList)( TidyDocImpl* doc ) { TidyMutedMessages *list = &(doc->muted); if ( list->list ) TidyFree( doc->allocator, list->list ); } void TY_(DefineMutedMessage)(TidyDocImpl* doc, const TidyOptionImpl* opt, ctmbstr name) { enum { capacity = 10 }; TidyMutedMessages *list = &(doc->muted); tidyStrings message = TY_(tidyErrorCodeFromKey)( name ); if ( message <= REPORT_MESSAGE_FIRST || message >= REPORT_MESSAGE_LAST) { TY_(Report)( doc, NULL, NULL, STRING_ARGUMENT_BAD, opt->name, name ); return; } if ( !list->list ) { list->list = TidyAlloc(doc->allocator, sizeof(tidyStrings) * capacity ); list->list[0] = 0; list->capacity = capacity; list->count = 0; } if ( list->count >= list->capacity ) { list->capacity = list->capacity * 2; list->list = TidyRealloc(doc->allocator, list->list, sizeof(tidyStrings) * list->capacity + 1 ); } list->list[list->count] = message; list->count++; list->list[list->count] = 0; /* Must come *after* adding to the list, in case it's muted, too. */ TY_(Report)( doc, NULL, NULL, STRING_MUTING_TYPE, name ); } TidyIterator TY_(getMutedMessageList)( TidyDocImpl* doc ) { TidyMutedMessages *list = &(doc->muted); size_t result = list->count > 0 ? 1 : 0; return (TidyIterator) result; } ctmbstr TY_(getNextMutedMessage)( TidyDocImpl* doc, TidyIterator* iter ) { TidyMutedMessages *list = &(doc->muted); size_t index; ctmbstr result = NULL; assert( iter != NULL ); index = (size_t)*iter; if ( index > 0 && index <= list->count ) { result = TY_(tidyErrorCodeAsKey)(list->list[index-1]); index++; } *iter = (TidyIterator) ( index <= list->count ? index : (size_t)0 ); return result; } /********************************************************************* * Key Discovery *********************************************************************/ /********************************************************************* * LibTidy users may want to to enable their own localization lookup * lookup methods. Because Tidy's errors codes are enums, the actual * values can change over time. This table will the LibTidy users * always have a static value available for use. * * For macro documentation, refer to the comments in `tidyenum.h`. *********************************************************************/ typedef struct tidyStringsKeyItem { ctmbstr key; int value; } tidyStringsKeyItem; static const tidyStringsKeyItem tidyStringsKeys[] = { FOREACH_TIDYCONFIGCATEGORY(MAKE_STRUCT) FOREACH_MSG_MISC(MAKE_STRUCT) FOREACH_FOOTNOTE_MSG(MAKE_STRUCT) FOREACH_DIALOG_MSG(MAKE_STRUCT) FOREACH_REPORT_MSG(MAKE_STRUCT) FOREACH_ACCESS_MSG(MAKE_STRUCT) #if SUPPORT_CONSOLE_APP FOREACH_MSG_CONSOLE(MAKE_STRUCT) #endif { "TIDYSTRINGS_FIRST", TIDYSTRINGS_FIRST }, { "TIDYSTRINGS_LAST", TIDYSTRINGS_LAST }, { NULL, 0 }, }; /** * Given an error code, return the string associated with it. */ ctmbstr TY_(tidyErrorCodeAsKey)(uint code) { uint i = 0; while (tidyStringsKeys[i].key) { if ( tidyStringsKeys[i].value == code ) return tidyStringsKeys[i].key; i++; } return "UNDEFINED"; } /** * Given an error code string, return its uint. */ uint TY_(tidyErrorCodeFromKey)(ctmbstr code) { uint i = 0; while (tidyStringsKeys[i].key) { if ( strcmp(tidyStringsKeys[i].key, code) == 0 ) return tidyStringsKeys[i].value; i++; } return UINT_MAX; } /** * Determines the number of error codes used by Tidy. */ static const uint tidyErrorCodeListSize() { static uint array_size = 0; if ( array_size == 0 ) { while ( tidyStringsKeys[array_size].key ) { array_size++; } } return array_size; } /** * Initializes the TidyIterator to point to the first item * in Tidy's list of error codes. Individual items must be * retrieved with getNextErrorCode(); */ TidyIterator TY_(getErrorCodeList)() { return (TidyIterator)(size_t)1; } /** * Returns the next error code. */ uint TY_(getNextErrorCode)( TidyIterator* iter ) { const tidyStringsKeyItem *item = NULL; size_t itemIndex; assert( iter != NULL ); itemIndex = (size_t)*iter; if ( itemIndex > 0 && itemIndex <= tidyErrorCodeListSize() ) { item = &tidyStringsKeys[itemIndex - 1]; itemIndex++; } *iter = (TidyIterator)( itemIndex <= tidyErrorCodeListSize() ? itemIndex : (size_t)0 ); return item->value; } /********************************************************************* * Documentation of configuration options * * Although most of the strings now come from the language module, * generating the documentation by the console application requires a * series of cross-references that are generated in this messaging * module. *********************************************************************/ #if SUPPORT_CONSOLE_APP /* Cross-references definitions. * Note that each list must be terminated with `TidyUnknownOption`. */ static const TidyOptionId TidyAsciiCharsLinks[] = { TidyMakeClean, TidyUnknownOption }; static const TidyOptionId TidyBlockTagsLinks[] = { TidyEmptyTags, TidyInlineTags, TidyPreTags, TidyUseCustomTags, TidyUnknownOption }; static const TidyOptionId TidyCharEncodingLinks[] = { TidyInCharEncoding, TidyOutCharEncoding, TidyUnknownOption }; static const TidyOptionId TidyDuplicateAttrsLinks[] = { TidyJoinClasses, TidyJoinStyles, TidyUnknownOption }; static const TidyOptionId TidyEmacsLinks[] = { TidyShowFilename, TidyUnknownOption }; static const TidyOptionId TidyEmptyTagsLinks[] = { TidyBlockTags, TidyInlineTags, TidyPreTags, TidyUseCustomTags, TidyUnknownOption }; static const TidyOptionId TidyErrFileLinks[] = { TidyOutFile, TidyUnknownOption }; static const TidyOptionId TidyInCharEncodingLinks[] = { TidyCharEncoding, TidyUnknownOption }; static const TidyOptionId TidyIndentContentLinks[] = { TidyIndentSpaces, TidyUnknownOption }; static const TidyOptionId TidyIndentSpacesLinks[] = { TidyIndentContent, TidyUnknownOption }; static const TidyOptionId TidyInlineTagsLinks[] = { TidyBlockTags, TidyEmptyTags, TidyPreTags, TidyUseCustomTags, TidyUnknownOption }; static const TidyOptionId TidyMergeDivsLinks[] = { TidyMakeClean, TidyMergeSpans, TidyUnknownOption }; static const TidyOptionId TidyMergeSpansLinks[] = { TidyMakeClean, TidyMergeDivs, TidyUnknownOption }; static const TidyOptionId TidyMuteLinks[] = { TidyMuteShow, TidyUnknownOption }; static const TidyOptionId TidyMuteShowLinks[] = { TidyMuteReports, TidyUnknownOption }; static const TidyOptionId TidyNumEntitiesLinks[] = { TidyDoctype, TidyPreserveEntities, TidyUnknownOption }; static const TidyOptionId TidyOutCharEncodingLinks[] = { TidyCharEncoding, TidyUnknownOption }; static const TidyOptionId TidyOutFileLinks[] = { TidyErrFile, TidyUnknownOption }; static const TidyOptionId TidyPreTagsLinks[] = { TidyBlockTags, TidyEmptyTags, TidyInlineTags, TidyUseCustomTags, TidyUnknownOption }; static const TidyOptionId TidyShowFilenameLinks[] = { TidyEmacs, TidyUnknownOption }; static const TidyOptionId TidySortAttributesLinks[] = { TidyPriorityAttributes, TidyUnknownOption }; static const TidyOptionId TidyUseCustomTagsLinks[] = { TidyBlockTags, TidyEmptyTags, TidyInlineTags, TidyPreTags, TidyUnknownOption }; static const TidyOptionId TidyWrapAttValsLinks[] = { TidyWrapScriptlets, TidyLiteralAttribs, TidyUnknownOption }; static const TidyOptionId TidyWrapScriptletsLinks[] = { TidyWrapAttVals, TidyUnknownOption }; static const TidyOptionId TidyXmlDeclLinks[] = { TidyCharEncoding, TidyOutCharEncoding, TidyUnknownOption }; /* Cross-reference assignments. * We can't build a complex array at compile time and we're not counting on * any type of initialization, so this two-stage building process is required. */ static const TidyOptionDoc docs_xrefs[] = { { TidyAsciiChars, TidyAsciiCharsLinks }, { TidyBlockTags, TidyBlockTagsLinks }, { TidyCharEncoding, TidyCharEncodingLinks }, { TidyDuplicateAttrs, TidyDuplicateAttrsLinks }, { TidyEmacs, TidyEmacsLinks }, { TidyEmptyTags, TidyEmptyTagsLinks }, { TidyErrFile, TidyErrFileLinks }, { TidyInCharEncoding, TidyInCharEncodingLinks }, { TidyIndentContent, TidyIndentContentLinks }, { TidyIndentSpaces, TidyIndentSpacesLinks }, { TidyInlineTags, TidyInlineTagsLinks }, { TidyMergeDivs, TidyMergeDivsLinks }, { TidyMergeSpans, TidyMergeSpansLinks }, { TidyMuteShow, TidyMuteShowLinks }, { TidyNumEntities, TidyNumEntitiesLinks }, { TidyOutCharEncoding, TidyOutCharEncodingLinks }, { TidyOutFile, TidyOutFileLinks }, { TidyPreTags, TidyPreTagsLinks }, { TidyShowFilename, TidyShowFilenameLinks }, { TidySortAttributes, TidySortAttributesLinks }, { TidyMuteReports, TidyMuteLinks }, { TidyUseCustomTags, TidyUseCustomTagsLinks }, { TidyWrapAttVals, TidyWrapAttValsLinks }, { TidyWrapScriptlets, TidyWrapScriptletsLinks }, { TidyXmlDecl, TidyXmlDeclLinks }, { N_TIDY_OPTIONS } }; /* Cross-reference retrieval. */ const TidyOptionDoc* TY_(OptGetDocDesc)( TidyOptionId optId ) { uint i = 0; while( docs_xrefs[i].opt != N_TIDY_OPTIONS ) { if ( docs_xrefs[i].opt == optId ) return &docs_xrefs[i]; ++i; } return NULL; } #endif /* SUPPORT_CONSOLE_APP */ /* * local variables: * mode: c * indent-tabs-mode: nil * c-basic-offset: 4 * eval: (c-set-offset 'substatement-open 0) * end: */