�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fconnect%2F'>connect</a>/</p><hr><h3>✏️ Editing: domdoc.cpp</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/******************************************************************/
/*  Implementation of XML document processing using MS DOM        */
/*  Author: Olivier Bertrand                2007 - 2013           */          
/******************************************************************/
#include &quot;my_global.h&quot;
#include &lt;stdio.h&gt;
#if defined(_WIN32)
//#include &lt;windows.h&gt;
#if   defined(MSX2)
#import &quot;msxml2.dll&quot;  //Does not exist on Vista
#elif defined(MSX3)
#import &quot;msxml3.dll&quot;  //Causes error C2872: DOMNodeType: ambiguous symbol  ??
#elif defined(MSX4)
#import &quot;msxml4.dll&quot;  //Causes error C2872: DOMNodeType: ambiguous symbol  ??
#elif defined(MSX6)
#pragma warning(suppress : 4192)
#import &quot;msxml6.dll&quot;  //Causes error C2872: DOMNodeType: ambiguous symbol  ??
#else       // MSX4
#error MSX? is not defined
#endif     // MSX
using namespace MSXML2;
#else
#error This is a Windows implementation only
#endif

#define NODE_TYPE_LIST

#include &quot;global.h&quot;
#include &quot;plgdbsem.h&quot;
#include &quot;xobject.h&quot;
#include &quot;domdoc.h&quot;

inline bool TestHr(PGLOBAL g, HRESULT hr)
  {
  if FAILED(hr) {
    snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s, hr=%d&quot;, MSG(COM_ERROR), hr);
    return true;
  } else
    return false;

  } // end of TestHr

/******************************************************************/
/*  Return a DOMDOC as a XMLDOC.                                  */
/******************************************************************/
PXDOC GetDomDoc(PGLOBAL g, char *nsl, char *nsdf, 
                                      char *enc, PFBLOCK fp)
  {
  return (PXDOC) new(g) DOMDOC(nsl, nsdf, enc, fp);
  }  // end of GetDomDoc

/***********************************************************************/
/*  Close a loaded DOM XML file.                                       */
/***********************************************************************/
void CloseXMLFile(PGLOBAL g, PFBLOCK fp, bool all)
  {
  PXBLOCK xp = (PXBLOCK)fp;

  if (xp &amp;&amp; xp-&gt;Count &gt; 1 &amp;&amp; !all) {
    xp-&gt;Count--;
  } else if (xp &amp;&amp; xp-&gt;Count &gt; 0) {
    try {
      if (xp-&gt;Docp)
        xp-&gt;Docp-&gt;Release();

    } catch(_com_error e)  {
			char *p = _com_util::ConvertBSTRToString(e.Description());
      snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s %s&quot;, MSG(COM_ERROR), p);
			delete[] p;
    } catch(...) {}

    CoUninitialize();
    xp-&gt;Count = 0;
  }  // endif

  } // end of CloseXMLFile

/* ------------------------ class DOMDOC ------------------------ */

/******************************************************************/
/*  DOMDOC constructor.                                           */
/******************************************************************/
DOMDOC::DOMDOC(char *nsl, char *nsdf, char *enc, PFBLOCK fp)
      : XMLDOCUMENT(nsl, nsdf, enc)
  {
  assert (!fp || fp-&gt;Type == TYPE_FB_XML);
  Docp = (fp) ? ((PXBLOCK)fp)-&gt;Docp : (MSXML2::IXMLDOMDocumentPtr)NULL;
  Nlist = NULL;
  Hr = 0;
  } // end of DOMDOC constructor

/******************************************************************/
/*  Initialize XML parser and check library compatibility.        */
/******************************************************************/
bool DOMDOC::Initialize(PGLOBAL g, PCSZ entry, bool zipped)
{
	if (zipped &amp;&amp; InitZip(g, entry))
		return true;

	if (TestHr(g, CoInitialize(NULL)))
    return true;

  if (TestHr(g, Docp.CreateInstance(&quot;msxml2.domdocument&quot;)))
    return true;

  return MakeNSlist(g);
} // end of Initialize

/******************************************************************/
/* Parse the XML file and construct node tree in memory.          */
/******************************************************************/
bool DOMDOC::ParseFile(PGLOBAL g, char *fn)
{
	bool b;

  Docp-&gt;async = false;

	if (zip) {
		// Parse an in memory document
		char *xdoc = GetMemDoc(g, fn);

		// This is not equivalent to load for UTF8 characters
		// It is why get node content is not the same
  	b = (xdoc) ? (bool)Docp-&gt;loadXML((_bstr_t)xdoc) : false;
	} else
		// Load the document
		b = (bool)Docp-&gt;load((_bstr_t)fn);

	if (!b)
    return true;

  return false;
} // end of ParseFile

/******************************************************************/
/* Create or reuse an Xblock for this document.                   */
/******************************************************************/
PFBLOCK DOMDOC::LinkXblock(PGLOBAL g, MODE m, int rc, char *fn)
  {
  PDBUSER dup = (PDBUSER)g-&gt;Activityp-&gt;Aptr;
  PXBLOCK xp = (PXBLOCK)PlugSubAlloc(g, NULL, sizeof(XBLOCK));

  memset(xp, 0, sizeof(XBLOCK));
  xp-&gt;Next = (PXBLOCK)dup-&gt;Openlist;
  dup-&gt;Openlist = (PFBLOCK)xp;
  xp-&gt;Type = TYPE_FB_XML;
  xp-&gt;Fname = (LPCSTR)PlugSubAlloc(g, NULL, strlen(fn) + 1);
  strcpy((char*)xp-&gt;Fname, fn);
  xp-&gt;Count = 1;
  xp-&gt;Length = (m == MODE_READ) ? 1 : 0;
  xp-&gt;Docp = Docp;
  xp-&gt;Retcode = rc;

  // Return xp as a fp 
  return (PFBLOCK)xp;
  } // end of LinkXblock

/******************************************************************/
/* Create the XML node.                                           */
/******************************************************************/
bool DOMDOC::NewDoc(PGLOBAL g, PCSZ ver)
  {
  char buf[64];
  MSXML2::IXMLDOMProcessingInstructionPtr pip;

  sprintf(buf, &quot;version=\&quot;%s\&quot; encoding=\&quot;%s\&quot;&quot;, ver, Encoding);
  pip = Docp-&gt;createProcessingInstruction(&quot;xml&quot;, buf);
  Docp-&gt;appendChild(pip);
  return false;
  } // end of NewDoc

/******************************************************************/
/* Add a comment to the document node.                            */
/******************************************************************/
void DOMDOC::AddComment(PGLOBAL g, char *com)
  {
  Docp-&gt;appendChild(Docp-&gt;createComment(com));
  } // end of AddComment

/******************************************************************/
/* Return the node class of the root of the document.             */
/******************************************************************/
PXNODE DOMDOC::GetRoot(PGLOBAL g)
  {
  MSXML2::IXMLDOMElementPtr root = Docp-&gt;documentElement;

  if (root == NULL)
    return NULL;

  return new(g) DOMNODE(this, root); 
  } // end of GetRoot

/******************************************************************/
/* Create a new root element and return its class node.           */
/******************************************************************/
PXNODE DOMDOC::NewRoot(PGLOBAL g, char *name)
  {
  MSXML2::IXMLDOMElementPtr ep = Docp-&gt;createElement(name);

  if (ep == NULL)
    return NULL;
  Docp-&gt;appendChild(ep);
  return new(g) DOMNODE(this, ep); 
  } // end of NewRoot

/******************************************************************/
/* Return a void DOMNODE node class.                              */
/******************************************************************/
PXNODE DOMDOC::NewPnode(PGLOBAL g, char *name)
  {
  MSXML2::IXMLDOMElementPtr root = NULL;

  if (name)
    if ((root = Docp-&gt;createElement(name)) == NULL)
      return NULL;

  return new(g) DOMNODE(this, root);
  } // end of NewPnode

/******************************************************************/
/* Return a void DOMATTR node class.                              */
/******************************************************************/
PXATTR DOMDOC::NewPattr(PGLOBAL g)
  {
  return new(g) DOMATTR(this, NULL);
  } // end of NewPattr

/******************************************************************/
/* Return a void DOMATTR node class.                              */
/******************************************************************/
PXLIST DOMDOC::NewPlist(PGLOBAL g)
  {
  return new(g) DOMNODELIST(this, NULL);
  } // end of NewPlist

/******************************************************************/
/* Dump the node tree to a new XML file.                          */
/******************************************************************/
int DOMDOC::DumpDoc(PGLOBAL g, char *ofn)
  {
  int rc = 0;

  try {
    Docp-&gt;save(ofn);
  } catch(_com_error e)  {
    int i = snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s: %s&quot;, MSG(COM_ERROR),
                _com_util::ConvertBSTRToString(e.Description()));
    for (i--; i &gt;= 0 &amp;&amp; g-&gt;Message[i] == &#039;\n&#039;; i--)
      g-&gt;Message[i] = 0;
    rc = -1;
  }  catch(...) {}

  return rc;
  } // end of Dump

/******************************************************************/
/* Free the document, cleanup the XML library, and                */
/* debug memory for regression tests.                             */
/******************************************************************/
void DOMDOC::CloseDoc(PGLOBAL g, PFBLOCK xp)
  {
  CloseXMLFile(g, xp, false);
	CloseZip();
  } // end of Close

/* ----------------------- class DOMNODE ------------------------ */

/******************************************************************/
/*  DOMNODE constructor.                                          */
/******************************************************************/
DOMNODE::DOMNODE(PXDOC dp, MSXML2::IXMLDOMNodePtr np) : XMLNODE(dp)
  {
  Docp = ((PDOMDOC)dp)-&gt;Docp;
  Nodep = np;
  Ws = NULL;
  Len = 0;
	Zip = (bool)dp-&gt;zip;
  } // end of DOMNODE constructor

/******************************************************************/
/*  Return the node name.                                         */
/******************************************************************/
char *DOMNODE::GetName(PGLOBAL g)
  {
  if (!WideCharToMultiByte(CP_ACP, 0, Nodep-&gt;nodeName, -1,
                           Name, sizeof(Name), NULL, NULL)) {
    strcpy(g-&gt;Message, MSG(NAME_CONV_ERR));
    return NULL;
    } // endif

  return Name;
  }  // end of GetName

/******************************************************************/
/*  Return the node class of next sibling of the node.            */
/******************************************************************/
PXNODE DOMNODE::GetNext(PGLOBAL g)
  {
  if (Nodep-&gt;nextSibling == NULL)
    Next = NULL;
  else // if (!Next)
    Next = new(g) DOMNODE(Doc, Nodep-&gt;nextSibling);

  return Next;
  } // end of GetNext

/******************************************************************/
/*  Return the node class of first children of the node.          */
/******************************************************************/
PXNODE DOMNODE::GetChild(PGLOBAL g)
  {
  if (Nodep-&gt;firstChild == NULL)
    Children = NULL;
  else // if (!Children)
    Children = new(g) DOMNODE(Doc, Nodep-&gt;firstChild);

  return Children;
  } // end of GetChild

/******************************************************************/
/*  Return the content of a node and subnodes.                    */
/******************************************************************/
RCODE DOMNODE::GetContent(PGLOBAL g, char *buf, int len)
  {
  RCODE rc = RC_OK;

  // Nodep can be null for a missing HTML table column
  if (Nodep) {
		if (Zip) {
			strcpy(buf, Nodep-&gt;text);
		} else if (!WideCharToMultiByte(CP_UTF8, 0, Nodep-&gt;text, -1,
                             buf, len, NULL, NULL)) {
      DWORD lsr = GetLastError();

      switch (lsr) {
        case 0:
        case ERROR_INSUFFICIENT_BUFFER:      // 122L
          snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Truncated %s content&quot;, GetName(g));
          rc = RC_INFO;
          break;
        case ERROR_NO_UNICODE_TRANSLATION:   // 1113L
          snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Invalid character(s) in %s content&quot;,
                              GetName(g));
          rc = RC_INFO;
          break;
        default:
          snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;System error getting %s content&quot;,
                              GetName(g));
          rc = RC_FX;
          break;
        } // endswitch

      } // endif

  } else
    *buf = &#039;\0&#039;;

  return rc;
  } // end of GetContent

/******************************************************************/
/*  Set the text content of an attribute.                         */
/******************************************************************/
bool DOMNODE::SetContent(PGLOBAL g, char *txtp, int len)
  {
  bool rc;
  BSTR val;

  if (len &gt; Len || !Ws) {
    Ws = (WCHAR*)PlugSubAlloc(g, NULL, (len + 1) * 2);
    Len = len;
    } // endif len

  if (!MultiByteToWideChar(CP_UTF8, 0, txtp, strlen(txtp) + 1,
                                       Ws, Len + 1)) {
    snprintf(g-&gt;Message, sizeof(g-&gt;Message), MSG(WS_CONV_ERR), txtp);
    return true;
    } // endif

  val = SysAllocString(Ws);
  rc = TestHr(g, Nodep-&gt;put_text(val));
  SysFreeString(val);
  return rc;
  } // end of SetContent

/******************************************************************/
/*  Return a clone of this node.                                  */
/******************************************************************/
PXNODE DOMNODE::Clone(PGLOBAL g, PXNODE np)
  {
  if (np) {
    ((PDOMNODE)np)-&gt;Nodep = Nodep;
    return np;
  } else
    return new(g) DOMNODE(Doc, Nodep);

  } // end of Clone

/******************************************************************/
/*  Return the list of all or matching children that are elements.*/
/******************************************************************/
PXLIST DOMNODE::GetChildElements(PGLOBAL g, char *xp, PXLIST lp)
  {
  MSXML2::IXMLDOMNodeListPtr dnlp;

  if (xp) {
    if (Nodep-&gt;nodeType == MSXML2::NODE_ELEMENT) {
      MSXML2::IXMLDOMElementPtr ep = Nodep;
      dnlp = ep-&gt;getElementsByTagName(xp);
    } else
      return NULL;

  } else
    dnlp = Nodep-&gt;childNodes;

  if (lp) {
    ((PDOMLIST)lp)-&gt;Listp = dnlp;
    return lp;
  } else
    return new(g) DOMNODELIST(Doc, dnlp);

  } // end of GetChildElements

/******************************************************************/
/*  Return the list of nodes verifying the passed Xapth.          */
/******************************************************************/
PXLIST DOMNODE::SelectNodes(PGLOBAL g, char *xp, PXLIST lp)
  {
  MSXML2::IXMLDOMNodeListPtr dnlp = Nodep-&gt;selectNodes(xp);

  if (lp) {
    ((PDOMLIST)lp)-&gt;Listp = dnlp;
    return lp;
  } else
    return new(g) DOMNODELIST(Doc, dnlp);

  } // end of SelectNodes

/******************************************************************/
/*  Return the first node verifying the passed Xapth.             */
/******************************************************************/
PXNODE DOMNODE::SelectSingleNode(PGLOBAL g, char *xp, PXNODE np)
  {
  try {
    MSXML2::IXMLDOMNodePtr dnp = Nodep-&gt;selectSingleNode(xp);

    if (dnp) {
      if (np) {
        ((PDOMNODE)np)-&gt;Nodep = dnp;
        return np;
      } else
        return new(g) DOMNODE(Doc, dnp);

      } // endif dnp

  } catch(_com_error e) {
    snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s: %s&quot;, MSG(COM_ERROR),
            _com_util::ConvertBSTRToString(e.Description()));
  } catch(...) {}

  return NULL;
  } // end of SelectSingleNode

/******************************************************************/
/*  Return the node attribute with the specified name.            */
/******************************************************************/
PXATTR DOMNODE::GetAttribute(PGLOBAL g, char *name, PXATTR ap)
  {
  MSXML2::IXMLDOMElementPtr ep;
  MSXML2::IXMLDOMNamedNodeMapPtr nmp;
  MSXML2::IXMLDOMAttributePtr atp;

  if (name) {
    ep = Nodep;
    atp = ep-&gt;getAttributeNode(name);
    nmp = NULL;
  } else {
    nmp = Nodep-&gt;Getattributes();
    atp = nmp-&gt;Getitem(0);
  } // endif name

  if (atp) {
    if (ap) {
      ((PDOMATTR)ap)-&gt;Atrp = atp;
      ((PDOMATTR)ap)-&gt;Nmp = nmp;
      ((PDOMATTR)ap)-&gt;K = 0;
      return ap;
    } else
      return new(g) DOMATTR(Doc, atp, nmp);

  } else
    return NULL;

  } // end of GetAttribute

/******************************************************************/
/*  Add a new element child node to this node and return it.      */
/******************************************************************/
PXNODE DOMNODE::AddChildNode(PGLOBAL g, PCSZ name, PXNODE np)
  {
  const char *p, *pn;
//  char *p, *pn, *epf, *pf = NULL;
  MSXML2::IXMLDOMNodePtr ep;
//  _bstr_t   uri((wchar_t*)NULL);

#if 0
  // Is a prefix specified ?
  if ((p = strchr(name, &#039;:&#039;))) {
    pf = BufAlloc(g, name, p - name);

    // Is it the pseudo default prefix
    if (Doc-&gt;DefNs &amp;&amp; !strcmp(pf, Doc-&gt;DefNs)) {
      name = p + 1;              // Suppress it from name
      pf = NULL;                // No real prefix
      } // endif DefNs

    } // endif p

  // Look for matching namespace URI in context
  for (ep = Nodep; ep; ep = ep-&gt;parentNode) {
    epf = (_bstr_t)ep-&gt;prefix;

    if ((!pf &amp;&amp; !epf) || (pf &amp;&amp; epf &amp;&amp; !strcmp(pf, epf))) {
      uri = Nodep-&gt;namespaceURI;
      break;
      } // endif

    } // endfor ep

  if ((wchar_t*)uri == NULL) {
    if (!pf)
      pf = Doc-&gt;DefNs;

    // Look for the namespace URI corresponding to this node
    if (pf)
      for (PNS nsp = Doc-&gt;Namespaces; nsp; nsp = nsp-&gt;Next)
        if (!strcmp(pf, nsp-&gt;Prefix)) {
          uri = nsp-&gt;Uri;
          break;
          } // endfor nsp

    } // endif pns
#endif // 0

  // If name has the format m[n] only m is taken as node name
  if ((p = strchr(name, &#039;[&#039;)))
    pn = BufAlloc(g, name, (int)(p - name));
  else
    pn = name;

  // Construct the element node with eventual namespace
//  ep = Docp-&gt;createNode(_variant_t(&quot;Element&quot;), pn, uri);
  ep = Docp-&gt;createElement(pn);

  _bstr_t pfx = ep-&gt;prefix;
  _bstr_t uri = ep-&gt;namespaceURI;

  if (ep == NULL)
    return NULL;
  Nodep-&gt;appendChild(ep);
  if (np)
    ((PDOMNODE)np)-&gt;Nodep = ep;
  else
    np = new(g) DOMNODE(Doc, ep);

  return NewChild(np);
  } // end of AddChildNode

/******************************************************************/
/*  Add a new property to this node and return it.                */
/******************************************************************/
PXATTR DOMNODE::AddProperty(PGLOBAL g, char *name, PXATTR ap)
  {
  MSXML2::IXMLDOMAttributePtr atp = Docp-&gt;createAttribute(name);

  if (atp) {
    MSXML2::IXMLDOMElementPtr ep = Nodep;
    ep-&gt;setAttributeNode(atp);

    if (ap) {
      ((PDOMATTR)ap)-&gt;Atrp = atp;
      return ap;
    } else
      return new(g) DOMATTR(Doc, atp);

  } else
    return NULL;

  } // end of AddProperty

/******************************************************************/
/*  Add a new text node to this node.                             */
/******************************************************************/
void DOMNODE::AddText(PGLOBAL g, PCSZ txtp)
  {
  MSXML2::IXMLDOMTextPtr tp= Docp-&gt;createTextNode((_bstr_t)txtp);

  if (tp != NULL)
    Nodep-&gt;appendChild(tp);

  } // end of AddText

/******************************************************************/
/*  Remove a child node from this node.                           */
/******************************************************************/
void DOMNODE::DeleteChild(PGLOBAL g, PXNODE dnp)
  {
  Nodep-&gt;removeChild(((PDOMNODE)dnp)-&gt;Nodep);
//  ((PDOMNODE)dnp)-&gt;Nodep-&gt;Release();  bad idea, causes a crash
  Delete(dnp);
  } // end of DeleteChild

/* --------------------- class DOMNODELIST ---------------------- */

/******************************************************************/
/*  DOMNODELIST constructor.                                      */
/******************************************************************/
DOMNODELIST::DOMNODELIST(PXDOC dp, MSXML2::IXMLDOMNodeListPtr lp)
           : XMLNODELIST(dp)
  {
  Listp = lp;
  } // end of DOMNODELIST constructor

/******************************************************************/
/*  Return the nth element of the list.                           */
/******************************************************************/
PXNODE DOMNODELIST::GetItem(PGLOBAL g, int n, PXNODE np)
  {
  if (Listp == NULL || Listp-&gt;length &lt;= n)
    return NULL;

  if (np) {
    ((PDOMNODE)np)-&gt;Nodep = Listp-&gt;item[n];
    return np;
  } else
    return new(g) DOMNODE(Doc, Listp-&gt;item[n]);

  }  // end of GetItem

/******************************************************************/
/*  Reset the pointer on the deleted item.                        */
/******************************************************************/
bool DOMNODELIST::DropItem(PGLOBAL g, int n)
{
	if (Listp == NULL || Listp-&gt;length &lt; n)
		return true;

  return false;
}  // end of DeleteItem

/* ----------------------- class DOMATTR ------------------------ */

/******************************************************************/
/*  DOMATTR constructor.                                          */
/******************************************************************/
DOMATTR::DOMATTR(PXDOC dp, MSXML2::IXMLDOMAttributePtr ap,
                           MSXML2::IXMLDOMNamedNodeMapPtr nmp)
        : XMLATTRIBUTE(dp)
  {
  Atrp = ap;
  Nmp = nmp;
  Ws = NULL;
  Len = 0;
  K = 0;
  }  // end of DOMATTR constructor

/******************************************************************/
/*  Return the attribute name.                                    */
/******************************************************************/
char *DOMATTR::GetName(PGLOBAL g)
  {
  if (!WideCharToMultiByte(CP_ACP, 0, Atrp-&gt;nodeName, -1,
                           Name, sizeof(Name), NULL, NULL)) {
    strcpy(g-&gt;Message, MSG(NAME_CONV_ERR));
    return NULL;
    } // endif

  return Name;
  }  // end of GetName

/******************************************************************/
/*  Return the next attribute node.                               */
/*  This funtion is implemented as needed by XMLColumns.          */
/******************************************************************/
PXATTR DOMATTR::GetNext(PGLOBAL g)
  {
  if (!Nmp)
    return NULL;

  if (++K &gt;= Nmp-&gt;Getlength()) {
    Nmp-&gt;reset();
    Nmp = NULL;
    K = 0;
    return NULL;
    } // endif K

  Atrp = Nmp-&gt;Getitem(K);
  return this;
  } // end of GetNext

/******************************************************************/
/*  Return the content of a node and subnodes.                    */
/******************************************************************/
RCODE DOMATTR::GetText(PGLOBAL g, char *buf, int len)
  {
  RCODE rc = RC_OK;

  if (!WideCharToMultiByte(CP_UTF8, 0, Atrp-&gt;text, -1,
                           buf, len, NULL, NULL)) {
    DWORD lsr = GetLastError();

    switch (lsr) {
      case 0:
      case ERROR_INSUFFICIENT_BUFFER:      // 122L
        snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Truncated %s content&quot;, GetName(g));
        rc = RC_INFO;
        break;
      case ERROR_NO_UNICODE_TRANSLATION:   // 1113L
        snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Invalid character(s) in %s content&quot;,
                            GetName(g));
        rc = RC_INFO;
        break;
      default:
        snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;System error getting %s content&quot;,
                            GetName(g));
        rc = RC_FX;
        break;
      } // endswitch

    } // endif

  return rc;
  } // end of GetText

/******************************************************************/
/*  Set the text content of an attribute.                         */
/******************************************************************/
bool DOMATTR::SetText(PGLOBAL g, char *txtp, int len)
  {
  bool rc;
  BSTR val;

  if (len &gt; Len || !Ws) {
    Ws = (WCHAR*)PlugSubAlloc(g, NULL, (len + 1) * 2);
    Len = len;
    } // endif len

  if (!MultiByteToWideChar(CP_UTF8, 0, txtp, strlen(txtp) + 1,
                                       Ws, Len + 1)) {
    snprintf(g-&gt;Message, sizeof(g-&gt;Message), MSG(WS_CONV_ERR), txtp);
    return true;
    } // endif

  val = SysAllocString(Ws);
  rc = TestHr(g, Atrp-&gt;put_text(val));
  SysFreeString(val);
  return rc;
  } // end of SetText
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fconnect'>🔙 Back</a></p>