diff --git a/xfa/fde/css/fde_cssstylesheet.cpp b/xfa/fde/css/fde_cssstylesheet.cpp
index bc27545..3da7cf4 100644
--- a/xfa/fde/css/fde_cssstylesheet.cpp
+++ b/xfa/fde/css/fde_cssstylesheet.cpp
@@ -11,7 +11,7 @@
 #include "xfa/fgas/crt/fgas_codepage.h"
 
 IFDE_CSSStyleSheet* IFDE_CSSStyleSheet::LoadHTMLStandardStyleSheet() {
-  static const FX_WCHAR* s_pStyle =
+  static const FX_WCHAR s_pStyle[] =
       L"html,address,blockquote,body,dd,div,dl,dt,fieldset,form,frame,frameset,"
       L"h1,h2,h3,h4,h5,h6,noframes,ol,p,ul,center,dir,hr,menu,pre{display:"
       L"block}"
diff --git a/xfa/fxfa/parser/xfa_document_serialize.cpp b/xfa/fxfa/parser/xfa_document_serialize.cpp
index 91b8ff1..f08215a 100644
--- a/xfa/fxfa/parser/xfa_document_serialize.cpp
+++ b/xfa/fxfa/parser/xfa_document_serialize.cpp
@@ -429,11 +429,11 @@
                                          const FX_CHAR* pChecksum,
                                          FX_BOOL bSaveXML) {
   if (pNode->GetObjectType() == XFA_OBJECTTYPE_ModelNode) {
-    static const FX_WCHAR* s_pwsTagName = L"<form";
-    static const FX_WCHAR* s_pwsClose = L"</form\n>";
+    static const FX_WCHAR s_pwsTagName[] = L"<form";
+    static const FX_WCHAR s_pwsClose[] = L"</form\n>";
     pStream->WriteString(s_pwsTagName, FXSYS_wcslen(s_pwsTagName));
     if (pChecksum) {
-      static const FX_WCHAR* s_pwChecksum = L" checksum=\"";
+      static const FX_WCHAR s_pwChecksum[] = L" checksum=\"";
       CFX_WideString wsChecksum = CFX_WideString::FromUTF8(pChecksum);
       pStream->WriteString(s_pwChecksum, FXSYS_wcslen(s_pwChecksum));
       pStream->WriteString((const FX_WCHAR*)wsChecksum, wsChecksum.GetLength());
@@ -497,14 +497,14 @@
   if (pNode->GetObjectType() == XFA_OBJECTTYPE_ModelNode) {
     switch (pNode->GetPacketID()) {
       case XFA_XDPPACKET_XDP: {
-        static const FX_WCHAR* s_pwsPreamble =
+        static const FX_WCHAR s_pwsPreamble[] =
             L"<xdp:xdp xmlns:xdp=\"http://ns.adobe.com/xdp/\">";
         pStream->WriteString(s_pwsPreamble, FXSYS_wcslen(s_pwsPreamble));
         for (CXFA_Node* pChild = pNode->GetNodeItem(XFA_NODEITEM_FirstChild);
              pChild; pChild = pChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
           Export(pStream, pChild, dwFlag, pChecksum);
         }
-        static const FX_WCHAR* s_pwsPostamble = L"</xdp:xdp\n>";
+        static const FX_WCHAR s_pwsPostamble[] = L"</xdp:xdp\n>";
         pStream->WriteString(s_pwsPostamble, FXSYS_wcslen(s_pwsPostamble));
       } break;
       case XFA_XDPPACKET_Datasets: {
