XMQWrite ()

bool
(*XMQWrite) (void *writer_state,
             const char *start,
             const char *stop);

Any function implementing XMQWrite must handle stop == NULL.

XMQNodeCallback ()

XMQProceed
(*XMQNodeCallback) (XMQDoc *doc,
                    XMQNode *node,
                    void *user_data);

xmqDetectContentType ()

XMQContentType
xmqDetectContentType (const char *start,
                      const char *stop);

Detect the content type xmq/xml/html/json by examining a few leading non-whitespace words/characters.

xmqParseErrorToString ()

const char *
xmqParseErrorToString (XMQParseError e);

xmqNewParseCallbacks ()

XMQParseCallbacks *
xmqNewParseCallbacks ();

Allocate an empty XMQParseCallback structure. All callbacks are NULL and none will be called.

xmqFreeParseCallbacks ()

void
xmqFreeParseCallbacks (XMQParseCallbacks *cb);

Free the XMQParseCallback structure.

xmqSetupParseCallbacksColorizeTokens ()

void
xmqSetupParseCallbacksColorizeTokens (XMQParseCallbacks *state,
                                      XMQRenderFormat render_format);

Used to colorize xmq input, without building a parse tree.

xmqSetupParseCallbacksDebugTokens ()

void
xmqSetupParseCallbacksDebugTokens (XMQParseCallbacks *state);

Used to debug location, type of tokens.

xmqSetupParseCallbacksDebugContent ()

void
xmqSetupParseCallbacksDebugContent (XMQParseCallbacks *state);

Used debug the decoded content.

xmqTokenizeBuffer ()

bool
xmqTokenizeBuffer (XMQParseState *state,
                   const char *start,
                   const char *stop);

xmqTokenizeFile ()

bool
xmqTokenizeFile (XMQParseState *state,
                 const char *file);

xmqTokenizeFileDescriptor ()

bool
xmqTokenizeFileDescriptor (XMQParseState *state,
                           int fd);

xmqNewParseState ()

XMQParseState *
xmqNewParseState (XMQParseCallbacks *callbacks,
                  XMQOutputSettings *settings);

Now prepare a parse state that is used to actually parse an xmq file. The print settings can be referenced from the callbacks for example when tokenizing.

xmqFreeParseState ()

void
xmqFreeParseState (XMQParseState *state);

Free the memory allocated for the state.

xmqSetStateSourceName ()

void
xmqSetStateSourceName (XMQParseState *state,
                       const char *source_name);

Set the source name to make error message more readable when parsing fails. The source name is often the file name, but can be "-" for stdin or anything you like.

xmqStateErrno ()

int
xmqStateErrno (XMQParseState *state);

If the parse fails then use this function to get the integer value of XMQParseError.

xmqStateErrorMsg ()

const char *
xmqStateErrorMsg (XMQParseState *state);

If the parse fails then use this function to get a string explaining the error.

xmqSetPrintAllParsesIXML ()

void
xmqSetPrintAllParsesIXML (XMQParseState *state,
                          bool all_parses);

If the parse is ambiguous generate all possible trees.

xmqSetTryToRecoverIXML ()

void
xmqSetTryToRecoverIXML (XMQParseState *state,
                        bool try_recover);

If the parse fails then try to recover. Default is to fail.

xmqNewDoc ()

XMQDoc *
xmqNewDoc ();

Create an empty document object.

xmqSetDocSourceName ()

void
xmqSetDocSourceName (XMQDoc *doq,
                     const char *source_name);

Set the source name to make error message more readable when parsing fails. The source name is often the file name, but can be "-" for stdin or anything you like.

xmqGetDocSourceName ()

const char *
xmqGetDocSourceName (XMQDoc *doq);

Returns the source name used to make error message more readable when parsing fails. The source name is often the file name, but can be "-" for stdin or anything you like.

xmqGetOriginalContentType ()

XMQContentType
xmqGetOriginalContentType (XMQDoc *doq);

If available, return the original content type (xmq/htmq/xml/html/json/text) of this document.

xmqGetOriginalSize ()

size_t
xmqGetOriginalSize (XMQDoc *doq);

If available, return the size of the original content, ie the loaded file size.

xmqSetOriginalSize ()

void
xmqSetOriginalSize (XMQDoc *doq,
                    size_t size);

Override the original size of the document.

xmqGetRootNode ()

XMQNode *
xmqGetRootNode (XMQDoc *doq);

Get root node suitable for xmqForeach.

xmqGetImplementationDoc ()

void *
xmqGetImplementationDoc (XMQDoc *doq);

Get the underlying implementation doc, could be an xmlDocPtr from libxml2 for example.

xmqSetImplementationDoc ()

void
xmqSetImplementationDoc (XMQDoc *doq,
                         void *doc);

Set the underlying implementation doc, could be an xmlDocPtr from libxml2 for example.

xmqFreeDoc ()

void
xmqFreeDoc (XMQDoc *doc);

Free the document object and all associated memory.

xmqParseFile ()

bool
xmqParseFile (XMQDoc *doc,
              const char *file,
              const char *implicit_root,
              int flags);

Parse a file, or if file is NULL, read from stdin.

xmqParseBuffer ()

bool
xmqParseBuffer (XMQDoc *doc,
                const char *start,
                const char *stop,
                const char *implicit_root,
                int flags);

Parse a buffer or a file and create a document. The xmq format permits multiple root nodes if an implicit root is supplied.

xmqParseReader ()

bool
xmqParseReader (XMQDoc *doc,
                XMQReader *reader,
                const char *implicit_root,
                int flags);

Parse data fetched with a reader and create a document. The xmq format permits multiple root nodes if an implicit root is supplied.

xmqNewOutputSettings ()

XMQOutputSettings *
xmqNewOutputSettings ();

xmqFreeOutputSettings ()

void
xmqFreeOutputSettings (XMQOutputSettings *os);

xmqSetAddIndent ()

void
xmqSetAddIndent (XMQOutputSettings *os,
                 int add_indent);

xmqSetCompact ()

void
xmqSetCompact (XMQOutputSettings *os,
               bool compact);

xmqSetUseColor ()

void
xmqSetUseColor (XMQOutputSettings *os,
                bool use_color);

xmqSetBackgroundMode ()

void
xmqSetBackgroundMode (XMQOutputSettings *os,
                      bool bg_dark_mode);

xmqSetPreferDoubleQuotes ()

void
xmqSetPreferDoubleQuotes (XMQOutputSettings *os,
                          bool prefer_double_quotes);

xmqSetEscapeNewlines ()

void
xmqSetEscapeNewlines (XMQOutputSettings *os,
                      bool escape_newlines);

xmqSetEscapeNon7bit ()

void
xmqSetEscapeNon7bit (XMQOutputSettings *os,
                     bool escape_non_7bit);

xmqSetEscapeTabs ()

void
xmqSetEscapeTabs (XMQOutputSettings *os,
                  bool escape_tabs);

xmqSetOutputFormat ()

void
xmqSetOutputFormat (XMQOutputSettings *os,
                    XMQContentType output_format);

xmqSetOmitDecl ()

void
xmqSetOmitDecl (XMQOutputSettings *os,
                bool omit_decl);

xmqSetRenderFormat ()

void
xmqSetRenderFormat (XMQOutputSettings *os,
                    XMQRenderFormat render_to);

xmqSetRenderTheme ()

void
xmqSetRenderTheme (XMQOutputSettings *os,
                   const char *theme_name);

xmqSetRenderRaw ()

void
xmqSetRenderRaw (XMQOutputSettings *os,
                 bool render_raw);

xmqSetRenderOnlyStyle ()

void
xmqSetRenderOnlyStyle (XMQOutputSettings *os,
                       bool only_style);

xmqSetWriterContent ()

void
xmqSetWriterContent (XMQOutputSettings *os,
                     XMQWriter content);

xmqSetWriterError ()

void
xmqSetWriterError (XMQOutputSettings *os,
                   XMQWriter error);

xmqSetupPrintStdOutStdErr ()

void
xmqSetupPrintStdOutStdErr (XMQOutputSettings *ps);

xmqSetupPrintFile ()

void
xmqSetupPrintFile (XMQOutputSettings *ps,
                   const char *file);

xmqSetupPrintFileDescriptor ()

void
xmqSetupPrintFileDescriptor (XMQOutputSettings *ps,
                             int fd);

xmqSetupPrintMemory ()

void
xmqSetupPrintMemory (XMQOutputSettings *ps,
                     char **start,
                     char **stop);

xmqSetupPrintSkip ()

void
xmqSetupPrintSkip (XMQOutputSettings *ps,
                   size_t *skip);

xmqPrint ()

void
xmqPrint (XMQDoc *doc,
          XMQOutputSettings *settings);

xmqTrimWhitespace ()

void
xmqTrimWhitespace (XMQDoc *doc,
                   int flags);

xmqCompactQuote ()

char *
xmqCompactQuote (const char *content);

xmqDocError ()

const char *
xmqDocError (XMQDoc *doc);

xmqDocErrno ()

XMQParseError
xmqDocErrno (XMQDoc *doc);

xmqGetName ()

const char *
xmqGetName (XMQNode *node);

xmqGetContent ()

const char *
xmqGetContent (XMQNode *node);

xmqGetInt ()

int32_t
xmqGetInt (XMQDoc *doc,
           const char *xpath);

xmqGetIntRel ()

int32_t
xmqGetIntRel (XMQDoc *doc,
              const char *xpath,
              XMQNode *relative);

xmqGetLong ()

int64_t
xmqGetLong (XMQDoc *doc,
            const char *xpath);

xmqGetLongRel ()

int64_t
xmqGetLongRel (XMQDoc *doc,
               const char *xpath,
               XMQNode *relative);

xmqGetDouble ()

double
xmqGetDouble (XMQDoc *doc,
              const char *xpath);

xmqGetDoubleRel ()

double
xmqGetDoubleRel (XMQDoc *doc,
                 const char *xpath,
                 XMQNode *relative);

xmqGetString ()

const char *
xmqGetString (XMQDoc *doc,
              const char *xpath);

xmqGetStringRel ()

const char *
xmqGetStringRel (XMQDoc *doc,
                 const char *xpath,
                 XMQNode *relative);

xmqForeach ()

int
xmqForeach (XMQDoc *doq,
            const char *xpath,
            XMQNodeCallback cb,
            void *user_data);

xmqForeachRel ()

int
xmqForeachRel (XMQDoc *doq,
               const char *xpath,
               XMQNodeCallback cb,
               void *user_data,
               XMQNode *relative);

xmqReplaceEntity ()

int
xmqReplaceEntity (XMQDoc *doq,
                  const char *entity,
                  const char *content);

xmqReplaceEntityWithNode ()

int
xmqReplaceEntityWithNode (XMQDoc *doq,
                          const char *entity,
                          XMQDoc *idoq,
                          XMQNode *inode);

xmqVersion ()

const char *
xmqVersion ();

Return the current xmq version in this library.

xmqSetVerbose ()

void
xmqSetVerbose (bool e);

Enable/Disable verbose logging.

xmqSetDebug ()

void
xmqSetDebug (bool e);

Enable/Disable debugging.

xmqSetTrace ()

void
xmqSetTrace (bool e);

Enable/Disable tracing.

xmqLogFilter ()

void
xmqLogFilter (const char *log_filter);

Enable/Disable debug/trace logging for certain prefixes.

xmqDebugging ()

bool
xmqDebugging ();

Return whether debugging is enabled or not.

xmqTracing ()

bool
xmqTracing ();

Return whether tracing is enabled or not.

xmqSetLogHumanReadable ()

void
xmqSetLogHumanReadable (bool e);

Enable/Disable verbose/debug/tracing output as human readable. The default is in xmq format.

xmqLoggingXMQ ()

bool
xmqLoggingXMQ ();

xmqParseBufferWithType ()

bool
xmqParseBufferWithType (XMQDoc *doc,
                        const char *start,
                        const char *stop,
                        const char *implicit_root,
                        XMQContentType ct,
                        int flags);

Parse buffer.

xmqParseFileWithType ()

bool
xmqParseFileWithType (XMQDoc *doc,
                      const char *file,
                      const char *implicit_root,
                      XMQContentType ct,
                      int flags);

Load and parse file. If file is NULL read from stdin.

xmqParseBufferWithIXML ()

bool
xmqParseBufferWithIXML (XMQDoc *doc,
                        const char *start,
                        const char *stop,
                        XMQDoc *ixml_grammar,
                        int flags);

Parse buffer using the supplied IXML grammar.

xmqParseFileWithIXML ()

bool
xmqParseFileWithIXML (XMQDoc *doc,
                      const char *file,
                      XMQDoc *ixml_grammar,
                      int flags);

Load a file and parse it using the supplied IXML grammar. If file is NULL read from stdin.

xmqSetupDefaultColors ()

void
xmqSetupDefaultColors (XMQOutputSettings *settings);

Set the default colors for settings based on the theme and background color.

xmqOverrideSettings ()

void
xmqOverrideSettings (XMQOutputSettings *settings,
                     const char *indentation_space,
                     const char *explicit_space,
                     const char *explicit_tab,
                     const char *explicit_cr,
                     const char *explicit_nl);

xmqRenderHtmlSettings ()

void
xmqRenderHtmlSettings (XMQOutputSettings *settings,
                       const char *use_id,
                       const char *use_class);

xmqOverrideColor ()

void
xmqOverrideColor (XMQOutputSettings *settings,
                  const char *render_style,
                  XMQColorName cn,
                  const char *pre,
                  const char *post,
                  const char *ns);

Change the color strings for the given color type. You have to run xmqSetupDefaultColors first.

xmqNewLineConfig ()

XMQLineConfig *
xmqNewLineConfig ();

Allocate a default XMQLineConfig.

xmqFreeLineConfig ()

void
xmqFreeLineConfig (XMQLineConfig *lc);

Free the XMQLineConfig structure.

xmqSetLineHumanReadable ()

void
xmqSetLineHumanReadable (XMQLineConfig *lc,
                         bool enable);

xmqLineDoc ()

char *
xmqLineDoc (XMQLineConfig *lc,
            XMQDoc *doc);

Generate from the doc a compact single line xmq string containing no newlines at all, for logging.

xmqLinePrintf ()

char *
xmqLinePrintf (XMQLineConfig *lc,
               const char *element_name,
               ...);

Generate a compact single line xmq string containing no newlines at all, for logging. The content is constructed from printf formatted strings: xmqLinePrintf(&lc, "car{", "model=", "s", modelstring, "id=", "d", idnumber, "description=", "desc: s", multilinedescription, "}"); Generates: car{model=Volvo id=123 description=('desc: lines of'&10;'next line')}

xmqLineVPrintf ()

char *
xmqLineVPrintf (XMQLineConfig *lc,
                const char *element_name,
                va_list ap);

XMQDoc

typedef struct XMQDoc XMQDoc;

Structure storing a loaded xmq/xml/json document.

XMQNode

typedef struct XMQNode XMQNode;

Structure referencing a node/attr in the xmq/xml/json document.

XMQParseState

An opaque structure to maintain the parse state and the list of callbacks to be invoked when parsing xmq.

XMQParseCallbacks

typedef struct XMQParseCallbacks XMQParseCallbacks;

Store your own parse callbacks into this structure and register your own callback structure with the XMQParseState. Then you will get your own callbacks when parsing xmq and using these callbacks you can implement your own document builder or token handler.

enum XMQContentType

Specify the file/buffer content type.

enum XMQRenderFormat

The xmq output can be rendered as PLAIN, or for human consumption in TERMINAL, HTML, HTMQ, TEX or RAW.

enum XMQFlagBits

If a 0 is provided as the flags to the parse functions, then it will parse using the these default settings: When loading xml/html: trim the whitespace from the input to generate the most likely desired xmq output. merge character entities When loading xmq/htmq: no trimming but merge character entities such as &10; and consecutive text quotes

If you load xml with XMQ_TRIM_NONE (--trim=none) there will be a lot of unnecessary whitespace stored in the xmq, like &32;	&10; etc. You can then view the xmq with XMQ_TRIM_HEURISTIC (--trim=heuristic) to drop the whitespace.

If you load xmq with --nomerge then character entities and separate text blocks will be kept as is. The --nomerge currently does not work for XML/HTML since libxml2 does not have a setting for merge.

enum XMQColorName

struct XMQReader

struct XMQReader {
    void *reader_state;
    size_t (*read)(void *reader_state, char *start, char *stop);
};

The xmq parser uses the reader to fetch data into a buffer (start <= i < stop). You can create your own reader with a function that takes a pointer to the reader state. Returns the number of bytes stored in buffer, maximum stored is stop-start.

struct XMQWriter

struct XMQWriter {
    void *writer_state;
    XMQWrite write;
};

The xmq printer uses the writer to write data supplied from a buffer (start <= i < stop). You can create your own writer with a function that takes a pointer to the writer state. The writer function must return true if the writing was successful.

XMQOutputSettings

enum XMQProceed

enum XMQParseError

Possible parse errors.

enum XMQCoreType

XMQLineConfig

typedef struct XMQLineConfig XMQLineConfig;