#endif
]], [[
xmlFeature f;
xmlHasFeature(f);
]])],[PKG_CPPFLAGS="$PKG_CPPFLAGS -DHAVE_XML_HAS_FEATURE=1"; echo "Version has xmlHasFeature()"],[echo "No xmlHasFeature."])
dnl ---------------------------------------------
AC_SUBST(XMLSEC_DEFS)
AC_SUBST(LIBXML2)
AC_SUBST(LANGUAGE_DEFS)
AC_SUBST(LIBXML_INCDIR)
AC_SUBST(XMLPARSE_INCDIR)
AC_SUBST(PKG_LIBS)
AC_SUBST(PKG_CPPFLAGS)
AC_SUBST(SUPPORTS_LIBXML)
AC_SUBST(SUPPORTS_EXPAT)
AC_SUBST(LD_PATH)
AC_SUBST(EXPORT_MEMORY_MANAGEMENT)
if test -n "${USE_SPLUS}" ; then
AC_SUBST(SPLUS)
SPLUS_MAKEFILE=GNUmakefile.Splus
fi
echo ""
echo "****************************************"
echo "Configuration information:"
echo ""
echo "Libxml settings"
echo ""
echo "libxml include directory: ${LIBXML_INCDIR}"
echo "libxml library directory: ${LIBS}"
echo "libxml 2: ${LIBXML2-no}"
echo ""
echo "Compilation flags: ${PKG_CPPFLAGS} ${LANGUAGE_DEFS} $XMLSEC_DEFS"
echo "Link flags: ${PKG_LIBS}"
echo ""
echo "****************************************"
if test "$ADD_XML_OUTPUT_BUFFER" = "no" ; then
ADD_XML_OUTPUT_BUFFER=0
fi
if test "$ADD_XML_OUTPUT_BUFFER" = "yes" ; then
ADD_XML_OUTPUT_BUFFER=1
fi
AC_SUBST(ADD_XML_OUTPUT_BUFFER)
if test -n "${_R_CHECK_TIMINGS_}" ; then
PKG_CPPFLAGS="$PKG_CPPFLAGS -DNO_XML_MEMORY_SHOW_ROUTINE=1"
fi
dnl create the different targets
dnl We had NAMESPACE here when were conditionally exporting the functions to
dnl remove finalizers on a node or document. Need to add NAMESPACE.in in
dnl Install/GNUmakefile.admin
AC_CONFIG_FILES([src/Makevars R/supports.R inst/scripts/RSXML.csh inst/scripts/RSXML.bsh ${SPLUS_MAKEFILE}])
AC_OUTPUT
chmod +x cleanup
dnl Set things up for an S-Plus chapter.
if test -n "${USE_SPLUS}" ; then
mv GNUmakefile.Splus GNUmakefile
echo "Creating S-Plus chapter"
cd src
C_SRC_FILES="DocParse.c RSDTD.c Utils.c"
${SPLUS} CHAPTER ${C_SRC_FILES}
echo "include Makevars" >> makefile
echo 'CFLAGS:= $(PKG_CPPFLAGS) $(CFLAGS)' >> makefile
echo 'LOCAL_LIBS=$(PKG_LIBS) ' >> makefile
cd ..
fi
XML/inst/ 0000755 0001751 0000144 00000000000 13607643014 011711 5 ustar hornik users XML/inst/examples/ 0000755 0001751 0000144 00000000000 14636531033 013527 5 ustar hornik users XML/inst/examples/README 0000644 0001751 0000144 00000000246 13607633730 014415 0 ustar hornik users propmptXML - an R function analogous to prompt for generating
help/documentation files for R functions, but this generates this in
XML format according to Rhelp.dtd.
XML/inst/examples/gettingStarted.xml 0000644 0001751 0000144 00000017713 13607633725 017262 0 ustar hornik users
The idea here is to provide simple examples of how to get started
with processing XML in R using some reasonably straightforward "flat" XML files
and not worrying about efficiency.
An Example: Grades
Here is an example of a simple file in XML containing
grades for students for three different tests.
We might want to turn this into a data frame in R
with a row for each student and four variables,
the name and the scores on the three tests.
Since this is a small file, let's not worry about efficiency in any way.
We can read the entire document tree into memory and make multiple passes
over it to get the information.
Our first approach will be to read the XML into an R tree, i.e.
R-level XML node objects.
We do this with a simple call to xmlTreeParse.
doc = xmlRoot(xmlTreeParse("generic_file.xml"))
We use xmlRoot to get the top-level node of the tree
rather than holding onto the general document information since we won't need it.
Since the structure of this file is
just a list of elements under the root node,
we need only process each of those nodes and turn them into something we want.
The "easiest" way to apply the same function to each child of an XML node
is with the xmlApply function.
What do we want to do for each of the <GRADES> node?
We want to get the value, i.e. the simple text within the node, of each of its children.
Since this is the same for each of the child nodes in <GRADES>, this is again
another call to xmlApply. And since this is all text, we can
simplify the result and get back a character vector rather than a list by using
xmlSApply which will perform this extra simplication step.
So a function to do the initial processing of an individual
<GRADES> node might be
function(node)
xmlSApply(node, xmlValue)
since xmlValue returns the text content within an XML node.
Let's check that this does what we want by calling it on the
first child of the root node.
xmlSApply(doc[[1]], xmlValue)
And indeed it does.
So we can process all the <GRADES> nodes with the command
tmp = xmlSApply(doc, function(x) xmlSApply(x, xmlValue))
The result is a character matrix in which the rows are the variables and the columns
are the records. So let's transpose this.
tmp = t(tmp)
Now, we have finished working with the XML; the rest is regular R programming.
grades = as.data.frame(matrix(as.numeric(tmp[,-1]), 2))
names(grades) = names(doc[[1]])[-1]
grades$Student = tmp[,1]
There seems to be more messing about after we have got the values out of the XML file.
There are several things that might seem more complex but that actually just move
the work to different places, i.e. when we are traversing the XML tree.
Here's another alternative using XPath.
doc = xmlTreeParse("generic_file.xml", useInternal = TRUE)
ans = lapply(c("STUDENT", "TEST1", "TEST2", "FINAL"),
function(var)
unlist(xpathApply(doc, paste("//", var, sep = ""), xmlValue)))
And this gives us a list containing the variables
with the values as character vectors.
as.data.frame(lapply(names(ans),
function(x) if(x != "STUDENT") as.integer(x) else x ))
Another Example: Customer Information List
The second example is another list, this time of description of customers.
The first two nodes in the document are shown below:
ALFKI
Alfreds Futterkiste
Maria Anders
Sales Representative
Obere Str. 57
Berlin
12209
Germany
030-0074321
030-0076545
ANATR
Ana Trujillo Emparedados y helados
Ana Trujillo
Owner
Avda. de la Constitución 2222
México D.F.
05021
Mexico
(5) 555-4729
(5) 555-3745
]]>
We can quickly verify that all the nodes under the root are customers
with the command
doc = xmlRoot(xmlTreeParse("Cust-List.xml"))
table(names(doc))
We see that these are all "Customers".
We could further explore to see if each of these nodes has the same fields.
fields = xmlApply(doc, names)
table(sapply(fields, identical, fields[[1]]))
And the result indicates that about half of them are the same.
Let's see how many unique field names there are:
unique(unlist(fields))
This gives 10. And
we can see how may fields are in each of the Customers nodes with
xmlSApply(doc, xmlSize)
So most of the nodes have most of the fields.
So let's think about a data frame.
What we can do is treat each of the fields as having a simple string value.
Then we can create a data frame with the 10 character columns and with NA values for each
of the records. Thne we will fill this in record at a time.
ans = as.data.frame(replicate(10, character(xmlSize(doc))),
stringsAsFactors = FALSE)
names(ans) = unique(unlist(fields))
Now that we have the skeleton of the answer, we can process each of the
Customers nodes.
Note that we used a global assignemnt in the function to change the
ans in the global environment rather than the local version within the
function call.
Also, we loop over the indices of the
nodes in the tree, i.e. use sapply(1:xmlSize(doc), )
rather than xmlSApply(doc, )
simply because we need to know which row to put the results for each node.
There are various other ways to process these two XML files. One is
to use handler functions to process the internal nodes as they are
being converted from C-level data structures to R objects in a call to
xmlTreeParse. This avoids multiple traversal of the
tree but can seem a little indirect until you get the hang of it. And
some transformations can be cumbersome using this approach as it is a
bottom up transformation.
The event-driven parsing provided by xmlEventParse
is a SAX style approach. This is quite low level and used when
reading the entire XML document into memory and then processing it is prohibitive,
i.e. when the XML file is very, very large.
The use of XPath to perform queries and get subsets of nodes involves
a) learning XPath and b) potentially multiple passes over the tree.
If one has to do many queries, this can be slow overall eventhough each
is very fast. However, if you know XPath or are happy to learn the basics,
this can be quite convenient, avoiding having to write recursive functions
to search for the nodes of interests.
Using the internal nodes (as you must for XPath) also gives you the ability
to go up the tree, i.e. find parent, ancestor and sibling nodes, and not just
down to children. So we have more flexibility in how we traverse the tree.
XML/inst/examples/promptXML.Sxml 0000644 0001751 0000144 00000011510 13607633730 016300 0 ustar hornik users
]>
Here we define some
prompt.xml
this is the name of the file into which the documentation
is placed. In the future, this will be a connection object.
this is text that is to be placed immediately
after the ]]>
string emitted as the first part of the text.
In the future, we will want to append/insert
content into existing documents and so we will have to recognize
not to add this PI again, etc.
0) {
arg.names <- names(argls)
}
xml$addTag("sname", name,sep="")
for (i in s) {
xml$addTag("arg", xml$tagString("argName", arg.names[i]), close=F)
if(!is.missing.arg(argls[[i]])) {
xml$addTag("defaultValue", deparse(argls[[i]]),sep="")
}
xml$closeTag("arg")
if(i < n)
xml$addTag("next")
}
xml$add("")
xml$addTag("arguments", close=F)
for(i in arg.names) {
xml$addTag("argument", xml$tagString("argDescriptionName", i), "\n",
"~~Describe ",i," here~~", "")
}
xml$add("")
xml$addTag("details"," ~~ If necessary, more details than the __description__ above ~~")
xml$addTag("value", "~Describe the value returned",
" If it is a LIST, use", " \\item{comp1 }{Description of `comp1'}",
" \\item{comp2 }{Description of `comp2'}", " ...")
xml$addTag("references", ifelse(!is.null(local$references), local$references, ""))
xml$addTag("author", ifelse(!is.null(local$author), local$author, ""))
xml$addTag("note")
xml$addTag("seeAlso", xml$tagString("a", attrs=list("href"="\"\"")))
xml$addTag("examples", xml$tagString("example"))
xml$addTag("keywords", xml$tagString("keyword"))
if(!is.null(footer))
xml$add(footer)
val <- xml$value()
if(!missing(file))
cat(val, file=file)
val
}
]]>
# Always start with the perverse one!
xmlPrompt(xmlPrompt)
xmlWriteBuffer
Want to check with the DTD whether a tag is legitimate
attributes are valid, etc.
Add an indentation level.
Need to escape characters via entities:
%sgets;
< => %lt;
> => %gt;
]]>
etc.
"
add <- function(..., sep="\n") {
buf <<- paste(buf, paste0(...), sep=sep)
}
tagString <- function(tag, ..., attrs, close=F) {
tmp <- ""
if(!missing(attrs)) {
tmp <- paste(" ", paste(names(attrs), attrs,sep="=", collapse=" "),sep="")
}
return(paste0("<", tag,tmp, ">",...,""))
}
addTag <- function(tag, ..., attrs=NULL, sep="\n", close=T) {
tmp <- ""
if(!missing(attrs)) {
tmp <- paste(" ", paste(names(attrs), attrs,sep="=", collapse=" "),sep="")
}
add(paste("<",tag, tmp, ">", sep=""))
if(length(list(...)) > 0) {
add(..., sep=sep)
}
if(close) {
add(paste("", sep=""), sep="")
}
NULL
}
closeTag <- function(name) {
add("\n", "", sep="")
}
list( value=function() {buf},
add = add,
addTag = addTag,
closeTag = closeTag,
tagString = tagString
)
}
]]>
XML/inst/examples/itunes.xsl 0000644 0001751 0000144 00000001266 13607633725 015603 0 ustar hornik users
XML/inst/examples/HTMLText.R 0000644 0001751 0000144 00000001550 13607633725 015274 0 ustar hornik users # The following illustrates how we can get the text
# Michael Conklin.
# Also see ./foo.html as an example with javascript content
# and a pseudo/fake css node.
doc = htmlParse("http://www.omegahat.net/")
txt = xpathSApply(doc, "//body//text()", xmlValue)
#The result is a character vector that contains all the text.
#By limiting the nodes to the body, we avoid the content in
#such as inlined JavaScript or CSS.
#It is also possible that a document may have
CSS content
Some additional text. And a link.
Duncan Temple Lang
<duncan@wald.ucdavis.edu>
Last modified: Thu Dec 3 17:13:16 PST 2009