Merge lp:~albertog/xmlf90/wxml-upgrade into lp:xmlf90

[Alberto Garcia]

Updated wxml code, brought from the libpsml distribution.

[Alberto Garcia (albertog)]

The wxml test shows that there has been a regression: "real" attribute values are not trimmed.

review: Needs Fixing

[lp:~albertog/xmlf90/wxml-upgrade]

10. By Alberto Garcia on 2016-01-30

Trim attribute values when using the overloaded interface

Attribute values can be written in the form

pi = 3.1416
call xml_AddAttribute(xf,"key",pi [,fmt="(f6.2)"])

which internally calls the str() function to convert
the real (or integer, etc) to a string, which is now
trimmed.

[Alberto Garcia (albertog)]

OK. I will merge it now.

review: Approve

=== modified file 'Examples/wxml/m_pseudo_utils.f90'
--- Examples/wxml/m_pseudo_utils.f90	2016-01-15 15:49:14 +0000
+++ Examples/wxml/m_pseudo_utils.f90	2016-01-30 12:34:50 +0000
@@ -183,7 +183,8 @@
 call xml_AddAttribute(xf,"version","0.5")
 call xml_NewElement(xf,"header")
 call xml_AddAttribute(xf,"symbol",trim(p%name))
-call xml_AddAttribute(xf,"zval",trim(str(p%zval)))
+!call xml_AddAttribute(xf,"zval",trim(str(p%zval)))
+call xml_AddAttribute(xf,"zval",p%zval) ! Overloaded
 call xml_AddAttribute(xf,"creator",trim(p%creator))
 call xml_AddAttribute(xf,"date",trim(p%date))
 call xml_AddAttribute(xf,"flavor",trim(p%flavor))
@@ -206,27 +207,27 @@
 call xml_NewElement(xf,"grid")
       call xml_AddAttribute(xf,"type","log")
       call xml_AddAttribute(xf,"units","bohr")
-      call xml_AddAttribute(xf,"scale",trim(str(p%grid_scale)))
-      call xml_AddAttribute(xf,"step",trim(str(p%grid_step)))
-      call xml_AddAttribute(xf,"npts",trim(str(p%nr-1)))
-call xml_EndElement(xf,"grid")
+      call xml_AddAttribute(xf,"scale",p%grid_scale)
+      call xml_AddAttribute(xf,"step",p%grid_step)
+      call xml_AddAttribute(xf,"npts",p%nr-1)
+      call xml_EndElement(xf,"grid")
 
 call xml_NewElement(xf,"semilocal")
 
       call xml_AddAttribute(xf,"units","rydberg")
       call xml_AddAttribute(xf,"format","r*V")
-      call xml_AddAttribute(xf,"npots-down",trim(str(p%npotd)))
-      call xml_AddAttribute(xf,"npots-up",trim(str(p%npotu)))
+      call xml_AddAttribute(xf,"npots-down",p%npotd)
+      call xml_AddAttribute(xf,"npots-up",p%npotu)
 
       do i=1,p%npotd
          call xml_NewElement(xf,"vps")
          call xml_AddAttribute(xf,"principal-n", &
-                trim(str(p%principal_n(p%ldown(i)))))
-         call xml_AddAttribute(xf,"l",trim(str(p%ldown(i))))
+                p%principal_n(p%ldown(i)))
+         call xml_AddAttribute(xf,"l",p%ldown(i))
          call xml_AddAttribute(xf,"cutoff", &
-                trim(str(p%cutoff(p%ldown(i)))))
+                p%cutoff(p%ldown(i)))
          call xml_AddAttribute(xf,"occupation", &
-                trim(str(p%occupation(p%ldown(i)))))
+                p%occupation(p%ldown(i)))
          call xml_AddAttribute(xf,"spin","-1")
 
          call xml_NewElement(xf,"radfunc")
 
=== modified file 'Examples/wxml/simple.f90'
--- Examples/wxml/simple.f90	2016-01-15 15:49:14 +0000
+++ Examples/wxml/simple.f90	2016-01-30 12:34:50 +0000
@@ -2,6 +2,8 @@
 
 use xmlf90_wxml
 
+integer, parameter :: dp = selected_real_kind(15,100)
+
 type(xmlf_t) :: xf
 
 integer :: age = 34
@@ -12,12 +14,14 @@
 
 call xml_AddXMLDeclaration(xf,"UTF-8")
 call xml_NewElement(xf,"john")
-call xml_AddAttribute(xf,"age",str(age))
+call xml_AddAttribute(xf,"age",age) ! Overloaded int, with trimming
 call xml_NewElement(xf,"peter")
+call xml_AddAttribute(xf,"with-blanks","  ..Ha..  ")  ! String, no trimming
 call xml_NewElement(xf,"tim")
-call xml_AddAttribute(xf,"age","37")
-call xml_AddAttribute(xf,"weight",str(123.45,"(f7.3)"))
-call xml_AddAttribute(xf,"cholesterol",str(167.0,format="(f8.0)"))
+call xml_AddAttribute(xf,"age","37")  ! String, no trimming
+call xml_AddAttribute(xf,"weight",123.45_dp,fmt="(f7.3)") ! Overloaded, trimming
+call xml_AddAttribute(xf,"cholesterol",167.0,fmt="(f8.0)") ! Overloaded, trimming
+call xml_AddAttribute(xf,"realdefault",137.01) ! Overloaded, default fmt, trimming
 call xml_EndElement(xf,"tim")
 call xml_AddPcdata(xf,"Ping-pong")
 call xml_AddPcdata(xf,"champion", line_feed=.false.)
 
=== added file 'wxml/m_wxml_array_str.f90'
--- wxml/m_wxml_array_str.f90	1970-01-01 00:00:00 +0000
+++ wxml/m_wxml_array_str.f90	2016-01-30 12:34:50 +0000
@@ -0,0 +1,77 @@
+module m_wxml_array_str
+!
+! Utilities for character to character array
+! conversions and tests of equality.
+!
+interface operator (.equal.)
+ module procedure compare_array_str
+end interface
+!
+! Not supported by all compilers...
+! interface assignment (=)
+!  module procedure assign_array_to_str !!!! , assign_str_to_array
+! end interface
+
+public :: operator(.equal.) !!!! , assignment(=)
+public :: assign_array_to_str , assign_str_to_array
+private
+
+CONTAINS
+!-------------------------------------------------------------
+subroutine assign_array_to_str(str,s)
+implicit none
+character(len=1), dimension(:), intent(in)   :: s
+character(len=*), intent(out) :: str
+
+integer :: i, lstr
+
+lstr = len(str)
+do i = 1, min(size(s),lstr)
+   str(i:i) = s(i)
+enddo
+do i = size(s)+1, lstr
+   str(i:i) = " "
+enddo
+end subroutine assign_array_to_str
+
+!-------------------------------------------------------------
+! The NAG and Intel compilers cannot distinguish this from the
+! intrinsic assignment... so we resort to using an explicit
+! subroutine call.
+!
+subroutine assign_str_to_array(s,str)
+implicit none
+character(len=1), dimension(:), intent(out)   :: s
+character(len=*), intent(in) :: str
+
+integer :: i, lstr
+
+lstr = len(str)
+do i = 1, min(size(s),lstr)
+   s(i) = str(i:i)
+enddo
+
+end subroutine assign_str_to_array
+
+!-------------------------------------------------------------
+function compare_array_str(s,str) result(equal) ! .equal. generic
+implicit none
+character(len=1), dimension(:), intent(in)   :: s
+character(len=*), intent(in) :: str
+logical                      :: equal
+integer                      :: lens, lenstr, i
+
+
+equal = .false.
+lens = size(s)
+lenstr = len(str)
+if (lens .ne. lenstr) return
+
+do i = 1, lens
+ if (s(i) .ne. str(i:i)) return
+enddo
+equal = .true.
+
+end function compare_array_str
+
+end module m_wxml_array_str
 
=== modified file 'wxml/m_wxml_buffer.f90'
--- wxml/m_wxml_buffer.f90	2014-09-04 09:28:10 +0000
+++ wxml/m_wxml_buffer.f90	2016-01-30 12:34:50 +0000
@@ -1,5 +1,9 @@
 module m_wxml_buffer
 
+use m_wxml_error
+
+implicit none
+
 !
 ! At this point we use a fixed-size buffer. 
 ! Note however that buffer overflows will only be
@@ -9,13 +13,13 @@
 ! There is code in the parser module  m_fsm to avoid buffer overflows
 ! caused by pcdata values.
 !
-! This module is re-used from the parser package.
+! This module is re-used from the parser package, except the size.
 ! Most of the routines are superfluous at this point.
 !
 ! In a forthcoming implementation it could be made dynamical...
 !
-integer, parameter, public   :: MAX_BUFF_SIZE  = 2000
-integer, parameter, private  :: BUFF_SIZE_WARNING  = 1750
+integer, parameter, public   :: MAX_BUFF_SIZE  = 10000
+integer, parameter, private  :: BUFF_SIZE_WARNING  = 9500
 !
 type, public  :: buffer_t
 private
@@ -23,12 +27,12 @@
       character(len=MAX_BUFF_SIZE)  :: str
 end type buffer_t
 
-public :: add_to_buffer
+public :: add_to_buffer, add_to_buffer_escaping_markup
 public :: print_buffer, str, char, len
 public :: operator (.equal.)
 public :: buffer_nearly_full, reset_buffer
 
-
+private
 !----------------------------------------------------------------
 interface add_to_buffer
       module procedure add_str_to_buffer
@@ -97,9 +101,7 @@
 n = buffer%size
 
 if (n> MAX_BUFF_SIZE) then
-  stop "Buffer overflow: long unbroken string of pcdata or attribute value..."
-!  RETURN
-!
+  call wxml_error("Buffer overflow: long unbroken string of pcdata or attribute value...")
 endif
 
 buffer%str(n:n) = c
@@ -110,7 +112,7 @@
 character(len=*), intent(in)   :: s
 type(buffer_t), intent(inout)  :: buffer
 
-integer   :: n, len_s, last_pos
+integer   :: i, n, len_s, last_pos
 
 len_s = len(s)
 last_pos = buffer%size
@@ -118,13 +120,40 @@
 n = buffer%size
 
 if (n> MAX_BUFF_SIZE) then
-  stop "Buffer overflow: long unbroken string of pcdata or attribute value..."
-!  RETURN
+  call wxml_error("Buffer overflow: long unbroken string of pcdata or attribute value...")
 endif
 
-buffer%str(last_pos+1:n) = s
+if (len_s.gt.0) buffer%str(last_pos+1:n) = s
 end subroutine add_str_to_buffer
 
+subroutine add_to_buffer_escaping_markup(s,buf)
+character(len=*), intent(in)      ::   s
+type(buffer_t), intent(inout)     ::   buf
+
+integer           :: len_s, i
+character(len=1)  :: c
+
+len_s = len(s)
+i = 0
+do 
+ if (i==len_s) exit
+ i = i + 1
+ c = s(i:i)
+ if (c == "<") then
+    call add_to_buffer("&lt;",buf)
+ else if (c == "&") then
+    call add_to_buffer("&amp;",buf)
+ else if (c == "'") then
+    call add_to_buffer("&apos;",buf)
+ else if (c == '"') then
+    call add_to_buffer("&quot;",buf)
+ else
+    call add_to_buffer(c,buf)
+ endif
+enddo
+
+end subroutine add_to_buffer_escaping_markup
+
 !----------------------------------------------------------------
 subroutine reset_buffer(buffer)
 type(buffer_t), intent(inout)  :: buffer
 
=== modified file 'wxml/m_wxml_core.f90'
--- wxml/m_wxml_core.f90	2014-09-04 09:28:10 +0000
+++ wxml/m_wxml_core.f90	2016-01-30 12:34:50 +0000
@@ -1,9 +1,14 @@
 module m_wxml_core
 
 use m_wxml_buffer
+use m_wxml_array_str, only: assign_array_to_str
+use m_wxml_array_str, only: assign_str_to_array
+use m_wxml_escape, only: check_Name
 use m_wxml_elstack
 use m_wxml_dictionary
 
+implicit none
+
 logical, private, save  :: pcdata_advance_line_default = .false.
 logical, private, save  :: pcdata_advance_space_default = .false.
 
@@ -13,19 +18,31 @@
 private
 
 type, public :: xmlf_t
-   integer            :: lun
-   type(buffer_t)     :: buffer
-   type(elstack_t)    :: stack
+   character, pointer      :: filename(:)
+   integer                 :: lun
+   type(buffer_t)          :: buffer
+   type(elstack_t)         :: stack
    type(wxml_dictionary_t) :: dict
-   logical            :: start_tag_closed
-   logical            :: root_element_output
-   logical            :: indenting_requested
+   logical                 :: start_tag_closed
+   logical                 :: root_element_output
+   logical                 :: indenting_requested
+   logical                 :: inhibit_lf
 end type xmlf_t
 
 public :: xml_OpenFile, xml_NewElement, xml_EndElement, xml_Close
-public :: xml_AddPcdata, xml_AddAttribute, xml_AddXMLDeclaration
+public :: xml_AddXMLDeclaration
+public :: xml_AddXMLStylesheet
+public :: xml_AddXMLPI
 public :: xml_AddComment, xml_AddCdataSection
-
+public :: xml_AddPcdata, xml_AddAttribute
+interface  xml_AddPcdata
+   module procedure xml_AddPcdata_Ch
+end interface
+!
+interface  xml_AddAttribute
+   module procedure xml_AddAttribute_Ch
+end interface
+!
 public :: xml_AddArray
 interface xml_AddArray
    module procedure  xml_AddArray_integer,  &
@@ -37,9 +54,28 @@
 private :: add_eol
 private :: write_attributes
 
+!overload error handlers to allow file info
+interface wxml_warning
+  module procedure wxml_warning_xf
+end interface
+interface wxml_error
+  module procedure wxml_error_xf
+end interface
+interface wxml_fatal
+  module procedure wxml_fatal_xf
+end interface
 
+!
+! Heuristic (approximate) target for justification of output
+! Large unbroken pcdatas will go beyond this limit
+! 
 integer, private, parameter  :: COLUMNS = 80
 
+! TOHW - This is the longest string that may be output without
+! a newline. The buffer must not be larger than this, but its size 
+! can be tuned for performance.
+integer, private, parameter  :: xml_recl = 4096
+
 CONTAINS
 
 !-------------------------------------------------------------------
@@ -50,17 +86,30 @@
 
 integer :: iostat
 
+allocate(xf%filename(len(filename)))
+call assign_str_to_array(xf%filename,filename)
+
 call get_unit(xf%lun,iostat)
-if (iostat /= 0) stop "cannot open file"
+if (iostat /= 0) call wxml_fatal(xf, "cannot open file")
+!
+! Use large I/O buffer in case the O.S./Compiler combination
+! has hard-limits by default (i.e., NAGWare f95's 1024 byte limit)
+! This is related to the maximum size of the buffer.
+! TOHW - This is the longest string that may be output without
+! a newline. The buffer must not be larger than this, but its size 
+! can be tuned for performance.
+
 open(unit=xf%lun, file=filename, form="formatted", status="replace", &
-     action="write", position="rewind") ! , recl=65536)
-
-call reset_elstack(xf%stack)
-call reset_dict(xf%dict)
+     action="write", position="rewind", recl=xml_recl)
+
+call init_elstack(xf%stack)
+
+call init_dict(xf%dict)
 call reset_buffer(xf%buffer)
 
 xf%start_tag_closed = .true.
 xf%root_element_output = .false.
+xf%inhibit_lf = .false.
 
 xf%indenting_requested = .false.
 if (present(indent)) then
@@ -82,6 +131,48 @@
 end subroutine xml_AddXMLDeclaration
 
 !-------------------------------------------------------------------
+subroutine xml_AddXMLStylesheet(xf, href, type, title, media, charset, alternate)
+type(xmlf_t), intent(inout)   :: xf
+character(len=*), intent(in) :: href
+character(len=*), intent(in) :: type
+character(len=*), intent(in), optional :: title
+character(len=*), intent(in), optional :: media
+character(len=*), intent(in), optional :: charset
+logical,          intent(in), optional :: alternate
+
+call add_eol(xf)
+call add_to_buffer("<?xml-stylesheet href=""" //trim(href)// &
+     """ type=""" //trim(type)// """", xf%buffer)
+
+if (present(title)) call add_to_buffer(" title="""//trim(title)// """", xf%buffer)
+if (present(media)) call add_to_buffer(" media="""//trim(media)// """", xf%buffer)
+if (present(charset)) call add_to_buffer(" charset="""//trim(charset)// """", xf%buffer)
+if (present(alternate)) then
+   if (alternate) then
+      call add_to_buffer(" alternate=""yes""", xf%buffer)
+   else
+      call add_to_buffer(" alternate=""no""", xf%buffer)
+   endif
+endif
+call add_to_buffer(" ?>", xf%buffer)
+
+end subroutine xml_AddXMLStylesheet
+
+!-------------------------------------------------------------------
+subroutine xml_AddXMLPI(xf, name, data)
+type(xmlf_t), intent(inout)   :: xf
+character(len=*), intent(in) :: name
+character(len=*), intent(in), optional :: data
+
+call add_eol(xf)
+call add_to_buffer("<?" // trim(name) // " ", xf%buffer)
+if(present(data)) call add_to_buffer(data, xf%buffer)
+call add_to_buffer(" ?>", xf%buffer)
+
+end subroutine xml_AddXMLPI
+
+
+!-------------------------------------------------------------------
 subroutine xml_AddComment(xf,comment)
 type(xmlf_t), intent(inout)   :: xf
 character(len=*), intent(in)  :: comment
@@ -94,14 +185,20 @@
 end subroutine xml_AddComment
 
 !-------------------------------------------------------------------
-subroutine xml_AddCdataSection(xf,cdata)
+subroutine xml_AddCdataSection(xf,cdata,line_feed)
 type(xmlf_t), intent(inout)   :: xf
 character(len=*), intent(in)  :: cdata
+logical, intent(in), optional :: line_feed
 
 call close_start_tag(xf,">")
+call dump_buffer(xf,line_feed)
 call add_to_buffer("<![CDATA[", xf%buffer)
 call add_to_buffer(cdata, xf%buffer)
 call add_to_buffer("]]>", xf%buffer)
+call dump_buffer(xf,line_feed)
+if (present(line_feed)) then
+   if (line_feed) xf%inhibit_lf = .true.
+endif
 end subroutine xml_AddCdataSection
 
 !-------------------------------------------------------------------
@@ -110,10 +207,15 @@
 character(len=*), intent(in)  :: name
 
 if (is_empty(xf%stack)) then
-   if (xf%root_element_output) stop "two root elements"
+   if (xf%root_element_output) call wxml_error(xf, "two root elements")
    xf%root_element_output = .true.
 endif
 
+if (.not.check_Name(name)) then
+  call wxml_warning(xf, 'attribute name '//name//' is not valid')
+endif
+
+
 call close_start_tag(xf,">")
 call push_elstack(name,xf%stack)
 call add_eol(xf)
@@ -123,15 +225,13 @@
 
 end subroutine xml_NewElement
 !-------------------------------------------------------------------
-subroutine xml_AddPcdata(xf,pcdata,space,line_feed)
+subroutine xml_AddPcdata_Ch(xf,pcdata,space,line_feed)
 type(xmlf_t), intent(inout)   :: xf
 character(len=*), intent(in)  :: pcdata
 logical, intent(in), optional  :: space
 logical, intent(in), optional  :: line_feed
 
 logical :: advance_line , advance_space
-integer :: n, i, jmax
-integer, parameter   :: chunk_size = 128
 
 advance_line = pcdata_advance_line_default 
 if (present(line_feed)) then
@@ -144,7 +244,7 @@
 endif
 
 if (is_empty(xf%stack)) then
-   stop "pcdata outside element content"
+   call wxml_error(xf, "pcdata outside element content")
 endif
 
 call close_start_tag(xf,">")
@@ -161,43 +261,32 @@
    endif
 endif
 if (advance_space) call add_to_buffer(" ",xf%buffer)
-if (len(xf%buffer) > 0) call dump_buffer(xf,lf=.false.)
-!
-! We bypass the buffer for the bulk of the dump
-!
-n = len(pcdata)
-!print *, "writing pcdata of length: ", n
-i = 1
-do
-   jmax = min(i+chunk_size-1,n)
-!   print *, "writing chunk: ", i, jmax
-   write(unit=xf%lun,fmt="(a)",advance="no") pcdata(i:jmax)
-   if (jmax == n) exit
-   i = jmax + 1
-enddo
-end subroutine xml_AddPcdata
+
+call add_to_buffer_escaping_markup(pcdata, xf%buffer)
+
+end subroutine xml_AddPcdata_Ch
 
 !-------------------------------------------------------------------
-subroutine xml_AddAttribute(xf,name,value)
+subroutine xml_AddAttribute_Ch(xf,name,value)
 type(xmlf_t), intent(inout)   :: xf
 character(len=*), intent(in)  :: name
 character(len=*), intent(in)  :: value
 
 if (is_empty(xf%stack)) then
-   stop "attributes outside element content"
+   call wxml_error(xf, "attributes outside element content")
 endif
 
 if (xf%start_tag_closed)  then
-   stop "attributes outside start tag"
+   call wxml_error(xf, "attributes outside start tag")
 endif
+
 if (has_key(xf%dict,name)) then
-   stop "duplicate att name"
+   call wxml_error(xf, "duplicate att name")
 endif
 
-call add_key_to_dict(trim(name),xf%dict)
-call add_value_to_dict(trim(value),xf%dict)
+call add_item_to_dict(xf%dict, name, value)
 
-end subroutine xml_AddAttribute
+end subroutine xml_AddAttribute_Ch
 
 !-----------------------------------------------------------
 subroutine xml_EndElement(xf,name)
@@ -207,19 +296,19 @@
 character(len=100)  :: current
 
 if (is_empty(xf%stack)) then
-   stop "Out of elements to close"
+   call wxml_fatal(xf, "Out of elements to close")
 endif
 
 call get_top_elstack(xf%stack,current)
 if (current /= name) then
-   print *, "current, name: ", trim(current), " ", trim(name)
-   stop
+   call wxml_fatal(xf, 'Trying to close '//Trim(name)//' but '//Trim(current)//' is open.') 
 endif
 if (.not. xf%start_tag_closed)  then                ! Empty element
    if (len(xf%dict) > 0) call write_attributes(xf)
    call add_to_buffer(" />",xf%buffer)
    xf%start_tag_closed = .true.
 else
+   ! This statement will introduce a newline after array data...
    call add_eol(xf)
    call add_to_buffer("</" // trim(name) // ">", xf%buffer)
 endif
@@ -230,11 +319,21 @@
 !----------------------------------------------------------------
 
 subroutine xml_Close(xf)
-type(xmlf_t), intent(in)   :: xf
+type(xmlf_t), intent(inout)   :: xf
+
+character(len=200) :: name
+
+do
+   if (is_empty(xf%stack)) exit
+   call get_top_elstack(xf%stack,name)
+   call xml_EndElement(xf,trim(name))
+enddo
 
 write(unit=xf%lun,fmt="(a)") char(xf%buffer)
 close(unit=xf%lun)
 
+deallocate(xf%filename)
+
 end subroutine xml_Close
 
 !==================================================================
@@ -266,14 +365,24 @@
 type(xmlf_t), intent(inout)   :: xf
 
 integer :: indent_level
-character(len=100), parameter  ::  blanks =  ""
-
-indent_level = len(xf%stack) - 1
-write(unit=xf%lun,fmt="(a)") char(xf%buffer)
-call reset_buffer(xf%buffer)
-
+
+
+! Flush with a linefeed except if a previous operation has raised
+! the inhibit_lf flag
+
+if (xf%inhibit_lf) then
+   call dump_buffer(xf,lf=.false.)
+   xf%inhibit_lf = .false.
+else
+   call dump_buffer(xf,lf=.true.)
+endif
+
+! In case we still have a zero-length stack, we must make
+! sure indent_level is not less than zero.
+
+indent_level = max(len(xf%stack) - 1, 0)
 if (xf%indenting_requested) &
-   call add_to_buffer(blanks(1:indent_level),xf%buffer)
+   call add_to_buffer(repeat(' ',indent_level),xf%buffer)
 
 end subroutine add_eol
 !------------------------------------------------------------
@@ -311,21 +420,19 @@
 subroutine write_attributes(xf)
 type(xmlf_t), intent(inout)   :: xf
 
-integer  :: i, status, size
-character(len=100)  :: key, value
+integer  :: i, status, size, key_len, value_len
+character(len=200)  :: key, value
 
 do i = 1, len(xf%dict)
-   call get_key(xf%dict,i,key,status)
-   call get_value(xf%dict,key,value,status)
-   key = adjustl(key)
-   value = adjustl(value)
-   size = len_trim(key) + len_trim(value) + 4
+   call get_key(xf%dict,i,key,key_len,status)
+   call get_value(xf%dict,i,value,value_len,status)
+   size = key_len + value_len + 4
    if ((len(xf%buffer) + size) > COLUMNS) call add_eol(xf)
    call add_to_buffer(" ", xf%buffer)
-   call add_to_buffer(trim(key), xf%buffer)
+   call add_to_buffer(key(:key_len), xf%buffer)
    call add_to_buffer("=", xf%buffer)
    call add_to_buffer("""",xf%buffer)
-   call add_to_buffer(trim(value), xf%buffer)
+   call add_to_buffer_escaping_markup(value(:value_len), xf%buffer)
    call add_to_buffer("""", xf%buffer)
 enddo
 
@@ -343,6 +450,7 @@
          write(xf%lun,format) a
       else
          write(xf%lun,"(6(i12))") a
+      xf%inhibit_lf = .true.
       endif
     end subroutine xml_AddArray_integer
 
@@ -359,6 +467,7 @@
       else
          write(xf%lun,"(4(es20.12))") a
       endif
+      xf%inhibit_lf = .true.
     end subroutine xml_AddArray_real_dp
 
 !------------------------------------------------------------------
@@ -374,7 +483,57 @@
       else
          write(xf%lun,"(4(es20.12))") a
       endif
+      xf%inhibit_lf = .true.
     end subroutine xml_AddArray_real_sp
 
+!---------------------------------------------------------
+! Error handling/trapping routines:
+
+    subroutine wxml_warning_xf(xf, msg)
+      ! Emit warning, but carry on.
+      type(xmlf_t), intent(in) :: xf
+      character(len=*), intent(in) :: msg
+
+      write(6,'(a)') 'WARNING(wxml) in writing to file ', xmlf_name(xf)
+      write(6,'(a)')  msg
+
+    end subroutine wxml_warning_xf
+
+    subroutine wxml_error_xf(xf, msg)
+      ! Emit error message, clean up file and stop.
+      type(xmlf_t), intent(inout) :: xf
+      character(len=*), intent(in) :: msg
+
+      write(6,'(a)') 'ERROR(wxml) in writing to file ', xmlf_name(xf)
+      write(6,'(a)')  msg
+
+      call xml_Close(xf)
+      stop
+
+    end subroutine wxml_error_xf
+
+    subroutine wxml_fatal_xf(xf, msg)
+      !Emit error message and abort with coredump. Does not try to
+      !close file, so should be used from anything xml_Close might
+      !itself call (to avoid infinite recursion!)
+
+      type(xmlf_t), intent(in) :: xf
+      character(len=*), intent(in) :: msg
+
+      write(6,'(a)') 'ERROR(wxml) in writing to file ', xmlf_name(xf)
+      write(6,'(a)')  msg
+
+      !call pxfabort
+      stop
+
+    end subroutine wxml_fatal_xf
+
+    function xmlf_name(xf) result(fn)
+      Type (xmlf_t), intent(in) :: xf
+      character(len=size(xf%filename)) :: fn
+      call assign_array_to_str(fn,xf%filename)
+    end function xmlf_name
+      
+
 end module m_wxml_core
 
 
=== modified file 'wxml/m_wxml_dictionary.f90'
--- wxml/m_wxml_dictionary.f90	2014-09-04 09:28:10 +0000
+++ wxml/m_wxml_dictionary.f90	2016-01-30 12:34:50 +0000
@@ -1,24 +1,32 @@
 module m_wxml_dictionary
 
+  use m_wxml_escape, only : check_Name
+  use m_wxml_error,  only : wxml_fatal
+  use m_wxml_array_str
+
+  implicit none
+
 private
 !
-! A very rough implementation for now
-! It uses fixed-length buffers for key/value pairs,
-! and the maximum number of dictionary items is hardwired.
-
 integer, parameter, private    :: MAX_ITEMS = 30
+
+type, private :: dict_item
+  character(len=1), pointer, dimension(:) :: key
+  character(len=1), pointer, dimension(:) :: value
+end type dict_item
+
 type, public :: wxml_dictionary_t
 private
       integer                               :: number_of_items ! = 0
-      character(len=100), dimension(MAX_ITEMS)  :: key
-      character(len=100), dimension(MAX_ITEMS)  :: value
+      type(dict_item), dimension(MAX_ITEMS) :: items
 end type wxml_dictionary_t
 
 !
 ! Building procedures
 !
-public  :: add_key_to_dict, add_value_to_dict, reset_dict
-
+public :: init_dict
+public :: reset_dict
+public :: add_item_to_dict
 !
 ! Query and extraction procedures
 !
@@ -27,13 +35,13 @@
    module procedure number_of_entries
 end interface
 public  :: number_of_entries
-public  :: get_key
+public  :: get_key 
 public  :: get_value
 public  :: has_key
 public  :: print_dict
 !
 interface get_value
-   module procedure wxml_get_value
+   module procedure wxml_get_value, wxml_get_value_i
 end interface
 
 CONTAINS
@@ -53,14 +61,13 @@
 character(len=*), intent(in)     :: key
 logical                          :: found
 
-integer  :: n, i
+integer  ::  i
 found = .false.
-n = dict%number_of_items
-do  i = 1, n
-      if (dict%key(i) == key) then
-         found = .true.
-         exit
-      endif
+do  i = 1, dict%number_of_items
+    if (dict%items(i)%key .equal. key) then
+      found = .true.
+      exit
+    endif
 enddo
 end function has_key
 
@@ -71,79 +78,141 @@
 character(len=*), intent(out)             :: value
 integer, intent(out)                      :: status
 !
-integer  :: n, i
+integer  :: i
 
 status = -1
-n = dict%number_of_items
-do  i = 1, n
-      if (dict%key(i) == key) then
-         value = dict%value(i)
-         status = 0
-         RETURN
-      endif
+do  i = 1, dict%number_of_items
+    if (dict%items(i)%key .equal. key) then
+      call assign_array_to_str(value,dict%items(i)%value)
+      status = 0
+      exit
+    endif
 enddo
 
 end subroutine wxml_get_value
 
+function get_value_len(dict, key) result(value_len)
+  type(wxml_dictionary_t), intent(in) :: dict
+  character(len=*), intent(in) :: key
+  integer :: value_len
+
+  integer :: i
+
+  value_len = 0
+  do  i = 1, dict%number_of_items
+      if (dict%items(i)%key .equal. key) then
+        value_len = size(dict%items(i)%value)
+        exit
+      endif
+  enddo
+
+end function get_value_len
+
+
 !------------------------------------------------------
-subroutine get_key(dict,i,key,status)
+subroutine get_key(dict,i,key,key_len,status)
 !
 ! Get the i'th key
 !
 type(wxml_dictionary_t), intent(in)            :: dict
 integer, intent(in)                       :: i
 character(len=*), intent(out)             :: key
+integer, intent(out)                      :: key_len
 integer, intent(out)                      :: status
 
-if (i <= dict%number_of_items) then
-      key = dict%key(i)
+if (i>0 .and. i<=dict%number_of_items) then
+      call assign_array_to_str(key,dict%items(i)%key)
+      key_len = size(dict%items(i)%key)
       status = 0
 else
-      key = ""
+      key = ' '
+      key_len = 0
       status = -1
 endif
 
 end subroutine get_key
-
 !------------------------------------------------------
-subroutine add_key_to_dict(key,dict)
-character(len=*), intent(in)          :: key
-type(wxml_dictionary_t), intent(inout)   :: dict
-
-integer  :: n
-
-n = dict%number_of_items
-if (n == MAX_ITEMS) then
-      write(unit=0,fmt=*) "Dictionary capacity exceeded !"
-      RETURN
+subroutine wxml_get_value_i(dict,i,value,value_len,status)
+!
+! Get the i'th value
+!
+type(wxml_dictionary_t), intent(in)            :: dict
+integer, intent(in)                       :: i
+character(len=*), intent(out)             :: value
+integer, intent(out)                      :: value_len
+integer, intent(out)                      :: status
+
+if (i>0 .and. i<=dict%number_of_items) then
+      call assign_array_to_str(value,dict%items(i)%value)
+      value_len = size(dict%items(i)%value)
+      status = 0
+else
+      value = ' '
+      value_len = 0
+      status = -1
 endif
 
-n = n + 1
-dict%key(n) = key
-dict%number_of_items = n
-
-end subroutine add_key_to_dict
+end subroutine wxml_get_value_i
+
+subroutine add_item_to_dict(dict, key, value)
+
+  type(wxml_dictionary_t), intent(inout) :: dict
+  character(len=*), intent(in)          :: key
+  character(len=*), intent(in)          :: value
+
+  character(len=len(key)) :: check_key
+  integer  :: n, lenstr
+
+  n = dict%number_of_items
+  if (n == MAX_ITEMS) then
+    write(unit=0,fmt=*) "Dictionary capacity exceeded !"
+    RETURN
+  endif
+
+! keys may not have initial (or trailing; thus trim below) blanks:
+!TOHW remove this check? shouldn't be passing blank-prefixed strings anyway.
+  check_key=adjustl(key)
+  if (.not.check_Name(trim(check_key))) then
+    call wxml_fatal('attribute name is invalid')
+  endif
+
+  n = n + 1
+  lenstr=len_trim(check_key)
+  allocate(dict%items(n)%key(lenstr))
+  call assign_str_to_array(dict%items(n)%key,check_key)
+  allocate(dict%items(n)%value(len(value)))
+  call assign_str_to_array(dict%items(n)%value,value)
+
+  dict%number_of_items = n
+
+end subroutine add_item_to_dict
 
 !------------------------------------------------------
-! Assumes we build the dictionary in an orderly fashion,
-! so one adds first the key and then immediately afterwards the value.
-!
-subroutine add_value_to_dict(value,dict)
-character(len=*), intent(in)          :: value
-type(wxml_dictionary_t), intent(inout)   :: dict
-
-integer  :: n
-
-n = dict%number_of_items
-dict%value(n) = value
-
-end subroutine add_value_to_dict
-
+subroutine init_dict(dict)
+  type(wxml_dictionary_t), intent(out)   :: dict
+
+  integer :: i
+  
+  do i = 1, MAX_ITEMS
+    nullify(dict%items(i)%key)
+    nullify(dict%items(i)%key)
+  enddo
+
+  dict % number_of_items = 0
+
+end subroutine init_dict
+  
 !------------------------------------------------------
 subroutine reset_dict(dict)
-type(wxml_dictionary_t), intent(inout)   :: dict
+  type(wxml_dictionary_t), intent(inout)   :: dict
+  
+  integer :: i
+  do i = 1, dict%number_of_items
+    deallocate(dict%items(i)%key)
+    deallocate(dict%items(i)%value)
+  enddo
 
-dict%number_of_items = 0
+  dict%number_of_items = 0
 
 end subroutine reset_dict
 
@@ -154,7 +223,7 @@
 integer  :: i
 
 do i = 1, dict%number_of_items
-      print *, trim(dict%key(i)), " = ", trim(dict%value(i))
+      print *, dict%items(i)%key, " = ", dict%items(i)%value
 enddo
 
 end subroutine print_dict
 
=== modified file 'wxml/m_wxml_elstack.f90'
--- wxml/m_wxml_elstack.f90	2014-09-04 09:28:10 +0000
+++ wxml/m_wxml_elstack.f90	2016-01-30 12:34:50 +0000
@@ -1,19 +1,30 @@
 module m_wxml_elstack
 
+use m_wxml_error
+
+implicit none
+
 private
 
 !
 ! Simple stack to keep track of which elements have appeared so far
 !
-integer, parameter, private            :: STACK_SIZE = 20
+! Initial stack size:
+integer, parameter, private            :: STACK_SIZE_INIT = 10
+! Multiplier when stack is exceeded:
+real, parameter, private            :: STACK_SIZE_MULT = 1.5
+
+type, private :: elstack_item
+  character(len=100) :: data
+end type
 
 type, public :: elstack_t
 private
-      integer                                    :: n_items
-      character(len=100), dimension(STACK_SIZE)  :: data
+      integer                                   :: n_items
+      type(elstack_item), pointer, dimension(:) :: stack
 end type elstack_t
 
-public  :: push_elstack, pop_elstack, reset_elstack, print_elstack
+public  :: push_elstack, pop_elstack, init_elstack, reset_elstack, print_elstack
 public  :: get_top_elstack, is_empty, get_elstack_signature
 public  :: len
 
@@ -30,14 +41,39 @@
 CONTAINS
 
 !-----------------------------------------------------------------
+subroutine init_elstack(elstack)
+  type(elstack_t), intent(inout)  :: elstack
+
+  allocate(elstack%stack(STACK_SIZE_INIT))
+  elstack%n_items = 0
+
+end subroutine init_elstack
+
+!-----------------------------------------------------------------
 subroutine reset_elstack(elstack)
-type(elstack_t), intent(inout)  :: elstack
+  type(elstack_t), intent(inout)  :: elstack
 
-elstack%n_items = 0
+  deallocate(elstack%stack)
+  call init_elstack(elstack)
 
 end subroutine reset_elstack
 
 !-----------------------------------------------------------------
+subroutine resize_elstack(elstack)
+  type(elstack_t), intent(inout)  :: elstack
+  type(elstack_item), pointer, dimension(:) :: temp
+  integer :: s
+
+  s = size(elstack%stack)
+
+  temp=>elstack%stack
+  allocate(elstack%stack(nint(s*STACK_SIZE_MULT)))
+  elstack%stack(:s) = temp
+  deallocate(temp)
+
+end subroutine resize_elstack
+
+!-----------------------------------------------------------------
 function is_empty_elstack(elstack) result(answer)
 type(elstack_t), intent(in)  :: elstack
 logical                    :: answer
@@ -61,11 +97,11 @@
 integer   :: n
 
 n = elstack%n_items
-if (n == STACK_SIZE) then
-      stop "*Element stack full"
+if (n == size(elstack%stack)) then
+  call resize_elstack(elstack)
 endif
 n = n + 1
-elstack%data(n) = item
+elstack%stack(n)%data = item
 elstack%n_items = n
 
 end subroutine push_elstack
@@ -75,16 +111,13 @@
 type(elstack_t), intent(inout)     :: elstack
 character(len=*), intent(out)        :: item
 
-!
-! We assume the elstack is not empty... (the user has called is_empty first)
-!
 integer   :: n
 
 n = elstack%n_items
 if (n == 0) then
-      stop "*********Element stack empty"
+      call wxml_error("Element stack empty")
 endif
-item = elstack%data(n)
+item = elstack%stack(n)%data
 elstack%n_items = n - 1
 
 end subroutine pop_elstack
@@ -97,16 +130,13 @@
 type(elstack_t), intent(in)        :: elstack
 character(len=*), intent(out)        :: item
 
-!
-! We assume the elstack is not empty... (the user has called is_empty first)
-!
 integer   :: n
 
 n = elstack%n_items
 if (n == 0) then
-      stop "*********Element stack empty"
+  call wxml_error("Element stack empty")
 endif
-item = elstack%data(n)
+item = elstack%stack(n)%data
 
 end subroutine get_top_elstack
 
@@ -117,7 +147,7 @@
 integer   :: i
 
 do i = elstack%n_items, 1, -1
-      write(unit=unit,fmt=*) trim(elstack%data(i))
+  write(unit=unit,fmt=*) trim(elstack%stack(i)%data)
 enddo
 
 end subroutine print_elstack
@@ -128,13 +158,13 @@
 character(len=*), intent(out) :: string
 integer   :: i, length, j
 
-string = ""
+string = ' '
 j = 0
 do i = 1, elstack%n_items
-   length = len_trim(elstack%data(i))
+   length = len_trim(elstack%stack(i)%data)
    string(j+1:j+1) = "/"
    j = j+1
-   string(j+1:j+length) = trim(elstack%data(i))
+   string(j+1:j+length) = trim(elstack%stack(i)%data)
    j = j + length
 enddo
 
 
=== added file 'wxml/m_wxml_overloads.f90'
--- wxml/m_wxml_overloads.f90	1970-01-01 00:00:00 +0000
+++ wxml/m_wxml_overloads.f90	2016-01-30 12:34:50 +0000
@@ -0,0 +1,143 @@
+module m_wxml_overloads
+  
+  use m_wxml_text, only: str
+  use m_wxml_core, only: xmlf_t
+  use m_wxml_core, only: xml_AddPcData_Ch => xml_AddPcData
+  use m_wxml_core, only: xml_AddAttribute_Ch => xml_AddAttribute
+
+  implicit none
+
+  integer, parameter ::  sp = selected_real_kind(6,30)
+  integer, parameter ::  dp = selected_real_kind(14,100)
+
+  private
+
+  public :: xml_AddPcdata
+  public :: xml_AddAttribute
+
+  interface xml_AddPcData
+     module procedure xml_AddPcdata_SP
+     module procedure xml_AddPcdata_DP
+     module procedure xml_AddPcdata_Int
+     module procedure xml_AddPcdata_Log
+  end interface
+
+  interface xml_AddAttribute
+     module procedure xml_AddAttribute_SP
+     module procedure xml_AddAttribute_DP
+     module procedure xml_AddAttribute_Int
+     module procedure xml_AddAttribute_Log
+  end interface
+
+CONTAINS
+
+  !-------------------------------------------------------------------
+
+  subroutine xml_AddPcdata_SP(xf,pcdata,fmt, space,line_feed)
+    type(xmlf_t), intent(inout)    :: xf
+    real(kind=sp), intent(in)      :: pcdata
+    logical,          intent(in), optional  :: space
+    logical,          intent(in), optional  :: line_feed
+    character(len=*), intent(in), optional  :: fmt
+
+    call xml_AddPcdata_Ch(xf,trim(str(pcdata,fmt)),space,line_feed)
+
+  end subroutine xml_AddPcdata_SP
+
+
+  subroutine xml_AddPcdata_DP(xf,pcdata,fmt,space,line_feed)
+    type(xmlf_t), intent(inout)    :: xf
+    real(kind=dp), intent(in)      :: pcdata
+    character(len=*), optional    :: fmt
+    logical, intent(in), optional  :: space
+    logical, intent(in), optional  :: line_feed
+
+    call xml_AddPcdata_Ch(xf,trim(str(pcdata,fmt)),space,line_feed)
+
+  end subroutine xml_AddPcdata_DP
+
+
+  subroutine xml_AddPcdata_log(xf,pcdata,fmt,space,line_feed)
+    type(xmlf_t), intent(inout)    :: xf
+    logical, intent(in)            :: pcdata
+    character(len=*), intent(in), optional    :: fmt
+    logical, intent(in), optional  :: space
+    logical, intent(in), optional  :: line_feed
+
+    if (present(fmt)) then
+      call xml_AddPcdata_Ch(xf,trim(str(pcdata,fmt)),space,line_feed)
+    else
+      call xml_AddPcdata_Ch(xf,trim(str(pcdata)),space,line_feed)
+    endif
+
+  end subroutine xml_AddPcdata_log
+
+
+  subroutine xml_AddPcdata_int(xf,pcdata,fmt,space,line_feed)
+    type(xmlf_t), intent(inout)    :: xf
+    integer, intent(in)            :: pcdata
+    character(len=*), intent(in), optional    :: fmt
+    logical, intent(in), optional  :: space
+    logical, intent(in), optional  :: line_feed
+
+    if (present(fmt)) then
+      call xml_AddPcdata_Ch(xf,trim(str(pcdata,fmt)),space,line_feed)
+    else
+      call xml_AddPcdata_Ch(xf,trim(str(pcdata)),space,line_feed)
+    endif
+
+  end subroutine xml_AddPcdata_int
+
+
+  !-------------------------------------------------------------------
+
+  subroutine xml_AddAttribute_SP(xf,name,value,fmt)
+    type(xmlf_t), intent(inout)   :: xf
+    character(len=*), intent(in)  :: name
+    real(kind=sp),    intent(in)  :: value
+    character(len=*), intent(in), optional   :: fmt
+
+    call xml_AddAttribute_Ch(xf,name,trim(str(value,fmt)))
+
+  end subroutine xml_AddAttribute_SP
+
+  subroutine xml_AddAttribute_DP(xf,name,value,fmt)
+    type(xmlf_t), intent(inout)   :: xf
+    character(len=*), intent(in)  :: name
+    real(kind=dp),    intent(in)  :: value
+    character(len=*), intent(in), optional   :: fmt
+
+    call xml_AddAttribute_Ch(xf,name,trim(str(value,fmt)))
+
+  end subroutine xml_AddAttribute_DP
+
+  subroutine xml_AddAttribute_log(xf,name,value,fmt)
+    type(xmlf_t), intent(inout)   :: xf
+    character(len=*), intent(in)  :: name
+    logical, intent(in)           :: value
+    character(len=*), intent(in), optional   :: fmt
+
+    if (present(fmt)) then
+      call xml_AddAttribute_Ch(xf,name,trim(str(value,fmt)))
+    else
+      call xml_AddAttribute_Ch(xf,name,trim(str(value)))
+    endif
+
+  end subroutine xml_AddAttribute_log
+
+  subroutine xml_AddAttribute_int(xf,name,value,fmt)
+    type(xmlf_t), intent(inout)   :: xf
+    character(len=*), intent(in)  :: name
+    integer, intent(in)           :: value
+    character(len=*), intent(in), optional   :: fmt
+
+    if (present(fmt)) then
+      call xml_AddAttribute_Ch(xf,name,trim(str(value,fmt)))
+    else
+      call xml_AddAttribute_Ch(xf,name,trim(str(value)))
+    endif
+
+  end subroutine xml_AddAttribute_int
+
+end module m_wxml_overloads
+
 
=== renamed file 'wxml/m_wxml_text.f90' => 'wxml/m_wxml_text.F90'
--- wxml/m_wxml_text.f90	2014-09-04 14:11:50 +0000
+++ wxml/m_wxml_text.F90	2016-01-30 12:34:50 +0000
@@ -1,44 +1,68 @@
 module m_wxml_text
+
+implicit none
 !
 integer, private, parameter ::  sp = selected_real_kind(6,30)
 integer, private, parameter ::  dp = selected_real_kind(14,100)
 !
 private
-
 public :: str
 
 interface str
-   module procedure  str_integer,  str_real_dp, str_real_sp, &
-                     str_logical
+   module procedure  str_integer_fmt, str_integer, &
+                     str_logical_fmt, str_logical, &
+                     str_real_dp, str_real_sp
 end interface
-private :: str_integer,  str_real_dp, str_real_sp, str_logical
 
 CONTAINS
 
-      function str_integer(int,format) result(s)
-      integer, intent(in)   :: int
-      character(len=*), intent(in), optional  :: format
+      function str_integer_fmt(i,format) result(s)
+      integer, intent(in)   :: i
+      character(len=*), intent(in) :: format
       character(len=100)    :: s
 
-      if (present(format)) then
-         write(s,format) int
-      else
-         write(s,"(i25)") int
-      endif
+      write(s,format) i
       s = adjustl(s)
+      end function str_integer_fmt
+
+      function str_integer(i) result(s)
+        ! This will work correctly (return an appropriately-sized
+        ! string) for integers i s.t. -99999999<=i<=999999999
+        integer, intent(in) :: i
+#ifndef WXML_INIT_FIX
+        character(len=int(merge(log10(real(max(abs(i),1)))+1, &
+                                log10(real(max(abs(i),1)))+2, &
+                          sign(1,i)>0))) :: s
+#else
+! Some compilers have trouble with the above
+        character(len=int(log10(real(max(abs(i),1)))+2))  :: s
+#endif
+        character(len=4) :: form
+        
+        write(form,'(a,i1,a)') '(i',len(s),')'
+        write(s, form) i
+
       end function str_integer
 
-      function str_logical(log,format) result(s)
-      logical, intent(in)   :: log
-      character(len=*), intent(in), optional  :: format
+      function str_logical_fmt(l,format) result(s)
+      logical, intent(in)   :: l
+      character(len=*), intent(in) :: format
       character(len=100)    :: s
 
-      if (present(format)) then
-         write(s,format) log
-      else
-         write(s,"(l1)") log
-      endif
+      write(s,format) l
       s = adjustl(s)
+
+      end function str_logical_fmt
+
+      function str_logical(l) result(s)
+        logical, intent(in)   :: l
+        character(len=merge(4,5,l)) :: s
+        
+        if (l) then
+          s='true'
+        else
+          s='false'
+        endif
       end function str_logical
 
       function str_real_dp(x,format) result(s)
@@ -47,10 +71,10 @@
       character(len=100)    :: s
 
       if (present(format)) then
-            write(s,format) x
+         write(s,format) x
       else
          if (abs(nint(x)-x) .lt. epsilon(x)) then
-            write(s,"(f20.0)") x
+            write(s,"(i0)") nint(x)
          else
             write(s,"(g22.12)") x
          endif
@@ -67,7 +91,7 @@
          write(s,format) x
       else
          if (abs(nint(x)-x) .lt. epsilon(x)) then
-            write(s,"(f20.0)") x
+            write(s,"(i0)") nint(x)
          else
             write(s,"(g22.12)") x
          endif
 
=== modified file 'wxml/makefile'
--- wxml/makefile	2016-01-15 15:49:14 +0000
+++ wxml/makefile	2016-01-30 12:34:50 +0000
@@ -1,6 +1,8 @@
 #
-OBJFILES= m_wxml_buffer.o m_wxml_dictionary.o m_wxml_elstack.o \
-          m_wxml_text.o m_wxml_core.o xmlf90_wxml.o
+OBJFILES= m_wxml_buffer.o m_wxml_array_str.o m_wxml_dictionary.o\
+          m_wxml_elstack.o \
+          m_wxml_text.o m_wxml_escape.o  m_wxml_core.o \
+          m_wxml_overloads.o xmlf90_wxml.o m_wxml_error.o
 MODFILES=$(OBJFILES:.o=)
 
 #------------------------------
@@ -10,4 +12,12 @@
 
 clean:
 	rm -f *.o *.$(MOD_EXT)
+# DO NOT DELETE THIS LINE - used by make depend
+xmlf90_wxml.o: m_wxml_core.o m_wxml_overloads.o m_wxml_text.o
+m_wxml_buffer.o: m_wxml_error.o m_wxml_escape.o
+m_wxml_core.o: m_wxml_buffer.o m_wxml_dictionary.o m_wxml_elstack.o
+m_wxml_core.o: m_wxml_escape.o m_wxml_array_str.o
+m_wxml_dictionary.o: m_wxml_array_str.o m_wxml_escape.o
+m_wxml_elstack.o: m_wxml_error.o
+m_wxml_overloads.o: m_wxml_core.o m_wxml_text.o
 
 
=== modified file 'wxml/xmlf90_wxml.f90'
--- wxml/xmlf90_wxml.f90	2016-01-15 15:49:14 +0000
+++ wxml/xmlf90_wxml.f90	2016-01-30 12:34:50 +0000
@@ -1,10 +1,8 @@
 module xmlf90_wxml
 
-!use m_wxml_buffer
-!use m_wxml_dictionary
-!use m_wxml_elstack
 use m_wxml_text
 use m_wxml_core
+use m_wxml_overloads
 
 public