require 'rexml/source'

module REXML

end

require 'rexml/text'

module REXML

NEEDS_A_SECOND_CHECK = /(<|&((#{Entity::NAME});|(#0*((?:\d+)|(?:x[a-fA-F0-9]+)));)?)/um

# FIXME: The parser doesn't catch illegal characters in attributes

#

# first::

# Ignored unless +first+ is a String; otherwise, may be the Element

# parent of this attribute, or nil.

#

def doctype

end

@normalized

@unnormalized

if @normalized

Text.check( @normalized, NEEDS_A_SECOND_CHECK, doctype )

end

def node_type

:attribute

path += "/@#{self.expanded_name}"

return path

end

end

#vim:ts=2 sw=2 noexpandtab:

require "rexml/text"

module REXML

def value

@string

# == DEPRECATED

# See the rexml/formatters package

#

# The amount to indent this node by

# Ignored

# Ignored

Kernel.warn( "#{self.class.name}.write is deprecated" )

end

require "rexml/node"

module REXML

end

require "rexml/child"

module REXML

# == DEPRECATED

# See REXML::Formatters

#

Kernel.warn("Comment.write is deprecated. See REXML::Formatters")

def node_type

:comment

end

end

#vim:ts=2 sw=2 noexpandtab:

# Document has a single child that can be accessed by root().

# Note that if you want to have an XML declaration written for a document

# you create, you must add one; REXML documents do not write a default

# +DEPRECATED+

# Use: mydoc << XMLDecl.default

@entity_expansion_count = 0

def node_type

:document

end

child.parent = self

# Find first Element or DocType node and insert the decl right

# before it. If there is no such node, just insert the child at the

# end. If there is a child and it is an DocType, then replace it.

else # Insert at end of list

@children[insert_before_index] = child

end

elements[1]

#self

#@children.find { |item| item.kind_of? Element }

return rv if rv.kind_of? XMLDecl

rv = @children.unshift(XMLDecl.default)[0]

# Write the XML tree out, optionally with indent. This writes out the

# entire XML document, including XML declarations, doctype declarations,

REXML::Formatters::Default.new( ie_hack )

end

formatter.write( self, output )

@@entity_expansion_limit = 10_000

end

end

Parsers::TreeParser.new( source, self ).parse

end

require "rexml/child"

module REXML

end

require "rexml/parent"

module REXML

end

require "rexml/child"

module REXML

end

require "rexml/child"

module REXML

indent( output, indent )

end

require "rexml/child"

module REXML

indent( output, indent )

end

#

module REXML

module Encoding

# Convert from UTF-8

def encode_cp1252(content)

#

module REXML

module Encoding

alias decode from_iso_8859_15

# Convert from UTF-8

def to_iso_8859_15(content)

require 'rexml/xmltokens'

module REXML

document.record_entity_expansion

#

# out::

# An object implementing <TT>&lt;&lt;<TT> to which the entity will be

# output

# indent::

# *DEPRECATED* and ignored

end

require "rexml/source"

module REXML

# == DEPRECATED

# See the rexml/formatters package

#

Kernel.warn( "#{self.class.name}.write is deprecated" )

def node_type

:processing_instruction

def inspect

"<?p-i #{target} ...?>"

end

end

require 'rexml/light/node'

# [ :element, parent, name, attributes, children* ]

module REXML

end

require 'rexml/xmltokens'

module REXML

end

require "rexml/formatters/default"

module REXML

# indent::

# *DEPRECATED* This parameter is now ignored. See the formatters in the

# REXML::Formatters package for changing the output style.

unless indent.nil?

Kernel.warn( "#{self.class.name}.to_s(indent) parameter is deprecated" )

f = REXML::Formatters::Pretty.new( indent )

f.write( self, rv = "" )

end

return rv

if @parent and @parent.context and not @parent.context[:indentstyle].nil? then

indentstyle = @parent.context[:indentstyle]

else

indentstyle = ' '

end

to << indentstyle*ind unless ind<1

# evaluates to true. Returns +nil+ if none was found.

each_recursive {|node|

return node if block.call(node)

}

def index_in_parent

parent.index(self)+1

end

end

require 'rexml/encoding'

module REXML

attr_reader :encoding

def to_s

"Output[#{encoding}]"

end

end

require 'rexml/light/node'

module REXML

def add_listener( listener )

@parser.add_listener( listener )

@parser.stream = @stream

end

end

require 'rexml/text'

module REXML

# SAX2Parser

@entities = {}

def source

@parser.source

end

def add_listener( listener )

@parser.add_listener( listener )

end

#

# There is an additional symbol that can be listened for: :progress.

# This will be called for every event generated, passing in the current

# stream position.

when :start_doctype

handle( :doctype, *event[1..-1])

#normalized = @parser.normalize( event[1] )

#handle( :characters, normalized )

copy = event[1].clone

handle( :characters, copy )

when :entitydecl

@entities[ event[1] ] = event[2] if event.size == 3

handle( :progress, @parser.position )

#puts sym.inspect+"=="+symbol.inspect+ "\t"+match.inspect+"=="+name.inspect+ "\t"+( (sym.nil? or symbol == sym) and ((name.nil? and match.nil?) or match.nil? or ( (name == match) or (match.kind_of? Regexp and name =~ match)))).to_s

uris = (@namespace_stack.find_all { |ns| not ns[prefix].nil? }) ||

end

require 'rexml/parsers/baseparser'

module REXML

def add_listener( listener )

@parser.add_listener( listener )

@parser.stream = @stream

end

end

case op

when :node

when :attribute

when :child

when :descendant_or_self

string << "/"

when :self

string << ".."

when :any

string << "*"

when :following, :following_sibling,

:ancestor, :ancestor_or_self, :descendant,

:namespace, :preceding, :preceding_sibling

string << ']'

when :document

document = true

else

string << "/" unless string.size == 0

string << "UNKNOWN("

string << ")"

end

end

return string

end

def parse_args( string )

arguments = []

ind = 0

depth = 1

begin

case string[ind]

when ?"

when ?'

else

if depth == 1

end

end

end

ind += 1

require 'rexml/xmltokens'

module REXML

end

module REXML

# @p spaced the declaration is followed by a line break

def progress position

end

end

module REXML

end

require 'rexml/source'

module REXML

attr_reader :writeencoding, :writethis

@writethis = true

@writeencoding = !encoding.nil?

@writeencoding = version.writeencoding

# indent::

# Ignored. There must be no whitespace before an XML declaration

# Ignored

# ie_hack::

# Ignored

return nil unless @writethis or writer.kind_of? Output

if writer.kind_of? Output

writer << " #{content writer.encoding}"

else

writer << " #{content encoding}"

end

alias :old_enc= :encoding=

def encoding=( enc )

START.sub(/\\/u, '') + " ... " + STOP.sub(/\\/u, '')

end

end

module REXML

end

require 'rexml/xpath_parser'

module REXML

def XPath::first element, path=nil, namespaces=nil, variables={}

raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)

raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)

raise "The namespaces argument, if supplied, must be a hash object." unless namespaces.nil? or namespaces.kind_of?(Hash)

raise "The variables argument, if supplied, must be a hash object." unless variables.kind_of?(Hash)

end

return @variables[ var_name ]

# :and, :or, :eq, :neq, :lt, :lteq, :gt, :gteq

left = expr( path_stack.shift, nodeset.dup, context )

#puts "LEFT => #{left.inspect} (#{left.class.name})"

right = expr( path_stack.shift, nodeset.dup, context )

def equality_relational_compare( set1, op, set2 )

#puts "EQ_REL_COMP(#{set1.inspect} #{op.inspect} #{set2.inspect})"

if set1.kind_of? Array and set2.kind_of? Array

if set1.size == 1 and set2.size == 1

set1 = set1[0]

set2 = set2[0]

return res

end

end

#puts "COMPARING VALUES"

# If one is nodeset and other is number, compare number to each item

# in nodeset s.t. number op number(string(item))

# If one is nodeset and other is boolean, compare boolean to each item

# in nodeset s.t. boolean op boolean(item)

if set1.kind_of? Array or set2.kind_of? Array

if set1.kind_of? Array

a = set1

b = set2

#puts "B = #{b.inspect}"

return a.collect {|v| compare( Functions::number(v), op, b )}

else

b = Functions::string( b )

return a.collect { |v| compare( Functions::string(v), op, b ) }

end

class Proxy

def initialize(server, prefix, args=[], meth=:call, delim=".")

@meth = meth

end

def method_missing(mid, *args)

end

end # class Proxy

class Abstract

def ele(name, *children)

end

def tag(name, txt)

end

end

class Simple < Abstract

def document_to_str(doc)

end

def document(*params)

end

def pi(name, *params)

end

def element(name, attrs, *children)

if children.empty?

"<#{name}/>"

else

class XMLParser < Abstract

def initialize

end

def document_to_str(doc)

end

def document(*params)

end

def pi(name, *params)

end

def element(name, attrs, *children)

end

def text(txt)

end

end # class XMLParser

name = name.to_s

if name !~ /[a-zA-Z0-9_.:\/]+/

end

parameter = params.collect do |param|

end

tree = @writer.document(

@writer.document_to_str(tree) + "\n"

end

def methodResponse(is_ret, *params)

if is_ret

else

end

tree = @writer.document(

@writer.document_to_str(tree) + "\n"

end

#

def conv2value(param)

if Config::ENABLE_BIGINT

@writer.tag("i4", param.to_s)

else

raise "Bignum is too big! Must be signed 32-bit integer!"

end

end

when NilClass

if Config::ENABLE_NIL_CREATE

raise "Wrong type NilClass. Not allowed!"

end

if Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable

# convert Ruby object into Hash

ret = {"___class___" => param.class.name}

raise "Wrong type!"

end

end

end

def wrong_type(value)

# parse HTTP headers

while (line=io.gets) !~ /^(\n|\r)/

if line =~ /^([\w-]+):\s*(.*)$/

end

end

class AbstractTreeParser

def parseMethodResponse(str)

end

def parseMethodCall(str)

end

private

# and all comments

#

def removeWhitespacesAndComments(node)

# TODO: add nil?

unless %w(i4 int boolean string double dateTime.iso8601 base64).include? node.nodeName

else

remove << nd if nd.nodeValue.strip == ""

end

end

def nodeMustBe(node, name)

end

#

# returns, when successfully the only child-node

#

def hasOnlyOneChild(node, name=nil)

end

def assert(b)

end

# the node `node` has empty string or string

def text_zero_one(node)

end

def integer(node)

end

def boolean(node)

Convert.boolean(text(node.firstChild))

end

def v_nil(node)

nodeMustBe(node, "nil")

nil

end

def string(node)

end

def double(node)

end

def dateTime(node)

Convert.dateTime( text(node.firstChild) )

end

def base64(node)

Convert.base64(text_zero_one(node))

end

def member(node)

end

def name(node)

end

def array(node)

end

def data(node)

end

def param(node)

end

def methodResponse(node)

end

def methodName(node)

end

def params(node, call=true)

end

def fault(node)

Convert.fault(f)

end

# _nodeType is defined in the subclass

def text(node)

end

def struct(node)

Convert.struct(hash)

def value(node)

if nodes == 0

return ""

elsif nodes > 1

end

text_zero_one(node)

when "nil"

if Config::ENABLE_NIL_PARSER

v_nil(child)

else

raise "wrong/unknown XML-RPC type 'nil'"

end

end

def methodCall(node)

end

end # module TreeParserMixin

private

def _nodeType(node)

end

def methodResponse_document(node)

end

def methodCall_document(node)

end

def createCleanedTree(str)

end

end # class XMLParser

private

def _nodeType(node)

end

def methodResponse_document(node)

end

def methodCall_document(node)

end

def createCleanedTree(str)

doc = ::NQXML::TreeParser.new(str).document.rootNode

end

end # class NQXMLTreeParser

def parse(str)

parser = REXML::Document.parse_stream(str, self)

end

end

def create

# if set_writer was not already called then call it now

if @create.nil? then

end

@create

end

def parser

# if set_parser was not already called then call it now

if @parser.nil? then

end

@parser

end