R自动数据收集第二章HTML笔记2(主要关于htmlTreeParse函数)

包含以下几个小的知识点
1htmlTreeParse函数源码和一些参数
2hander的写法
3关于missing函数
4关于if-else语句中else语句的花括号问题
5关于checkHandlerNames(handlers, "DOM")函数
6关于GeneralHandlerNames属性
7关于match函数
8关于inherits函数
9关于on.exit函数
===============================================================================
还是尝试去阅读下该函数的源码：
htmlTreeParse函数
  1. function (file, ignoreBlanks = TRUE, handlers = NULL, replaceEntities = FALSE, 
  2.     asText = FALSE, trim = TRUE, validate = FALSE, getDTD = TRUE, 
  3.     isURL = FALSE, asTree = FALSE, addAttributeNamespaces = FALSE, 
  4.     useInternalNodes = FALSE, isSchema = FALSE, fullNamespaceInfo = FALSE, 
  5.     encoding = character(), useDotNames = length(grep("^\\.", 
  6.         names(handlers))) > 0, xinclude = TRUE, addFinalizer = TRUE, 
  7.     error = htmlErrorHandler, isHTML = TRUE, options = integer(), 
  8.     parentFirst = FALSE) 
  9. {
  10.     #asText=T则file作为XML文本处理
  11.     isMissingAsText = missing(asText)
  12.     #地址大于一个时要中止程序并抛出异常
  13.     if (length(file) > 1) {
  14.         file = paste(file, collapse = "\n")
  15.         if (!missing(asText) && !asText) 
  16.             stop(structure(list(message = "multiple URLs passed to xmlTreeParse. If this is the content of the file, specify asText = TRUE"), 
  17.                 class = c("MultipleURLError", "XMLParserError", 
  18.                   "simpleError", "error", "condition")))
  19.         asText = TRUE
  20.     }
  21.     #当isURL非空时且是XML的时候，才修改URL为数值型
  22.     #比如这里isURL=1
  23.     if (missing(isURL) && !asText) 
  24.         isURL <- length(grep("^(http|ftp|file)://", file, useBytes = TRUE, 
  25.             perl = TRUE))
  26.    #isHTML 默认为 TRUE
  27.     if (isHTML) {
  28.         validate = FALSE
  29.         getDTD = FALSE
  30.         isSchema = FALSE
  31.         docClass = "HTMLInternalDocument"
  32.     }
  33.     else docClass = character()
  34.     #checkHandlerNames返回的是一个逻辑值，其作用是
  35.     checkHandlerNames(handlers, "DOM")
  36.     if (missing(fullNamespaceInfo) && inherits(handlers, "RequiresNamespaceInfo")) 
  37.         fullNamespaceInfo = TRUE
  38.     oldValidate = xmlValidity()
  39.     xmlValidity(validate)
  40.     on.exit(xmlValidity(oldValidate))
  41.     if (!asText && isURL == FALSE) {
  42.         if (file.exists(file) == FALSE) 
  43.             if (!missing(asText) && asText == FALSE) {
  44.                 e = simpleError(paste("File", file, "does not exist"))
  45.                 class(e) = c("FileNotFound", class(e))
  46.                 stop(e)
  47.             }
  48.             else asText <- TRUE
  49.     }
  50.     if (asText && length(file) > 1) 
  51.         file = paste(file, collapse = "\n")
  52.     old = setEntitySubstitution(replaceEntities)
  53.     on.exit(setEntitySubstitution(old), add = TRUE)
  54.     if (asText && length(grep(sprintf("^%s?\\s*<", BOMRegExp), 
  55.         file, perl = TRUE, useBytes = TRUE)) == 0) {
  56.         if (!isHTML || (isMissingAsText && !inherits(file, "AsIs"))) {
  57.             e = simpleError(paste("XML content does not seem to be XML:", 
  58.                 sQuote(file)))
  59.             class(e) = c("XMLInputError", class(e))
  60.             (if (isHTML) 
  61.                 warning
  62.             else stop)(e)
  63.         }
  64.     }
  65.     if (!is.logical(xinclude)) {
  66.         xinclude = as.logical(xinclude)
  67.     }
  68.     if (!asText && !isURL) 
  69.         file = path.expand(as.character(file))
  70.     if (useInternalNodes && trim) {
  71.         prevBlanks = .Call("RS_XML_setKeepBlanksDefault", 0L, 
  72.             PACKAGE = "XML")
  73.         on.exit(.Call("RS_XML_setKeepBlanksDefault", prevBlanks, 
  74.             PACKAGE = "XML"), add = TRUE)
  75.     }
  76.     .oldErrorHandler = setXMLErrorHandler(error)
  77.     on.exit(.Call("RS_XML_setStructuredErrorHandler", .oldErrorHandler, 
  78.         PACKAGE = "XML"), add = TRUE)
  79.     if (length(options)) 
  80.         options = sum(options)
  81.     ans <- .Call("RS_XML_ParseTree", as.character(file), handlers, 
  82.         as.logical(ignoreBlanks), as.logical(replaceEntities), 
  83.         as.logical(asText), as.logical(trim), as.logical(validate), 
  84.         as.logical(getDTD), as.logical(isURL), as.logical(addAttributeNamespaces), 
  85.         as.logical(useInternalNodes), as.logical(isHTML), as.logical(isSchema), 
  86.         as.logical(fullNamespaceInfo), as.character(encoding), 
  87.         as.logical(useDotNames), xinclude, error, addFinalizer, 
  88.         as.integer(options), as.logical(parentFirst), PACKAGE = "XML")
  89.     if (!missing(handlers) && length(handlers) && !as.logical(asTree)) 
  90.         return(handlers)
  91.     if (!isSchema && length(class(ans))) 
  92.         class(ans) = c(docClass, oldClass(class(ans)))
  93.     if (inherits(ans, "XMLInternalDocument")) 
  94.         addDocFinalizer(ans, addFinalizer)
  95.     else if (!getDTD && !isSchema) {
  96.         class(ans) = oldClass("XMLDocumentContent")
  97.     }
  98.     ans
  99. }
  100. <environment: namespace:XML>
查看整个htmlTreeParse函数的源代码，可以用到handler的地方并不多。

我们看一下xmlTreeParse {XML}中对于该参数的描述：
参数handlers：
Optional collection of functions(函数集) used to map the different XML nodes to R objects. Typically, this is a named list of functions, and a closure(闭包) can be used to provide local data. This provides a way of filtering the tree as it is being created in R, adding or removing nodes, and generally processing them as they are constructed in the C code.
In a recent addition to the package (version 0.99-8), if this is specified as a single function object, we call that function for each node (of any type) in the underlying DOM tree. It is invoked with（调用） the new node（新节点） and its parent node（父节点）. This applies to regular nodes（普通节点） and also comments（注释）, processing instructions, CDATA nodes, etc. So this function must be sufficiently general to handle them all.

asTree参数
this only applies when on passes a value for the handlers argument and is used then to determine whether the DOM tree should be returned or the handlers object.
该参数在有传入处理器函数的时候要设置为TRUE，此时，函数的返回值是处理后的DOM树，而不是handlers函数对象本身

useDotNames参数
a logical value indicating whether to use the newer format for identifying general element function handlers with the '.' prefix, e.g. .text, .comment, .startElement. If this is FALSE, then the older format text, comment, startElement, ... are used. This causes problems when there are indeed nodes named text or comment or startElement as a node-specific handler are confused with the corresponding general handler of the same name(如果函数名叫startElement，而有个节点(自定义标签吧)，也交startElement就会让函数困惑滴). Using TRUE means that your list of handlers should have names that use the '.' prefix for these general element handlers. This is the preferred way to write new code.
TRUE是使用新的格式(函数以.开头)来区分
FLALSE是用旧的格式
实际上配合参数里的这一句很容易理解：
useDotNames = length(grep("^\\.", names(handlers))) > 0
取得处理函数的名字，看看其是否以点开头，如果长度不大于0，就是没有，就是FALSE咯


isURL参数
indicates whether the file argument refers to a URL (accessible via ftp or http) or a regular file on the system. If asText is TRUE, this should not be specified. The function attempts to determine whether the data source is a URL by using grep to look for http or ftp at the start of the string. The libxml parser handles the connection to servers, not the R facilities (e.g. scan).


hander的写法——在文档的Details中：
The handlers argument is used similarly to those specified in xmlEventParse. When an XML tag (element) is processed, we look for a function in this collection with the same name as the tag's name. If this is not found, we look for one named startElement. If this is not found, we use the default built in converter(变换器). The same works for comments, entity references, cdata, processing instructions, etc. The default entries should be named comment, startElement, externalEntity, processingInstruction, text, cdata and namespace. All but the last should take the XMLnode as their first argument. In the future, other information may be passed via ..., for example, the depth in the tree, etc. Specifically, the second argument will be the parent node into which they are being added, but this is not currently implemented, so should have a default value (NULL).
当一个标签被处理时，在函数集里1先找和标签同名的函数，2找startElement，最后才找默认的函数
当一个注释等被处理时，也是一样。那么也就是说，比如处理注释的时候，先找叫comment的函数呗，
所以，handler中的函数命名(列表的组件名)是需要讲规律的
node必须作为这些函数的第一个参数。
嗯，这一段讲的很好~，把handler函数怎么编写讲清楚了。

这个博客，也提到了这些参数的含义，有空可以看看

=======================================================================
  1. #test
  2. #导包
  3. library(XML)
  4. #链接
  5. url <- "http://www.r-datacollection.com/materials/html/fortunes.html"
  6. #handers函数
  7. h2 <- list(
  8.   startElement = function(node, ...){
  9.     name <- xmlName(node)
  10.     if(name %in% c("div", "title")){NULL}else{node}
  11.   },
  12.   comment = function(node){NULL}
  13. )
  15. #正式开始，函数参数
  16. file=url
  17. ignoreBlanks = TRUE
  18. handlers = h2
  19. replaceEntities = FALSE
  20. asText = FALSE
  21. trim = TRUE
  22. validate = FALSE
  23. getDTD = TRUE
  24. isURL = FALSE
  25. asTree = TRUE
  26. addAttributeNamespaces = FALSE
  27. useInternalNodes = FALSE
  28. isSchema = FALSE
  29. fullNamespaceInfo = FALSE 
  30. encoding = character()
  31. useDotNames = length(grep("^\\.", names(handlers))) > 0
  32. xinclude = TRUE
  33. addFinalizer = TRUE
  34. error = XML:::htmlErrorHandler
  35. isHTML = TRUE
  36. options = integer()
  37. parentFirst = FALSE
  38. #函数体部分
  39.   #asText参数没有传入
  40.   #我们将其从missing(asText)改为TRUE
  41.   isMissingAsText = TRUE
  42.   #file的长度是否大于1，大于1如果asText未传入则要报错：传入了多个URL
  43.   #不大于1，则跳过
  44.   if (length(file) > 1) {
  45.     file = paste(file, collapse = "\n")
  46.     if (!missing(asText) && !asText) 
  47.       stop(structure(list(message = "multiple URLs passed to xmlTreeParse. If this is the content of the file, specify asText = TRUE"), 
  48.                      class = c("MultipleURLError", "XMLParserError", 
  49.                                "simpleError", "error", "condition")))
  50.     asText = TRUE
  51.   }
  52.   
  54.   # 本来是if (missing(isURL) && !asText)
  55.   # 我们修改为if (TURE && !asText)
  56.   #isURL参数没有传递且asText参数为假才执行
  57.   if (TRUE && !asText) 
  58.     isURL <- length(grep("^(http|ftp|file)://", file, useBytes = TRUE, 
  59.                          perl = TRUE))
  60.   #只要有http|ftp|file中的一个协议开头，比如http://，就是URL了。
  61.   # 此时isURL=1
  62.   
  63.   #是否为HTML，是的
  64.   if (isHTML) {
  65.     validate = FALSE
  66.     getDTD = FALSE  #从默认值T改为了F
  67.     isSchema = FALSE
  68.     docClass = "HTMLInternalDocument"
  69.   }else {docClass = character()} #否则创建空的
  70.   # class(docClass)
  71.   
  72.   #返回TRUE通过检验了，否则函数会中止并抛出异常
  73.   XML:::checkHandlerNames(handlers, "DOM")
  74.   
  75.   
  76.   #fullNamespaceInfo参数whether to provide the namespace URI and prefix on each node
  77.   #其实就是是否在节点面前带上URI信息
  78.   #fullNamespaceInfo为空且handlers含有该属性，才执行这一步
  79.   #missing(fullNamespaceInfo)被替换为TRUE
  80.   #handlers并没有RequiresNamespaceInfo属性,所以不执行
  81.   if ( TRUE && inherits(handlers, "RequiresNamespaceInfo")) 
  82.     fullNamespaceInfo = TRUE
  83.   
  84.   #以下两行的结果都是integer(0)
  85.   #奇妙~，先保存原有的配置
  86.   oldValidate = XML:::xmlValidity()
  87.   #当前的配置
  88.   XML:::xmlValidity(validate)
  89.   #还原原来的配置
  90.   on.exit(XML:::xmlValidity(oldValidate))
  91.   
  92.   #asText为假，且isURL是假的
  93.   #结果为TFALSE，我们不必管他
  94.   if (!asText && isURL == FALSE) {
  95.     if (file.exists(file) == FALSE) 
  96.       #如果本地文件不存在
  97.       if (!missing(asText) && asText == FALSE) {
  98.         #抛出异常，文件不存在
  99.         e = simpleError(paste("File", file, "does not exist"))
  100.         class(e) = c("FileNotFound", class(e))
  101.         stop(e)
  102.       }
  103.     else asText <- TRUE
  104.   }
  105.   
  106.   #此时asText是FALSE，这个跟我们无关
  107.   if (asText && length(file) > 1) 
  108.     file = paste(file, collapse = "\n")
  109.   
  110.   #replaceEntities的默认值是FALSE
  111.   old = XML:::setEntitySubstitution(replaceEntities)
  112.   #old的值是FALSE
  113.   on.exit(XML:::setEntitySubstitution(old), add = TRUE)
  114.   
  115.   #BOMRegExp是一个内置的常量吧
  116.   #看名字应该是基于BOM的正则表达式
  117.   #因为是FALSE，所以我们也先不去管它
  118.   if (asText && length(grep(
  119.                             sprintf("^%s?\\s*<", XML:::BOMRegExp), 
  120.                             file, perl = TRUE, useBytes = TRUE
  121.                             )
  122.                        ) == 0) 
  123.     {
  124.     if (!isHTML || (isMissingAsText && !inherits(file, "AsIs"))) {
  125.       e = simpleError(paste("XML content does not seem to be XML:", 
  126.                             sQuote(file)))
  127.       class(e) = c("XMLInputError", class(e))
  128.       (if (isHTML) 
  129.         warning
  130.         else stop)(e)
  131.     }
  132.   }
  133.   
  134.   #xinclude默认值是TRUE
  135.   #以下三个if都是F，所以不管了
  136.   if (!is.logical(xinclude)) {
  137.     xinclude = as.logical(xinclude)
  138.   }
  139.   if (!asText && !isURL) 
  140.     file = path.expand(as.character(file))
  141.   if (useInternalNodes && trim) {
  142.     prevBlanks = .Call("RS_XML_setKeepBlanksDefault", 0L, 
  143.                        PACKAGE = "XML")
  144.     on.exit(.Call("RS_XML_setKeepBlanksDefault", prevBlanks, 
  145.                   PACKAGE = "XML"), add = TRUE)
  146.   }
  147.   
  149.   .oldErrorHandler = XML:::setXMLErrorHandler(error)
  150.   #所以，这种点开头的命名是什么鬼？
  151.   # class(.oldErrorHandler)
  152.   # [1] "list"
  153.   on.exit(.Call("RS_XML_setStructuredErrorHandler", .oldErrorHandler, 
  154.                 PACKAGE = "XML"), add = TRUE)
  155.   
  156.   # length(options)是0，所以不执行
  157.   if (length(options)) 
  158.     options = sum(options)
  159.   #调用一个叫做RS_XML_ParseTree的函数
  160.   getAnywhere("RS_XML_ParseTree")
  161.   ans <- .Call("RS_XML_ParseTree", as.character(file), handlers, 
  162.                as.logical(ignoreBlanks), as.logical(replaceEntities), 
  163.                as.logical(asText), as.logical(trim), as.logical(validate), 
  164.                as.logical(getDTD), as.logical(isURL), as.logical(addAttributeNamespaces), 
  165.                as.logical(useInternalNodes), as.logical(isHTML), as.logical(isSchema), 
  166.                as.logical(fullNamespaceInfo), as.character(encoding), 
  167.                as.logical(useDotNames), xinclude, error, addFinalizer, 
  168.                as.integer(options), as.logical(parentFirst), PACKAGE = "XML")
  169.   print(ans)
  170.   print("-------我是可爱的分割线------------------")
  171.   #这里的missing(handlers)我们就不改了哈
  172.   #毕竟只要有默认值，他都觉得是TRUE
  173.   #和我们的确传递了处理函数的效果TRUE是一样的
  174.   if (!missing(handlers) && length(handlers) && !as.logical(asTree)) 
  175.     return("呵呵")
  176.   if (!isSchema && length(class(ans))) 
  177.     class(ans) = c(docClass, oldClass(class(ans)))
  178.   if (inherits(ans, "XMLInternalDocument")) {
  179.     addDocFinalizer(ans, addFinalizer) 
  180.   }else if (!getDTD && !isSchema) {
  181.     print("看我的类型")
  182.     print(class(ans))
  183.     class(ans) = oldClass("XMLDocumentContent")
  184.     print(class(ans))
  185.   }
  186.   print("看条件判断的逻辑值")
  187.   print("1")
  188.   print(!missing(handlers) && length(handlers) && !as.logical(asTree))
  189.   print("2")
  190.   print(!isSchema && length(class(ans)))
  191.   print("3")
  192.   print(inherits(ans, "XMLInternalDocument"))
  193.   print("4")
  194.   print(!getDTD && !isSchema)
  195.   print(class(ans))
  196.   ans
用来调试理解该函数的代码：

注释1：关于missing函数
missing(asText)的含义并不是判断asText是否缺失，而是判断asText作为函数的形参，是否已经在函数被调用的时候传入了实参，所以即便形参asText是有默认值的，missing(asText)的返回值结果仍然是TRUE
  1. #例子1
  2. testMissing<-function(a=TRUE,b=FALSE){
  3.   if(missing(b))
  4.     return("b is missing")
  5.   else "b is here "+b
  6. }
  7. testMissing(F)
  8. # [1] "b is missing"
  10. #例子2
  11. if(missing(b))
  12.   return("b is missing")
  13. # Error in missing(b) : 'missing' can only be used for arguments
  15. #例子3
  16. b=NULL
  17. if(missing(b))
  18.   return("b is missing")
  19. #没有输出

注释2 关于if-else语句中else语句的花括号问题
例子1
  1. if (isHTML) {
  2.     validate = FALSE
  3.     getDTD = FALSE  #从默认值T改为了F
  4.     isSchema = FALSE
  5.     docClass = "HTMLInternalDocument"
  6.   }else {docClass = character()} #否则创建空的
或者
  1. }else docClass = character()
前面的花括号很重要，在交互式模式，R语法分析器用else前面的右花括号来推断这是一个if-else结构，而不是if结构
见《R语言编程艺术中文版》P20
例子2
  1. function(){
  2.   if (isHTML) {
  3.     validate = FALSE
  4.     getDTD = FALSE  #从默认值T改为了F
  5.     isSchema = FALSE
  6.     docClass = "HTMLInternalDocument"
  7.   }
  8.   else docClass = character() #否则创建空的
  9. }
如果在函数体内，这样写是OK的。
否则，会报错：
Error: unexpected 'else' in "  else"


注释3.1：checkHandlerNames(handlers, "DOM")函数
事实上，必须要借助getAnywhere(checkHandlerNames)的帮助，才能获得其源码
我们可以在最后一行可以看到：<environment: namespace:XML>
所以我们可以通过XML:::checkHandlerNames()调用它
  1. function (handlers, id = "SAX") 
  2. {
  3.     if (is.null(handlers))                 #为空，则返回TRUE
  4.         return(TRUE)
  5.     ids = names(handlers)           #取出handlers中的函数名
  6.     i = match(ids, )  #匹配，返回逻辑值向量
  7.     prob = any(!is.na(i)) #任一个回空才是TRUE
  8.     if (prob) {
  9.         warning("future versions of the XML package will require names of general handler functions 
  10. to be prefixed by a . to distinguish them from handlers for nodes with those names.  This _may_ affect the ", 
  11.             paste(names(handlers)[!is.na(i)], collapse = ", "))
  12.     }
  13.     #任意一个handler中的函数不是函数类型，则抛出异常
  14.     if (any(w <- !sapply(handlers, is.function))) 
  15.         warning("some handlers are not functions: ", paste(names(handlers[w]), 
  16.             collapse = ", "))
  17.     #返回TRUE，后续代码继续运行
  18.     !prob
  19. }
  20. <environment: namespace:XML>

注释3.2关于GeneralHandlerNames属性
还真是人如其名呀，常用处理函数名
  1. > XML:::GeneralHandlerNames
  2. $SAX
  3. [1] "text"                  "startElement"         
  4. [3] "endElement"            "comment"              
  5. [5] "startDocument"         "endDocument"          
  6. [7] "processingInstruction" "entityDeclaration"    
  7. [9] "externalEntity"       
  9. $DOM
  10. [1] "text"                  "startElement"         
  11. [3] "comment"               "entity"               
  12. [5] "cdata"                 "processingInstruction"
分别有SAX和DOM两种方式，想起学Java时的DOM和SAX解析没？

注释3.3关于match函数
  1. > h2 <- list(
  2. +   startElement = function(node, ...){
  3. +     name <- xmlName(node)
  4. +     if(name %in% c("div", "title")){NULL}else{node}
  5. +   },
  6. +   comment = function(node){NULL}
  7. + )
  8. > handlers<-h2
  9. > ids = names(handlers)   
  10. > ids
  11. [1] "startElement" "comment"     
  12. > i = match(ids, XML:::GeneralHandlerNames)
  13. > i
  14. [1] NA NA
  15. > ?match
  16. starting httpd help server ... done
  17. > !is.na(i) #如果i中有NA，则返回F，没有NA则返回T
  18. [1] FALSE FALSE
  19. > prob = any(!is.na(i)) #当i中的任意一个元素都不是NA的时候，prob才返回T
  20. > prob
  21. [1] FALSE
match returns a vector of the positions of (first) matches of its first argument in its second.
math函数实际上返回的是：第一个参数中的元素如果匹配了第二个参数中的值，那么到底匹配的是第二个元素中的第几个，即其位置。
  1. > testMatch<-c("a","c")
  2. > testSet <- c('a','b','c')
  3. > match(testMatch,testSet)
  4. [1] 1 3
事实上，看警告信息，未来版本的XML将要求普通的处理函数前面要加一个前缀点(.)，以区别于节点他们名字的处理函数(到底是哪些呢？)
future versions of the XML package will require names of general handler functions 
to be prefixed by a . to distinguish them from handlers for nodes with those names.  This _may_ affect the
所以我觉得，这一个match和if判断，其实是一个预设吧，毕竟id='SAX'压根没有用到，应该是作者的编码还没打算在当前版本增加该设定。
其实在useDotNames中已经提到了


注释4关于inherits函数
inherits indicates whether its first argument inherits from any of the classes specified in the what argument. If which is TRUE then an integer vector of the same length as what is returned. Each element indicates the position in the class(x) matched by the element of what; zero indicates no match. If which is FALSE then TRUE is returned by inherits if any of the names in what match with any class.
what, value
   a character vector naming classes. value can also be NULL.  
inherits函数指明第一个参数是否继承了what参数中的任何一个classs类型
如果which为真，则inherits 返回一个同what一样长度的整型向量，每一个元素表示该位置的元素匹配了what的类型，如果数字是0，则表示不匹配
如果which为假，则当what中任意一个名字匹配了类型时，inherits 返回真
  1. x <- 10
  2. class(x) # "numeric"
  3. oldClass(x) # NULL
  4. #看了下文档，我个人觉得oldClass是S语言的余毒啊！！！
  5. inherits(x, "a") #FALSE

  7. class(x) <- c("a", "b")
  8. # x
  9. # [1] 10
  10. # attr(,"class")
  11. # [1] "a" "b"
  12. #即，x为10这个变量被赋予了两个class，分别名为"a"和 "b"
  13. inherits(x,"a") #TRUE
  14. inherits(x, "a", TRUE) # 1
  15. inherits(x, c("a", "b", "c"), TRUE) # 1 2 0

注释5.1：几行难懂的代码
  1.   #以下两行的结果都是integer(0)
  2.   #奇妙~，先保存原有的配置
  3.   oldValidate = XML:::xmlValidity()
  4.   #使用当前的配置
  5.   XML:::xmlValidity(validate)
  6.   #还原
  7.   on.exit(XML:::xmlValidity(oldValidate))
先看下xmlValidity函数
  1. > XML:::xmlValidity()
  2. integer(0)
  3. > getAnywhere(xmlValidity)
  4. A single object matching ‘xmlValidity’ was found
  5. It was found in the following places
  6.   namespace:XML
  7. with value
  8. function (val = integer(0)) 
  9. {
  10.     .Call("RS_XML_getDefaultValiditySetting", as.integer(val), 
  11.         PACKAGE = "XML")
  12. }
  13. <environment: namespace:XML>
无奈没有更多的信息
RS_XML_getDefaultValiditySetting，看命名应该是获取默认正确的设定
我们再来看：

注释5.2.1：关于on.exit函数
on.exit records the expression given as its argument as needing to be executed when the current function exits (either naturally or as the result of an error). This is useful for resetting graphical parameters or performing other cleanup actions.
on.exit记录作为其参数的表达式，在当前的函数退出(自然结束或者出错)时执行，他通常用来充值图形参数，或者执行清理行为。
例子1
  1. > opar <- par(bg='lightblue')
  2. > on.exit(par(opar))
  3. > plot(c(1,2,3),c(4,5,6))#蓝色背景
  4. > plot(c(1,2,3,4,5),runif(5))#蓝色背景
  5. #此时关闭绘图窗口
  6. > plot(c(1,2,3,4,5),rnorm(5))
  7. #白色背景
例子2
  1. plot_with_big_margins <- function(...)
  2. {
  3.   old_pars <- par(mar = c(10, 9, 9, 7))  
  4.   on.exit(par(old_pars))
  5.   plot(...)
  6. }
  7. plot_with_big_margins(with(cars, speed, dist))

  10. #不关闭图像窗口，此时再运行如下语句
  11. plot(c(1,2,3),c(4,5,6))
  12.  

  14. 对比


  17. plot_with_big_margins <- function(...)
  18. {
  19.   par(mar = c(10, 9, 9, 7))  
  20.   plot(...)
  21. }
  22. plot_with_big_margins(with(cars, speed, dist))

  24.  

  26. #不关闭图像窗口，此时再运行：
  27. plot(c(1,2,3),c(4,5,6))

  29.  
并在其所在函数退出后，就失效（注意，par()函数的设定是对当前窗口的所有图标有效，只要窗口没有清理和关闭）。
他所谓的在函数结束时候执行，是说这个on.exit()函数被放在哪个函数里，哪个函数结束的时候，它才执行。
但是代码有点奇怪对不对？
  1. old_pars <- par(mar = c(10, 9, 9, 7))  
  2. on.exit(par(old_pars))
不是要还原吗？为什么是把old_pars传递给par()?
事实上：
  1. > old_pars <- par(mar = c(10, 9, 9, 7))
  2. > old_pars
  3. $mar

  5. [1] 5.1 4.1 4.1 2.1
  6. > op <- options(stringsAsFactors = FALSE)
  7. > op
  8. $stringsAsFactors
  9. [1] TRUE
我们得到的是尚未改变之前的参数，而不是改变后的参数
我们可以验证这个结论，重启R。
  1. par()             #得到的mar是5.1 4.1 4.1 2.1
  2. plot_with_big_margins <- function(...)
  3. {
  4.   old_pars <- par(mar = c(10, 9, 9, 7))  #原参数被保存，新参数设置生效

  6.   print(par())    #得到的mar是10, 9, 9, 7

  8.   on.exit(par(old_pars))                 #参数被还原为原来的参数
  9.   plot(...)
  10. }
  11. plot_with_big_margins(with(cars, speed, dist))

  13. par()             #得到的mar是5.1 4.1 4.1 2.1
看到了吧，这就是他重置原参数的功能
例子3
  1. my_plot <- function()
  2. {
  3.   with(cars, plot(speed, dist))
  4. }
  5. save_base_plot <- function(plot_fn, file)
  6. {
  7.   png(file)
  8.   on.exit(dev.off())
  9.   plot_fn()
  10. }
  11. save_base_plot(my_plot, "testcars.png")
下面这篇sof的答案回答的很详细:

注释5.2.2：关于on.exit函数
那么
  1.   #replaceEntities的默认值是FALSE
  2.   old = XML:::setEntitySubstitution(replaceEntities)
  3.   #old的值是FALSE
  4.   on.exit(XML:::setEntitySubstitution(old), add = TRUE)
这几行代码的功能是类似的
  1. > XML:::setEntitySubstitution
  2. function (val) 
  3. .Call("RS_XML_SubstituteEntitiesDefault", as.logical(val), PACKAGE = "XML")
  4. <environment: namespace:XML>

注释5.2.3：关于on.exit函数
  1. .oldErrorHandler = XML:::setXMLErrorHandler(error)
  2.   #所以，这种点开头的命名是什么鬼？
  3.   # class(.oldErrorHandler)
  4.   # [1] "list"
  5.   on.exit(.Call("RS_XML_setStructuredErrorHandler", .oldErrorHandler, 
  6.                 PACKAGE = "XML"), add = TRUE)


  9. > XML:::htmlErrorHandler
  10. function (msg, code, domain, line, col, level, filename, class = "XMLError") 
  11. {
  12.     e = makeXMLError(msg, code, domain, line, col, level, filename, 
  13.         class)
  14.     dom = names(e$domain)
  15.     class(e) = c(names(e$code), sprintf("%s_Error", gsub("_FROM_", 
  16.         "_", dom)), class(e))
  17.     if (e$code == xmlParserErrors["XML_IO_LOAD_ERROR"]) 
  18.         stop(e)
  19. }
  20. <environment: namespace:XML>


  23. > XML:::setXMLErrorHandler
  24. function (fun) 
  25. {
  26.     prev = .Call("RS_XML_getStructuredErrorHandler", PACKAGE = "XML")
  27.     sym = getNativeSymbolInfo("R_xmlStructuredErrorHandler", 
  28.         "XML")$address
  29.     .Call("RS_XML_setStructuredErrorHandler", list(fun, sym), 
  30.         PACKAGE = "XML")
  31.     prev
  32. }
  33. <environment: namespace:XML>
其实是错误处理的方式的配置

注释4：关于判断条件
其实BOMRegExp是一个常量
  1. > getAnywhere(BOMRegExp)
  2. A single object matching ‘BOMRegExp’ was found
  3. It was found in the following places
  4.   namespace:XML
  5. with value
  7. [1] "(\\xEF\\xBB\\xBF|\\xFE\\xFF|\\xFF\\xFE)"
 sprintf("^%s?\\s*<", BOMRegExp)是C语言中的打印语句，被包装后用到R里面了，%s代表BOMRegExp的内容。


ans <- .Call("RS_XML_ParseTree", as.character(file), handlers, 
               as.logical(ignoreBlanks), as.logical(replaceEntities), 
               as.logical(asText), as.logical(trim), as.logical(validate), 
               as.logical(getDTD), as.logical(isURL), as.logical(addAttributeNamespaces), 
               as.logical(useInternalNodes), as.logical(isHTML), as.logical(isSchema), 
               as.logical(fullNamespaceInfo), as.character(encoding), 
               as.logical(useDotNames), xinclude, error, addFinalizer, 
               as.integer(options), as.logical(parentFirst), PACKAGE = "XML")

这里再插入下怎么看.Call的源码的那个sof链接
主要是community wiki的答案
还有Rstudio其实选中函数按下F2可以查看源码的
这篇问答里，提供了R中各种类型的函数的源码查看方式
 《R news article》P43
我也下载了：

我也使用照做了，下载了源码看：
  1. untar(download.packages(pkgs = "XML",
  2.                         destdir = ".",
  3.                         type = "source")[,2])
然后用everything搜索了下，发现在我的文档下，找到src：
在文件内部检索，也只查到了
 但是再也查不到其他的信息了，ENTYR应该入口吧？小弟的C只是本科时被老师误人子弟的...........（如有读者朋友知道，请评论），21是限定的参数的个数。
所以没有看到最终C的代码，有点遗憾，其实我关于htmlTreeParse函数源码的查看的核心任务没有完成呐
以后不看这么细致了...........抓住主要结构，毕竟C不给看，不给还是学到了一些琐碎的知识点。








附件列表

     

    posted @ 2016-12-30 21:53  旅鼠  阅读(1601)  评论(0)  编辑  收藏  举报