tidy.h

Go to the documentation of this file.
00001 #ifndef __TIDY_H__
00002 #define __TIDY_H__
00003 
00004 /** @file tidy.h - Defines HTML Tidy API implemented by tidy library.
00005 
00006   Public interface is const-correct and doesn't explicitly depend
00007   on any globals.  Thus, thread-safety may be introduced w/out
00008   changing the interface.
00009 
00010   Looking ahead to a C++ wrapper, C functions always pass 
00011   this-equivalent as 1st arg.
00012 
00013 
00014   Copyright (c) 1998-2004 World Wide Web Consortium
00015   (Massachusetts Institute of Technology, European Research 
00016   Consortium for Informatics and Mathematics, Keio University).
00017   All Rights Reserved.
00018 
00019   CVS Info :
00020 
00021     $Author: terry_teague $ 
00022     $Date: 2004/02/29 03:59:25 $ 
00023     $Revision: 1.9 $ 
00024 
00025   Contributing Author(s):
00026 
00027      Dave Raggett <dsr@w3.org>
00028 
00029   The contributing author(s) would like to thank all those who
00030   helped with testing, bug fixes and suggestions for improvements. 
00031   This wouldn't have been possible without your help.
00032 
00033   COPYRIGHT NOTICE:
00034  
00035   This software and documentation is provided "as is," and
00036   the copyright holders and contributing author(s) make no
00037   representations or warranties, express or implied, including
00038   but not limited to, warranties of merchantability or fitness
00039   for any particular purpose or that the use of the software or
00040   documentation will not infringe any third party patents,
00041   copyrights, trademarks or other rights. 
00042 
00043   The copyright holders and contributing author(s) will not be held
00044   liable for any direct, indirect, special or consequential damages
00045   arising out of any use of the software or documentation, even if
00046   advised of the possibility of such damage.
00047 
00048   Permission is hereby granted to use, copy, modify, and distribute
00049   this source code, or portions hereof, documentation and executables,
00050   for any purpose, without fee, subject to the following restrictions:
00051 
00052   1. The origin of this source code must not be misrepresented.
00053   2. Altered versions must be plainly marked as such and must
00054      not be misrepresented as being the original source.
00055   3. This Copyright notice may not be removed or altered from any
00056      source or altered source distribution.
00057  
00058   The copyright holders and contributing author(s) specifically
00059   permit, without fee, and encourage the use of this source code
00060   as a component for supporting the Hypertext Markup Language in
00061   commercial products. If you use this source code in a product,
00062   acknowledgment is not required but would be appreciated.
00063 
00064 
00065   Created 2001-05-20 by Charles Reitzel
00066   Updated 2002-07-01 by Charles Reitzel - 1st Implementation
00067 
00068 */
00069 
00070 #include "platform.h"
00071 #include "tidyenum.h"
00072 
00073 #ifdef __cplusplus
00074 extern "C" {
00075 #endif
00076 
00077 /** @defgroup Opaque Opaque Types
00078 **
00079 ** Cast to implementation types within lib.
00080 ** Reduces inter-dependencies/conflicts w/ application code.
00081 ** @{
00082 */
00083 
00084 /** @struct TidyDoc
00085 **  Opaque document datatype
00086 */
00087 opaque_type( TidyDoc );
00088 
00089 /** @struct TidyOption
00090 **  Opaque option datatype
00091 */
00092 opaque_type( TidyOption );
00093 
00094 /** @struct TidyNode
00095 **  Opaque node datatype
00096 */
00097 opaque_type( TidyNode );
00098 
00099 /** @struct TidyAttr
00100 **  Opaque attribute datatype
00101 */
00102 opaque_type( TidyAttr );
00103 
00104 /** @} */
00105 
00106 TIDY_STRUCT struct _TidyBuffer;
00107 typedef struct _TidyBuffer TidyBuffer;
00108 
00109 
00110 /** @defgroup Basic Basic Operations
00111 **
00112 ** Tidy public interface
00113 **
00114 ** Several functions return an integer document status:
00115 **
00116 ** <pre>
00117 ** 0    -> SUCCESS
00118 ** >0   -> 1 == TIDY WARNING, 2 == TIDY ERROR
00119 ** <0   -> SEVERE ERROR
00120 ** </pre>
00121 ** 
00122 The following is a short example program.
00123 
00124 <pre>
00125 #include &lt;tidy.h&gt;
00126 #include &lt;buffio.h&gt;
00127 #include &lt;stdio.h&gt;
00128 #include &lt;errno.h&gt;
00129 
00130 
00131 int main(int argc, char **argv )
00132 {
00133   const char* input = "&lt;title&gt;Foo&lt;/title&gt;&lt;p&gt;Foo!";
00134   TidyBuffer output = {0};
00135   TidyBuffer errbuf = {0};
00136   int rc = -1;
00137   Bool ok;
00138 
00139   TidyDoc tdoc = tidyCreate();                     // Initialize "document"
00140   printf( "Tidying:\t\%s\\n", input );
00141 
00142   ok = tidyOptSetBool( tdoc, TidyXhtmlOut, yes );  // Convert to XHTML
00143   if ( ok )
00144     rc = tidySetErrorBuffer( tdoc, &amp;errbuf );      // Capture diagnostics
00145   if ( rc &gt;= 0 )
00146     rc = tidyParseString( tdoc, input );           // Parse the input
00147   if ( rc &gt;= 0 )
00148     rc = tidyCleanAndRepair( tdoc );               // Tidy it up!
00149   if ( rc &gt;= 0 )
00150     rc = tidyRunDiagnostics( tdoc );               // Kvetch
00151   if ( rc &gt; 1 )                                    // If error, force output.
00152     rc = ( tidyOptSetBool(tdoc, TidyForceOutput, yes) ? rc : -1 );
00153   if ( rc &gt;= 0 )
00154     rc = tidySaveBuffer( tdoc, &amp;output );          // Pretty Print
00155 
00156   if ( rc &gt;= 0 )
00157   {
00158     if ( rc &gt; 0 )
00159       printf( "\\nDiagnostics:\\n\\n\%s", errbuf.bp );
00160     printf( "\\nAnd here is the result:\\n\\n\%s", output.bp );
00161   }
00162   else
00163     printf( "A severe error (\%d) occurred.\\n", rc );
00164 
00165   tidyBufFree( &amp;output );
00166   tidyBufFree( &amp;errbuf );
00167   tidyRelease( tdoc );
00168   return rc;
00169 }
00170 </pre>
00171 ** @{
00172 */
00173 
00174 TIDY_EXPORT TidyDoc     tidyCreate(void);
00175 TIDY_EXPORT void        tidyRelease( TidyDoc tdoc );
00176 
00177 /** Let application store a chunk of data w/ each Tidy instance.
00178 **  Useful for callbacks.
00179 */
00180 TIDY_EXPORT void        tidySetAppData( TidyDoc tdoc, ulong appData );
00181 
00182 /** Get application data set previously */
00183 TIDY_EXPORT ulong       tidyGetAppData( TidyDoc tdoc );
00184 
00185 /** Get release date (version) for current library */
00186 TIDY_EXPORT ctmbstr     tidyReleaseDate(void);
00187 
00188 /* Diagnostics and Repair
00189 */
00190 
00191 /** Get status of current document. */
00192 TIDY_EXPORT int         tidyStatus( TidyDoc tdoc );
00193 
00194 /** Detected HTML version: 0, 2, 3 or 4 */
00195 TIDY_EXPORT int         tidyDetectedHtmlVersion( TidyDoc tdoc );
00196 
00197 /** Input is XHTML? */
00198 TIDY_EXPORT Bool        tidyDetectedXhtml( TidyDoc tdoc );
00199 
00200 /** Input is generic XML (not HTML or XHTML)? */
00201 TIDY_EXPORT Bool        tidyDetectedGenericXml( TidyDoc tdoc );
00202 
00203 /** Number of Tidy errors encountered.  If > 0, output is suppressed
00204 **  unless TidyForceOutput is set.
00205 */
00206 TIDY_EXPORT uint        tidyErrorCount( TidyDoc tdoc );
00207 
00208 /** Number of Tidy warnings encountered. */
00209 TIDY_EXPORT uint        tidyWarningCount( TidyDoc tdoc );
00210 
00211 /** Number of Tidy accessibility warnings encountered. */
00212 TIDY_EXPORT uint        tidyAccessWarningCount( TidyDoc tdoc );
00213 
00214 /** Number of Tidy configuration errors encountered. */
00215 TIDY_EXPORT uint        tidyConfigErrorCount( TidyDoc tdoc );
00216 
00217 /* Get/Set configuration options
00218 */
00219 /** Load an ASCII Tidy configuration file */
00220 TIDY_EXPORT int         tidyLoadConfig( TidyDoc tdoc, ctmbstr configFile );
00221 
00222 /** Load a Tidy configuration file with the specified character encoding */
00223 TIDY_EXPORT int         tidyLoadConfigEnc( TidyDoc tdoc, ctmbstr configFile,
00224                                            ctmbstr charenc );
00225 
00226 TIDY_EXPORT Bool        tidyFileExists( ctmbstr filename );
00227 
00228 
00229 /** Set the input/output character encoding for parsing markup.
00230 **  Values include: ascii, latin1, raw, utf8, iso2022, mac,
00231 **  win1252, utf16le, utf16be, utf16, big5 and shiftjis.  Case in-sensitive.
00232 */
00233 TIDY_EXPORT int         tidySetCharEncoding( TidyDoc tdoc, ctmbstr encnam );
00234 
00235 /** Set the input encoding for parsing markup.
00236 ** As for tidySetCharEncoding but only affects the input encoding
00237 **/
00238 TIDY_EXPORT int         tidySetInCharEncoding( TidyDoc tdoc, ctmbstr encnam );
00239 
00240 /** Set the output encoding.
00241 **/
00242 TIDY_EXPORT int         tidySetOutCharEncoding( TidyDoc tdoc, ctmbstr encnam );
00243 
00244 /** @} end Basic group */
00245 
00246 
00247 /** @defgroup Configuration Configuration Options
00248 **
00249 ** Functions for getting and setting Tidy configuration options.
00250 ** @{
00251 */
00252 
00253 /** Applications using TidyLib may want to augment command-line and
00254 **  configuration file options.  Setting this callback allows an application 
00255 **  developer to examine command-line and configuration file options after
00256 **  TidyLib has examined them and failed to recognize them.
00257 **/
00258 
00259 typedef Bool (*TidyOptCallback)( ctmbstr option, ctmbstr value );
00260 
00261 TIDY_EXPORT Bool          tidySetOptionCallback( TidyDoc tdoc, TidyOptCallback pOptCallback );
00262 
00263 /** Get option ID by name */
00264 TIDY_EXPORT TidyOptionId  tidyOptGetIdForName( ctmbstr optnam );
00265 
00266 /** Get iterator for list of option */
00267 /** 
00268 Example:
00269 <pre>
00270 TidyIterator itOpt = tidyGetOptionList( tdoc );
00271 while ( itOpt )
00272 {
00273   TidyOption opt = tidyGetNextOption( tdoc, &itOpt );
00274   .. get/set option values ..
00275 }
00276 </pre>
00277 */
00278 
00279 TIDY_EXPORT TidyIterator  tidyGetOptionList( TidyDoc tdoc );
00280 /** Get next Option */
00281 TIDY_EXPORT TidyOption    tidyGetNextOption( TidyDoc tdoc, TidyIterator* pos );
00282 
00283 /** Lookup option by ID */
00284 TIDY_EXPORT TidyOption    tidyGetOption( TidyDoc tdoc, TidyOptionId optId );
00285 /** Lookup option by name */
00286 TIDY_EXPORT TidyOption    tidyGetOptionByName( TidyDoc tdoc, ctmbstr optnam );
00287 
00288 /** Get ID of given Option */
00289 TIDY_EXPORT TidyOptionId  tidyOptGetId( TidyOption opt );
00290 
00291 /** Get name of given Option */
00292 TIDY_EXPORT ctmbstr       tidyOptGetName( TidyOption opt );
00293 
00294 /** Get datatype of given Option */
00295 TIDY_EXPORT TidyOptionType tidyOptGetType( TidyOption opt );
00296 
00297 /** Is Option read-only? */
00298 TIDY_EXPORT Bool          tidyOptIsReadOnly( TidyOption opt );
00299 
00300 /** Get category of given Option */
00301 TIDY_EXPORT TidyConfigCategory tidyOptGetCategory( TidyOption opt );
00302 
00303 /** Get default value of given Option as a string */
00304 TIDY_EXPORT ctmbstr       tidyOptGetDefault( TidyOption opt );
00305 
00306 /** Get default value of given Option as an unsigned integer */
00307 TIDY_EXPORT ulong         tidyOptGetDefaultInt( TidyOption opt );
00308 
00309 /** Get default value of given Option as a Boolean value */
00310 TIDY_EXPORT Bool          tidyOptGetDefaultBool( TidyOption opt );
00311 
00312 /** Iterate over Option "pick list" */
00313 TIDY_EXPORT TidyIterator  tidyOptGetPickList( TidyOption opt );
00314 /** Get next string value of Option "pick list" */
00315 TIDY_EXPORT ctmbstr       tidyOptGetNextPick( TidyOption opt, TidyIterator* pos );
00316 
00317 /** Get current Option value as a string */
00318 TIDY_EXPORT ctmbstr       tidyOptGetValue( TidyDoc tdoc, TidyOptionId optId );
00319 /** Set Option value as a string */
00320 TIDY_EXPORT Bool          tidyOptSetValue( TidyDoc tdoc, TidyOptionId optId, ctmbstr val );
00321 /** Set named Option value as a string.  Good if not sure of type. */
00322 TIDY_EXPORT Bool          tidyOptParseValue( TidyDoc tdoc, ctmbstr optnam, ctmbstr val );
00323 
00324 /** Get current Option value as an integer */
00325 TIDY_EXPORT ulong         tidyOptGetInt( TidyDoc tdoc, TidyOptionId optId );
00326 /** Set Option value as an integer */
00327 TIDY_EXPORT Bool          tidyOptSetInt( TidyDoc tdoc, TidyOptionId optId, ulong val );
00328 
00329 /** Get current Option value as a Boolean flag */
00330 TIDY_EXPORT Bool          tidyOptGetBool( TidyDoc tdoc, TidyOptionId optId );
00331 /** Set Option value as a Boolean flag */
00332 TIDY_EXPORT Bool          tidyOptSetBool( TidyDoc tdoc, TidyOptionId optId, Bool val );
00333 
00334 /** Reset option to default value by ID */
00335 TIDY_EXPORT Bool          tidyOptResetToDefault( TidyDoc tdoc, TidyOptionId opt );
00336 /** Reset all options to their default values */
00337 TIDY_EXPORT Bool          tidyOptResetAllToDefault( TidyDoc tdoc );
00338 
00339 /** Take a snapshot of current config settings */
00340 TIDY_EXPORT Bool          tidyOptSnapshot( TidyDoc tdoc );
00341 /** Reset config settings to snapshot (after document processing) */
00342 TIDY_EXPORT Bool          tidyOptResetToSnapshot( TidyDoc tdoc );
00343 
00344 /** Any settings different than default? */
00345 TIDY_EXPORT Bool          tidyOptDiffThanDefault( TidyDoc tdoc );
00346 /** Any settings different than snapshot? */
00347 TIDY_EXPORT Bool          tidyOptDiffThanSnapshot( TidyDoc tdoc );
00348 
00349 /** Copy current configuration settings from one document to another */
00350 TIDY_EXPORT Bool          tidyOptCopyConfig( TidyDoc tdocTo, TidyDoc tdocFrom );
00351 
00352 /** Get character encoding name.  Used with TidyCharEncoding,
00353 **  TidyOutCharEncoding, TidyInCharEncoding */
00354 TIDY_EXPORT ctmbstr       tidyOptGetEncName( TidyDoc tdoc, TidyOptionId optId );
00355 
00356 /** Get current pick list value for option by ID.  Useful for enum types. */
00357 TIDY_EXPORT ctmbstr       tidyOptGetCurrPick( TidyDoc tdoc, TidyOptionId optId);
00358 
00359 /** Iterate over user declared tags */
00360 TIDY_EXPORT TidyIterator  tidyOptGetDeclTagList( TidyDoc tdoc );
00361 /** Get next declared tag of specified type: TidyInlineTags, TidyBlockTags,
00362 **  TidyEmptyTags, TidyPreTags */
00363 TIDY_EXPORT ctmbstr       tidyOptGetNextDeclTag( TidyDoc tdoc, 
00364                                                  TidyOptionId optId,
00365                                                  TidyIterator* iter );
00366 /** @} end Configuration group */
00367 
00368 /** @defgroup IO  I/O and Messages
00369 **
00370 ** By default, Tidy will define, create and use 
00371 ** instances of input and output handlers for 
00372 ** standard C buffered I/O (i.e. FILE* stdin,
00373 ** FILE* stdout and FILE* stderr for content
00374 ** input, content output and diagnostic output,
00375 ** respectively.  A FILE* cfgFile input handler
00376 ** will be used for config files.  Command line
00377 ** options will just be set directly.
00378 **
00379 ** @{
00380 */
00381 
00382 /*****************
00383    Input Source
00384 *****************/
00385 /** Input Callback: get next byte of input */
00386 typedef int  (*TidyGetByteFunc)( ulong sourceData );
00387 
00388 /** Input Callback: unget a byte of input */
00389 typedef void (*TidyUngetByteFunc)( ulong sourceData, byte bt );
00390 
00391 /** Input Callback: is end of input? */
00392 typedef Bool (*TidyEOFFunc)( ulong sourceData );
00393 
00394 /** End of input "character" */
00395 #define EndOfStream (~0u)
00396 
00397 /** TidyInputSource - Delivers raw bytes of input
00398 */
00399 TIDY_STRUCT
00400 typedef struct _TidyInputSource
00401 {
00402   /* Instance data */
00403   ulong               sourceData;  /**< Input context.  Passed to callbacks */
00404 
00405   /* Methods */
00406   TidyGetByteFunc     getByte;     /**< Pointer to "get byte" callback */
00407   TidyUngetByteFunc   ungetByte;   /**< Pointer to "unget" callback */
00408   TidyEOFFunc         eof;         /**< Pointer to "eof" callback */
00409 } TidyInputSource;
00410 
00411 /** Facilitates user defined source by providing
00412 **  an entry point to marshal pointers-to-functions.
00413 **  Needed by .NET and possibly other language bindings.
00414 */
00415 TIDY_EXPORT Bool tidyInitSource( TidyInputSource*  source,
00416                                  void*             srcData,
00417                                  TidyGetByteFunc   gbFunc,
00418                                  TidyUngetByteFunc ugbFunc,
00419                                  TidyEOFFunc       endFunc );
00420 
00421 /** Helper: get next byte from input source */
00422 TIDY_EXPORT uint tidyGetByte( TidyInputSource* source );
00423 
00424 /** Helper: unget byte back to input source */
00425 TIDY_EXPORT void tidyUngetByte( TidyInputSource* source, uint byteValue );
00426 
00427 /** Helper: check if input source at end */
00428 TIDY_EXPORT Bool tidyIsEOF( TidyInputSource* source );
00429 
00430 
00431 /****************
00432    Output Sink
00433 ****************/
00434 /** Output callback: send a byte to output */
00435 typedef void (*TidyPutByteFunc)( ulong sinkData, byte bt );
00436 
00437 
00438 /** TidyOutputSink - accepts raw bytes of output
00439 */
00440 TIDY_STRUCT
00441 typedef struct _TidyOutputSink
00442 {
00443   /* Instance data */
00444   ulong               sinkData;  /**< Output context.  Passed to callbacks */
00445 
00446   /* Methods */
00447   TidyPutByteFunc     putByte;   /**< Pointer to "put byte" callback */
00448 } TidyOutputSink;
00449 
00450 /** Facilitates user defined sinks by providing
00451 **  an entry point to marshal pointers-to-functions.
00452 **  Needed by .NET and possibly other language bindings.
00453 */
00454 TIDY_EXPORT Bool tidyInitSink( TidyOutputSink* sink, 
00455                                void*           snkData,
00456                                TidyPutByteFunc pbFunc );
00457 
00458 /** Helper: send a byte to output */
00459 TIDY_EXPORT void tidyPutByte( TidyOutputSink* sink, uint byteValue );
00460 
00461 
00462 /** Callback to filter messages by diagnostic level:
00463 **  info, warning, etc.  Just set diagnostic output 
00464 **  handler to redirect all diagnostics output.  Return true
00465 **  to proceed with output, false to cancel.
00466 */
00467 typedef Bool (*TidyReportFilter)( TidyDoc tdoc, TidyReportLevel lvl,
00468                                   uint line, uint col, ctmbstr mssg );
00469 
00470 /** Give Tidy a filter callback to use */
00471 TIDY_EXPORT Bool    tidySetReportFilter( TidyDoc tdoc,
00472                                          TidyReportFilter filtCallback );
00473 
00474 /** Set error sink to named file */
00475 TIDY_EXPORT FILE*   tidySetErrorFile( TidyDoc tdoc, ctmbstr errfilnam );
00476 /** Set error sink to given buffer */
00477 TIDY_EXPORT int     tidySetErrorBuffer( TidyDoc tdoc, TidyBuffer* errbuf );
00478 /** Set error sink to given generic sink */
00479 TIDY_EXPORT int     tidySetErrorSink( TidyDoc tdoc, TidyOutputSink* sink );
00480 
00481 /** @} end IO group */
00482 
00483 
00484 /** @defgroup Memory  Memory Allocation
00485 **
00486 ** By default, Tidy will use its own wrappers
00487 ** around standard C malloc/free calls. 
00488 ** These wrappers will abort upon any failures.
00489 ** If any are set, all must be set.
00490 ** Pass NULL to clear previous setting.
00491 **
00492 ** May be used to set environment-specific allocators
00493 ** such as used by web server plugins, etc.
00494 **
00495 ** @{
00496 */
00497 
00498 /** Callback for "malloc" replacement */
00499 typedef void* (*TidyMalloc)( size_t len );
00500 /** Callback for "realloc" replacement */
00501 typedef void* (*TidyRealloc)( void* buf, size_t len );
00502 /** Callback for "free" replacement */
00503 typedef void  (*TidyFree)( void* buf );
00504 /** Callback for "out of memory" panic state */
00505 typedef void  (*TidyPanic)( ctmbstr mssg );
00506 
00507 /** Give Tidy a malloc() replacement */
00508 TIDY_EXPORT Bool        tidySetMallocCall( TidyMalloc fmalloc );
00509 /** Give Tidy a realloc() replacement */
00510 TIDY_EXPORT Bool        tidySetReallocCall( TidyRealloc frealloc );
00511 /** Give Tidy a free() replacement */
00512 TIDY_EXPORT Bool        tidySetFreeCall( TidyFree ffree );
00513 /** Give Tidy an "out of memory" handler */
00514 TIDY_EXPORT Bool        tidySetPanicCall( TidyPanic fpanic );
00515 
00516 /** @} end Memory group */
00517 
00518 /* TODO: Catalog all messages for easy translation
00519 TIDY_EXPORT ctmbstr     tidyLookupMessage( int errorNo );
00520 */
00521 
00522 
00523 
00524 /** @defgroup Parse Document Parse
00525 **
00526 ** Parse markup from a given input source.  String and filename 
00527 ** functions added for convenience.  HTML/XHTML version determined
00528 ** from input.
00529 ** @{
00530 */
00531 
00532 /** Parse markup in named file */
00533 TIDY_EXPORT int         tidyParseFile( TidyDoc tdoc, ctmbstr filename );
00534 
00535 /** Parse markup from the standard input */
00536 TIDY_EXPORT int         tidyParseStdin( TidyDoc tdoc );
00537 
00538 /** Parse markup in given string */
00539 TIDY_EXPORT int         tidyParseString( TidyDoc tdoc, ctmbstr content );
00540 
00541 /** Parse markup in given buffer */
00542 TIDY_EXPORT int         tidyParseBuffer( TidyDoc tdoc, TidyBuffer* buf );
00543 
00544 /** Parse markup in given generic input source */
00545 TIDY_EXPORT int         tidyParseSource( TidyDoc tdoc, TidyInputSource* source);
00546 
00547 /** @} End Parse group */
00548 
00549 
00550 /** @defgroup Clean Diagnostics and Repair
00551 **
00552 ** @{
00553 */
00554 /** Execute configured cleanup and repair operations on parsed markup */
00555 TIDY_EXPORT int         tidyCleanAndRepair( TidyDoc tdoc );
00556 
00557 /** Run configured diagnostics on parsed and repaired markup. 
00558 **  Must call tidyCleanAndRepair() first.
00559 */
00560 TIDY_EXPORT int         tidyRunDiagnostics( TidyDoc tdoc );
00561 
00562 /** @} end Clean group */
00563 
00564 
00565 /** @defgroup Save Document Save Functions
00566 **
00567 ** Save currently parsed document to the given output sink.  File name
00568 ** and string/buffer functions provided for convenience.
00569 ** @{
00570 */
00571 
00572 /** Save to named file */
00573 TIDY_EXPORT int         tidySaveFile( TidyDoc tdoc, ctmbstr filename );
00574 
00575 /** Save to standard output (FILE*) */
00576 TIDY_EXPORT int         tidySaveStdout( TidyDoc tdoc );
00577 
00578 /** Save to given TidyBuffer object */
00579 TIDY_EXPORT int         tidySaveBuffer( TidyDoc tdoc, TidyBuffer* buf );
00580 
00581 /** Save document to application buffer.  If buffer is not big enough,
00582 **  ENOMEM will be returned and the necessary buffer size will be placed
00583 **  in *buflen.
00584 */
00585 TIDY_EXPORT int         tidySaveString( TidyDoc tdoc,
00586                                         tmbstr buffer, uint* buflen );
00587 
00588 /** Save to given generic output sink */
00589 TIDY_EXPORT int         tidySaveSink( TidyDoc tdoc, TidyOutputSink* sink );
00590 
00591 /** @} end Save group */
00592 
00593 
00594 /** @addtogroup Basic
00595 ** @{
00596 */
00597 /** Save current settings to named file.
00598     Only non-default values are written. */
00599 TIDY_EXPORT int         tidyOptSaveFile( TidyDoc tdoc, ctmbstr cfgfil );
00600 
00601 /** Save current settings to given output sink.
00602     Only non-default values are written. */
00603 TIDY_EXPORT int         tidyOptSaveSink( TidyDoc tdoc, TidyOutputSink* sink );
00604 
00605 
00606 /* Error reporting functions 
00607 */
00608 
00609 /** Write more complete information about errors to current error sink. */
00610 TIDY_EXPORT void        tidyErrorSummary( TidyDoc tdoc );
00611 
00612 /** Write more general information about markup to current error sink. */
00613 TIDY_EXPORT void        tidyGeneralInfo( TidyDoc tdoc );
00614 
00615 /** @} end Basic group (again) */
00616 
00617 
00618 /** @defgroup Tree Document Tree
00619 **
00620 ** A parsed and, optionally, repaired document is
00621 ** represented by Tidy as a Tree, much like a W3C DOM.
00622 ** This tree may be traversed using these functions.
00623 ** The following snippet gives a basic idea how these
00624 ** functions can be used.
00625 **
00626 <pre>
00627 void dumpNode( TidyNode tnod, int indent )
00628 {
00629   TidyNode child;
00630 
00631   for ( child = tidyGetChild(tnod); child; child = tidyGetNext(child) )
00632   {
00633     ctmbstr name = tidyNodeGetName( child );
00634     if ( !name )
00635     {
00636       switch ( tidyNodeGetType(child) )
00637       {
00638       case TidyNode_Root:       name = "Root";                    break;
00639       case TidyNode_DocType:    name = "DOCTYPE";                 break;
00640       case TidyNode_Comment:    name = "Comment";                 break;
00641       case TidyNode_ProcIns:    name = "Processing Instruction";  break;
00642       case TidyNode_Text:       name = "Text";                    break;
00643       case TidyNode_CDATA:      name = "CDATA";                   break;
00644       case TidyNode_Section:    name = "XML Section";             break;
00645       case TidyNode_Asp:        name = "ASP";                     break;
00646       case TidyNode_Jste:       name = "JSTE";                    break;
00647       case TidyNode_Php:        name = "PHP";                     break;
00648       case TidyNode_XmlDecl:    name = "XML Declaration";         break;
00649 
00650       case TidyNode_Start:
00651       case TidyNode_End:
00652       case TidyNode_StartEnd:
00653       default:
00654         assert( name != NULL ); // Shouldn't get here
00655         break;
00656       }
00657     }
00658     assert( name != NULL );
00659     printf( "\%*.*sNode: \%s\\n", indent, indent, tidy );
00660     dumpNode( child, indent + 4 );
00661   }
00662 }
00663 
00664 void dumpDoc( TidyDoc tdoc )
00665 {
00666   dumpNode( tidyGetRoot(tdoc), 0 );
00667 }
00668 
00669 void dumpBody( TidyDoc tdoc )
00670 {
00671   dumpNode( tidyGetBody(tdoc), 0 );
00672 }
00673 </pre>
00674 
00675 @{
00676 
00677 */
00678 
00679 TIDY_EXPORT TidyNode    tidyGetRoot( TidyDoc tdoc );
00680 TIDY_EXPORT TidyNode    tidyGetHtml( TidyDoc tdoc );
00681 TIDY_EXPORT TidyNode    tidyGetHead( TidyDoc tdoc );
00682 TIDY_EXPORT TidyNode    tidyGetBody( TidyDoc tdoc );
00683 
00684 /* parent / child */
00685 TIDY_EXPORT TidyNode    tidyGetParent( TidyNode tnod );
00686 TIDY_EXPORT TidyNode    tidyGetChild( TidyNode tnod );
00687 
00688 /* siblings */
00689 TIDY_EXPORT TidyNode    tidyGetNext( TidyNode tnod );
00690 TIDY_EXPORT TidyNode    tidyGetPrev( TidyNode tnod );
00691 
00692 /* Null for non-element nodes and all pure HTML
00693 TIDY_EXPORT ctmbstr     tidyNodeNsLocal( TidyNode tnod );
00694 TIDY_EXPORT ctmbstr     tidyNodeNsPrefix( TidyNode tnod );
00695 TIDY_EXPORT ctmbstr     tidyNodeNsUri( TidyNode tnod );
00696 */
00697 
00698 /* Iterate over attribute values */
00699 TIDY_EXPORT TidyAttr    tidyAttrFirst( TidyNode tnod );
00700 TIDY_EXPORT TidyAttr    tidyAttrNext( TidyAttr tattr );
00701 
00702 TIDY_EXPORT ctmbstr     tidyAttrName( TidyAttr tattr );
00703 TIDY_EXPORT ctmbstr     tidyAttrValue( TidyAttr tattr );
00704 
00705 /* Null for pure HTML
00706 TIDY_EXPORT ctmbstr     tidyAttrNsLocal( TidyAttr tattr );
00707 TIDY_EXPORT ctmbstr     tidyAttrNsPrefix( TidyAttr tattr );
00708 TIDY_EXPORT ctmbstr     tidyAttrNsUri( TidyAttr tattr );
00709 */
00710 
00711 /** @} end Tree group */
00712 
00713 
00714 /** @defgroup NodeAsk Node Interrogation
00715 **
00716 ** Get information about any givent node.
00717 ** @{
00718 */
00719 
00720 /* Node info */
00721 TIDY_EXPORT TidyNodeType tidyNodeGetType( TidyNode tnod );
00722 TIDY_EXPORT ctmbstr     tidyNodeGetName( TidyNode tnod );
00723 
00724 TIDY_EXPORT Bool tidyNodeIsText( TidyNode tnod );
00725 TIDY_EXPORT Bool tidyNodeIsProp( TidyDoc tdoc, TidyNode tnod );
00726 TIDY_EXPORT Bool tidyNodeIsHeader( TidyNode tnod ); /* h1, h2, ... */
00727 
00728 TIDY_EXPORT Bool tidyNodeHasText( TidyDoc tdoc, TidyNode tnod );
00729 TIDY_EXPORT Bool tidyNodeGetText( TidyDoc tdoc, TidyNode tnod, TidyBuffer* buf );
00730 
00731 TIDY_EXPORT TidyTagId tidyNodeGetId( TidyNode tnod );
00732 
00733 TIDY_EXPORT uint tidyNodeLine( TidyNode tnod );
00734 TIDY_EXPORT uint tidyNodeColumn( TidyNode tnod );
00735 
00736 TIDY_EXPORT Bool tidyNodeIsHTML( TidyNode tnod );
00737 TIDY_EXPORT Bool tidyNodeIsHEAD( TidyNode tnod );
00738 TIDY_EXPORT Bool tidyNodeIsTITLE( TidyNode tnod );
00739 TIDY_EXPORT Bool tidyNodeIsBASE( TidyNode tnod );
00740 TIDY_EXPORT Bool tidyNodeIsMETA( TidyNode tnod );
00741 TIDY_EXPORT Bool tidyNodeIsBODY( TidyNode tnod );
00742 TIDY_EXPORT Bool tidyNodeIsFRAMESET( TidyNode tnod );
00743 TIDY_EXPORT Bool tidyNodeIsFRAME( TidyNode tnod );
00744 TIDY_EXPORT Bool tidyNodeIsIFRAME( TidyNode tnod );
00745 TIDY_EXPORT Bool tidyNodeIsNOFRAMES( TidyNode tnod );
00746 TIDY_EXPORT Bool tidyNodeIsHR( TidyNode tnod );
00747 TIDY_EXPORT Bool tidyNodeIsH1( TidyNode tnod );
00748 TIDY_EXPORT Bool tidyNodeIsH2( TidyNode tnod );
00749 TIDY_EXPORT Bool tidyNodeIsPRE( TidyNode tnod );
00750 TIDY_EXPORT Bool tidyNodeIsLISTING( TidyNode tnod );
00751 TIDY_EXPORT Bool tidyNodeIsP( TidyNode tnod );
00752 TIDY_EXPORT Bool tidyNodeIsUL( TidyNode tnod );
00753 TIDY_EXPORT Bool tidyNodeIsOL( TidyNode tnod );
00754 TIDY_EXPORT Bool tidyNodeIsDL( TidyNode tnod );
00755 TIDY_EXPORT Bool tidyNodeIsDIR( TidyNode tnod );
00756 TIDY_EXPORT Bool tidyNodeIsLI( TidyNode tnod );
00757 TIDY_EXPORT Bool tidyNodeIsDT( TidyNode tnod );
00758 TIDY_EXPORT Bool tidyNodeIsDD( TidyNode tnod );
00759 TIDY_EXPORT Bool tidyNodeIsTABLE( TidyNode tnod );
00760 TIDY_EXPORT Bool tidyNodeIsCAPTION( TidyNode tnod );
00761 TIDY_EXPORT Bool tidyNodeIsTD( TidyNode tnod );
00762 TIDY_EXPORT Bool tidyNodeIsTH( TidyNode tnod );
00763 TIDY_EXPORT Bool tidyNodeIsTR( TidyNode tnod );
00764 TIDY_EXPORT Bool tidyNodeIsCOL( TidyNode tnod );
00765 TIDY_EXPORT Bool tidyNodeIsCOLGROUP( TidyNode tnod );
00766 TIDY_EXPORT Bool tidyNodeIsBR( TidyNode tnod );
00767 TIDY_EXPORT Bool tidyNodeIsA( TidyNode tnod );
00768 TIDY_EXPORT Bool tidyNodeIsLINK( TidyNode tnod );
00769 TIDY_EXPORT Bool tidyNodeIsB( TidyNode tnod );
00770 TIDY_EXPORT Bool tidyNodeIsI( TidyNode tnod );
00771 TIDY_EXPORT Bool tidyNodeIsSTRONG( TidyNode tnod );
00772 TIDY_EXPORT Bool tidyNodeIsEM( TidyNode tnod );
00773 TIDY_EXPORT Bool tidyNodeIsBIG( TidyNode tnod );
00774 TIDY_EXPORT Bool tidyNodeIsSMALL( TidyNode tnod );
00775 TIDY_EXPORT Bool tidyNodeIsPARAM( TidyNode tnod );
00776 TIDY_EXPORT Bool tidyNodeIsOPTION( TidyNode tnod );
00777 TIDY_EXPORT Bool tidyNodeIsOPTGROUP( TidyNode tnod );
00778 TIDY_EXPORT Bool tidyNodeIsIMG( TidyNode tnod );
00779 TIDY_EXPORT Bool tidyNodeIsMAP( TidyNode tnod );
00780 TIDY_EXPORT Bool tidyNodeIsAREA( TidyNode tnod );
00781 TIDY_EXPORT Bool tidyNodeIsNOBR( TidyNode tnod );
00782 TIDY_EXPORT Bool tidyNodeIsWBR( TidyNode tnod );
00783 TIDY_EXPORT Bool tidyNodeIsFONT( TidyNode tnod );
00784 TIDY_EXPORT Bool tidyNodeIsLAYER( TidyNode tnod );
00785 TIDY_EXPORT Bool tidyNodeIsSPACER( TidyNode tnod );
00786 TIDY_EXPORT Bool tidyNodeIsCENTER( TidyNode tnod );
00787 TIDY_EXPORT Bool tidyNodeIsSTYLE( TidyNode tnod );
00788 TIDY_EXPORT Bool tidyNodeIsSCRIPT( TidyNode tnod );
00789 TIDY_EXPORT Bool tidyNodeIsNOSCRIPT( TidyNode tnod );
00790 TIDY_EXPORT Bool tidyNodeIsFORM( TidyNode tnod );
00791 TIDY_EXPORT Bool tidyNodeIsTEXTAREA( TidyNode tnod );
00792 TIDY_EXPORT Bool tidyNodeIsBLOCKQUOTE( TidyNode tnod );
00793 TIDY_EXPORT Bool tidyNodeIsAPPLET( TidyNode tnod );
00794 TIDY_EXPORT Bool tidyNodeIsOBJECT( TidyNode tnod );
00795 TIDY_EXPORT Bool tidyNodeIsDIV( TidyNode tnod );
00796 TIDY_EXPORT Bool tidyNodeIsSPAN( TidyNode tnod );
00797 TIDY_EXPORT Bool tidyNodeIsINPUT( TidyNode tnod );
00798 TIDY_EXPORT Bool tidyNodeIsQ( TidyNode tnod );
00799 TIDY_EXPORT Bool tidyNodeIsLABEL( TidyNode tnod );
00800 TIDY_EXPORT Bool tidyNodeIsH3( TidyNode tnod );
00801 TIDY_EXPORT Bool tidyNodeIsH4( TidyNode tnod );
00802 TIDY_EXPORT Bool tidyNodeIsH5( TidyNode tnod );
00803 TIDY_EXPORT Bool tidyNodeIsH6( TidyNode tnod );
00804 TIDY_EXPORT Bool tidyNodeIsADDRESS( TidyNode tnod );
00805 TIDY_EXPORT Bool tidyNodeIsXMP( TidyNode tnod );
00806 TIDY_EXPORT Bool tidyNodeIsSELECT( TidyNode tnod );
00807 TIDY_EXPORT Bool tidyNodeIsBLINK( TidyNode tnod );
00808 TIDY_EXPORT Bool tidyNodeIsMARQUEE( TidyNode tnod );
00809 TIDY_EXPORT Bool tidyNodeIsEMBED( TidyNode tnod );
00810 TIDY_EXPORT Bool tidyNodeIsBASEFONT( TidyNode tnod );
00811 TIDY_EXPORT Bool tidyNodeIsISINDEX( TidyNode tnod );
00812 TIDY_EXPORT Bool tidyNodeIsS( TidyNode tnod );
00813 TIDY_EXPORT Bool tidyNodeIsSTRIKE( TidyNode tnod );
00814 TIDY_EXPORT Bool tidyNodeIsU( TidyNode tnod );
00815 TIDY_EXPORT Bool tidyNodeIsMENU( TidyNode tnod );
00816 
00817 /** @} End NodeAsk group */
00818 
00819 
00820 /** @defgroup Attribute Attribute Interrogation
00821 **
00822 ** Get information about any given attribute.
00823 ** @{
00824 */
00825 
00826 TIDY_EXPORT TidyAttrId tidyAttrGetId( TidyAttr tattr );
00827 TIDY_EXPORT Bool tidyAttrIsEvent( TidyAttr tattr );
00828 TIDY_EXPORT Bool tidyAttrIsProp( TidyAttr tattr );
00829 
00830 TIDY_EXPORT Bool tidyAttrIsHREF( TidyAttr tattr );
00831 TIDY_EXPORT Bool tidyAttrIsSRC( TidyAttr tattr );
00832 TIDY_EXPORT Bool tidyAttrIsID( TidyAttr tattr );
00833 TIDY_EXPORT Bool tidyAttrIsNAME( TidyAttr tattr );
00834 TIDY_EXPORT Bool tidyAttrIsSUMMARY( TidyAttr tattr );
00835 TIDY_EXPORT Bool tidyAttrIsALT( TidyAttr tattr );
00836 TIDY_EXPORT Bool tidyAttrIsLONGDESC( TidyAttr tattr );
00837 TIDY_EXPORT Bool tidyAttrIsUSEMAP( TidyAttr tattr );
00838 TIDY_EXPORT Bool tidyAttrIsISMAP( TidyAttr tattr );
00839 TIDY_EXPORT Bool tidyAttrIsLANGUAGE( TidyAttr tattr );
00840 TIDY_EXPORT Bool tidyAttrIsTYPE( TidyAttr tattr );
00841 TIDY_EXPORT Bool tidyAttrIsVALUE( TidyAttr tattr );
00842 TIDY_EXPORT Bool tidyAttrIsCONTENT( TidyAttr tattr );
00843 TIDY_EXPORT Bool tidyAttrIsTITLE( TidyAttr tattr );
00844 TIDY_EXPORT Bool tidyAttrIsXMLNS( TidyAttr tattr );
00845 TIDY_EXPORT Bool tidyAttrIsDATAFLD( TidyAttr tattr );
00846 TIDY_EXPORT Bool tidyAttrIsWIDTH( TidyAttr tattr );
00847 TIDY_EXPORT Bool tidyAttrIsHEIGHT( TidyAttr tattr );
00848 TIDY_EXPORT Bool tidyAttrIsFOR( TidyAttr tattr );
00849 TIDY_EXPORT Bool tidyAttrIsSELECTED( TidyAttr tattr );
00850 TIDY_EXPORT Bool tidyAttrIsCHECKED( TidyAttr tattr );
00851 TIDY_EXPORT Bool tidyAttrIsLANG( TidyAttr tattr );
00852 TIDY_EXPORT Bool tidyAttrIsTARGET( TidyAttr tattr );
00853 TIDY_EXPORT Bool tidyAttrIsHTTP_EQUIV( TidyAttr tattr );
00854 TIDY_EXPORT Bool tidyAttrIsREL( TidyAttr tattr );
00855 TIDY_EXPORT Bool tidyAttrIsOnMOUSEMOVE( TidyAttr tattr );
00856 TIDY_EXPORT Bool tidyAttrIsOnMOUSEDOWN( TidyAttr tattr );
00857 TIDY_EXPORT Bool tidyAttrIsOnMOUSEUP( TidyAttr tattr );
00858 TIDY_EXPORT Bool tidyAttrIsOnCLICK( TidyAttr tattr );
00859 TIDY_EXPORT Bool tidyAttrIsOnMOUSEOVER( TidyAttr tattr );
00860 TIDY_EXPORT Bool tidyAttrIsOnMOUSEOUT( TidyAttr tattr );
00861 TIDY_EXPORT Bool tidyAttrIsOnKEYDOWN( TidyAttr tattr );
00862 TIDY_EXPORT Bool tidyAttrIsOnKEYUP( TidyAttr tattr );
00863 TIDY_EXPORT Bool tidyAttrIsOnKEYPRESS( TidyAttr tattr );
00864 TIDY_EXPORT Bool tidyAttrIsOnFOCUS( TidyAttr tattr );
00865 TIDY_EXPORT Bool tidyAttrIsOnBLUR( TidyAttr tattr );
00866 TIDY_EXPORT Bool tidyAttrIsBGCOLOR( TidyAttr tattr );
00867 TIDY_EXPORT Bool tidyAttrIsLINK( TidyAttr tattr );
00868 TIDY_EXPORT Bool tidyAttrIsALINK( TidyAttr tattr );
00869 TIDY_EXPORT Bool tidyAttrIsVLINK( TidyAttr tattr );
00870 TIDY_EXPORT Bool tidyAttrIsTEXT( TidyAttr tattr );
00871 TIDY_EXPORT Bool tidyAttrIsSTYLE( TidyAttr tattr );
00872 TIDY_EXPORT Bool tidyAttrIsABBR( TidyAttr tattr );
00873 TIDY_EXPORT Bool tidyAttrIsCOLSPAN( TidyAttr tattr );
00874 TIDY_EXPORT Bool tidyAttrIsROWSPAN( TidyAttr tattr );
00875 
00876 /** @} end AttrAsk group */
00877 
00878 
00879 /** @defgroup AttrGet Attribute Retrieval
00880 **
00881 ** Lookup an attribute from a given node
00882 ** @{
00883 */
00884 
00885 
00886 TIDY_EXPORT TidyAttr tidyAttrGetHREF( TidyNode tnod );
00887 TIDY_EXPORT TidyAttr tidyAttrGetSRC( TidyNode tnod );
00888 TIDY_EXPORT TidyAttr tidyAttrGetID( TidyNode tnod );
00889 TIDY_EXPORT TidyAttr tidyAttrGetNAME( TidyNode tnod );
00890 TIDY_EXPORT TidyAttr tidyAttrGetSUMMARY( TidyNode tnod );
00891 TIDY_EXPORT TidyAttr tidyAttrGetALT( TidyNode tnod );
00892 TIDY_EXPORT TidyAttr tidyAttrGetLONGDESC( TidyNode tnod );
00893 TIDY_EXPORT TidyAttr tidyAttrGetUSEMAP( TidyNode tnod );
00894 TIDY_EXPORT TidyAttr tidyAttrGetISMAP( TidyNode tnod );
00895 TIDY_EXPORT TidyAttr tidyAttrGetLANGUAGE( TidyNode tnod );
00896 TIDY_EXPORT TidyAttr tidyAttrGetTYPE( TidyNode tnod );
00897 TIDY_EXPORT TidyAttr tidyAttrGetVALUE( TidyNode tnod );
00898 TIDY_EXPORT TidyAttr tidyAttrGetCONTENT( TidyNode tnod );
00899 TIDY_EXPORT TidyAttr tidyAttrGetTITLE( TidyNode tnod );
00900 TIDY_EXPORT TidyAttr tidyAttrGetXMLNS( TidyNode tnod );
00901 TIDY_EXPORT TidyAttr tidyAttrGetDATAFLD( TidyNode tnod );
00902 TIDY_EXPORT TidyAttr tidyAttrGetWIDTH( TidyNode tnod );
00903 TIDY_EXPORT TidyAttr tidyAttrGetHEIGHT( TidyNode tnod );
00904 TIDY_EXPORT TidyAttr tidyAttrGetFOR( TidyNode tnod );
00905 TIDY_EXPORT TidyAttr tidyAttrGetSELECTED( TidyNode tnod );
00906 TIDY_EXPORT TidyAttr tidyAttrGetCHECKED( TidyNode tnod );
00907 TIDY_EXPORT TidyAttr tidyAttrGetLANG( TidyNode tnod );
00908 TIDY_EXPORT TidyAttr tidyAttrGetTARGET( TidyNode tnod );
00909 TIDY_EXPORT TidyAttr tidyAttrGetHTTP_EQUIV( TidyNode tnod );
00910 TIDY_EXPORT TidyAttr tidyAttrGetREL( TidyNode tnod );
00911 TIDY_EXPORT TidyAttr tidyAttrGetOnMOUSEMOVE( TidyNode tnod );
00912 TIDY_EXPORT TidyAttr tidyAttrGetOnMOUSEDOWN( TidyNode tnod );
00913 TIDY_EXPORT TidyAttr tidyAttrGetOnMOUSEUP( TidyNode tnod );
00914 TIDY_EXPORT TidyAttr tidyAttrGetOnCLICK( TidyNode tnod );
00915 TIDY_EXPORT TidyAttr tidyAttrGetOnMOUSEOVER( TidyNode tnod );
00916 TIDY_EXPORT TidyAttr tidyAttrGetOnMOUSEOUT( TidyNode tnod );
00917 TIDY_EXPORT TidyAttr tidyAttrGetOnKEYDOWN( TidyNode tnod );
00918 TIDY_EXPORT TidyAttr tidyAttrGetOnKEYUP( TidyNode tnod );
00919 TIDY_EXPORT TidyAttr tidyAttrGetOnKEYPRESS( TidyNode tnod );
00920 TIDY_EXPORT TidyAttr tidyAttrGetOnFOCUS( TidyNode tnod );
00921 TIDY_EXPORT TidyAttr tidyAttrGetOnBLUR( TidyNode tnod );
00922 TIDY_EXPORT TidyAttr tidyAttrGetBGCOLOR( TidyNode tnod );
00923 TIDY_EXPORT TidyAttr tidyAttrGetLINK( TidyNode tnod );
00924 TIDY_EXPORT TidyAttr tidyAttrGetALINK( TidyNode tnod );
00925 TIDY_EXPORT TidyAttr tidyAttrGetVLINK( TidyNode tnod );
00926 TIDY_EXPORT TidyAttr tidyAttrGetTEXT( TidyNode tnod );
00927 TIDY_EXPORT TidyAttr tidyAttrGetSTYLE( TidyNode tnod );
00928 TIDY_EXPORT TidyAttr tidyAttrGetABBR( TidyNode tnod );
00929 TIDY_EXPORT TidyAttr tidyAttrGetCOLSPAN( TidyNode tnod );
00930 TIDY_EXPORT TidyAttr tidyAttrGetROWSPAN( TidyNode tnod );
00931 
00932 
00933 /** @} end AttrGet group */
00934 
00935 #ifdef __cplusplus
00936 }  /* extern "C" */
00937 #endif
00938 #endif /* __TIDY_H__ */

Generated on Tue Oct 5 11:39:53 2004 for HTML Tidy by doxygen 1.3.6