xaiml 0.1.0

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/README.md

@@ -0,0 +1,307 @@
+# Ox gem
+A fast XML parser and Object marshaller as a Ruby gem.
+
+[![Build Status](https://secure.travis-ci.org/ohler55/ox.png?branch=master)](http://travis-ci.org/ohler55/ox)
+
+## Installation
+    gem install ox
+
+## Documentation
+
+*Documentation*: http://www.ohler.com/ox
+
+## Source
+
+*GitHub* *repo*: https://github.com/ohler55/ox
+
+*RubyGems* *repo*: https://rubygems.org/gems/ox
+
+## Follow @oxgem on Twitter
+
+[Follow @peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Ox gem.
+
+## Build Status
+
+
+## Links of Interest
+
+[Ruby XML Gem Comparison](http://www.ohler.com/dev/xml_with_ruby/xml_with_ruby.html) for a performance comparison between Ox, Nokogiri, and LibXML.
+
+[Fast Ruby XML Serialization](http://www.ohler.com/dev/ruby_object_xml_serialization/ruby_object_xml_serialization.html) to see how Ox can be used as a faster replacement for Marshal.
+
+*Fast JSON parser and marshaller on RubyGems*: https://rubygems.org/gems/oj
+
+*Fast JSON parser and marshaller on GitHub*: https://github.com/ohler55/oj
+
+## Release Notes
+
+See [CHANGELOG.md](CHANGELOG.md)
+
+## Description
+
+Optimized XML (Ox), as the name implies was written to provide speed optimized
+XML and now HTML handling. It was designed to be an alternative to Nokogiri and other Ruby
+XML parsers in generic XML parsing and as an alternative to Marshal for Object
+serialization.
+
+Unlike some other Ruby XML parsers, Ox is self contained. Ox uses nothing
+other than standard C libraries so version issues with libXml are not an
+issue.
+
+Marshal uses a binary format for serializing Objects. That binary format
+changes with releases making Marshal dumped Object incompatible between some
+versions. The use of a binary format make debugging message streams or file
+contents next to impossible unless the same version of Ruby and only Ruby is
+used for inspecting the serialize Object. Ox on the other hand uses human
+readable XML. Ox also includes options that allow strict, tolerant, or a mode
+that automatically defines missing classes.
+
+It is possible to write an XML serialization gem with Nokogiri or other XML
+parsers but writing such a package in Ruby results in a module significantly
+slower than Marshal. This is what triggered the start of Ox development.
+
+Ox handles XML documents in three ways. It is a generic XML parser and writer,
+a fast Object / XML marshaller, and a stream SAX parser. Ox was written for
+speed as a replacement for Nokogiri, Ruby LibXML, and for Marshal.
+
+As an XML parser it is 2 or more times faster than Nokogiri and as a generic
+XML writer it is as much as 20 times faster than Nokogiri. Of course different
+files may result in slightly different times.
+
+As an Object serializer Ox is up to 6 times faster than the standard Ruby
+Marshal.dump() and up to 3 times faster than Marshal.load().
+
+The SAX like stream parser is 40 times faster than Nokogiri and more than 13
+times faster than LibXML when validating a file with minimal Ruby
+callbacks. Unlike Nokogiri and LibXML, Ox can be tuned to use only the SAX
+callbacks that are of interest to the caller. (See the perf_sax.rb file for an
+example.)
+
+Ox is compatible with Ruby 1.8.7, 1.9.3, 2.1.2, 2.2.0 and RBX.
+
+### Object Dump Sample:
+
+```ruby
+require 'ox'
+
+class Sample
+  attr_accessor :a, :b, :c
+
+  def initialize(a, b, c)
+    @a = a
+    @b = b
+    @c = c
+  end
+end
+
+# Create Object
+obj = Sample.new(1, "bee", ['x', :y, 7.0])
+# Now dump the Object to an XML String.
+xml = Ox.dump(obj)
+# Convert the object back into a Sample Object.
+obj2 = Ox.parse_obj(xml)
+```
+
+### Generic XML Writing and Parsing:
+
+```ruby
+require 'ox'
+
+doc = Ox::Document.new(:version => '1.0')
+
+top = Ox::Element.new('top')
+top[:name] = 'sample'
+doc << top
+
+mid = Ox::Element.new('middle')
+mid[:name] = 'second'
+top << mid
+
+bot = Ox::Element.new('bottom')
+bot[:name] = 'third'
+mid << bot
+
+xml = Ox.dump(doc)
+
+# xml =
+# <top name="sample">
+#   <middle name="second">
+#     <bottom name="third"/>
+#   </middle>
+# </top>
+
+doc2 = Ox.parse(xml)
+puts "Same? #{doc == doc2}"
+# true
+```
+
+### HTML Parsing:
+
+Ox can be used to parse HTML with a few options changes. HTML is often loose in
+regard to conformance. For HTML parsing try these options.
+
+```ruby
+Ox.default_options = {
+    mode:   :generic,
+    effort: :tolerant,
+    smart:  true
+}
+```
+
+### SAX XML Parsing:
+
+```ruby
+require 'stringio'
+require 'ox'
+
+class Sample < ::Ox::Sax
+  def start_element(name); puts "start: #{name}";        end
+  def end_element(name);   puts "end: #{name}";          end
+  def attr(name, value);   puts "  #{name} => #{value}"; end
+  def text(value);         puts "text #{value}";         end
+end
+
+io = StringIO.new(%{
+<top name="sample">
+  <middle name="second">
+    <bottom name="third"/>
+  </middle>
+</top>
+})
+
+handler = Sample.new()
+Ox.sax_parse(handler, io)
+# outputs
+# start: top
+#   name => sample
+# start: middle
+#   name => second
+# start: bottom
+#   name => third
+# end: bottom
+# end: middle
+# end: top
+```
+
+### Yielding results immediately while SAX XML Parsing:
+
+```ruby
+require 'stringio'
+require 'ox'
+
+class Yielder < ::Ox::Sax
+  def initialize(block); @yield_to = block; end
+  def start_element(name); @yield_to.call(name); end
+end
+
+io = StringIO.new(%{
+<top name="sample">
+  <middle name="second">
+    <bottom name="third"/>
+  </middle>
+</top>
+})
+
+proc = Proc.new { |name| puts name }
+handler = Yielder.new(proc)
+puts "before parse"
+Ox.sax_parse(handler, io)
+puts "after parse"
+# outputs
+# before parse
+# top
+# middle
+# bottom
+# after parse
+```
+
+### Parsing XML into a Hash (fast)
+
+```ruby
+require 'ox'
+
+xml = %{
+<top name="sample">
+  <middle name="second">
+    <bottom name="third">Rock bottom</bottom>
+  </middle>
+</top>
+}
+
+puts Ox.load(xml, mode: :hash)
+puts Ox.load(xml, mode: :hash_no_attrs)
+
+#{:top=>[{:name=>"sample"}, {:middle=>[{:name=>"second"}, {:bottom=>[{:name=>"third"}, "Rock bottom"]}]}]}
+#{:top=>{:middle=>{:bottom=>"Rock bottom"}}}
+```
+
+### Object XML format
+
+The XML format used for Object encoding follows the structure of the
+Object. Each XML element is encoded so that the XML element name is a type
+indicator. Attributes of the element provide additional information such as
+the Class if relevant, the Object attribute name, and Object ID if
+necessary.
+
+The type indicator map is:
+
+- **a** => `Array`
+- **b** => `Base64` - only for legacy loads
+- **c** => `Class`
+- **f** => `Float`
+- **g** => `Regexp`
+- **h** => `Hash`
+- **i** => `Fixnum`
+- **j** => `Bignum`
+- **l** => `Rational`
+- **m** => `Symbol`
+- **n** => `FalseClass`
+- **o** => `Object`
+- **p** => `Ref`
+- **r** => `Range`
+- **s** => `String`
+- **t** => `Time`
+- **u** => `Struct`
+- **v** => `Complex`
+- **x** => `Raw`
+- **y** => `TrueClass`
+- **z** => `NilClass`
+
+If the type is an Object, type 'o' then an attribute named 'c' should be set
+with the full Class name including the Module names. If the XML element
+represents an Object then a sub-elements is included for each attribute of
+the Object. An XML element attribute 'a' is set with a value that is the
+name of the Ruby Object attribute. In all cases, except for the Exception
+attribute hack the attribute names begin with an @ character. (Exception are
+strange in that the attributes of the Exception Class are not named with a @
+suffix. A hack since it has to be done in C and can not be done through the
+interpreter.)
+
+Values are encoded as the text portion of an element or in the sub-elements
+of the principle. For example, a Fixnum is encoded as:
+```xml
+<i>123</i>
+```
+An Array has sub-elements and is encoded similar to this example.
+```xml
+<a>
+  <i>1</i>
+  <s>abc</s>
+</a>
+```
+A Hash is encoded with an even number of elements where the first element is
+the key and the second is the value. This is repeated for each entry in the
+Hash. An example is of { 1 => 'one', 2 => 'two' } encoding is:
+```xml
+<h>
+  <i>1</i>
+  <s>one</s>
+  <i>2</i>
+  <s>two</s>
+</h>
+```
+
+Ox supports circular references where attributes of one Object can refer to
+an Object that refers back to the first Object. When this option is used an
+Object ID is added to each XML Object element as the value of the 'a'
+attribute.

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/Makefile

@@ -0,0 +1,264 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0
+hdrdir = $(topdir)
+arch_hdrdir = /Users/koji_dev/.rbenv/versions/2.5.1/include/ruby-2.5.0/x86_64-darwin17
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/Users/koji_dev/.rbenv/versions/2.5.1
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(DESTDIR)./.gem.20180906-71072-1l9777a
+sitelibdir = $(DESTDIR)./.gem.20180906-71072-1l9777a
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(SDKROOT)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = clang
+CXX = clang++
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static -framework Foundation
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = 
+cflags   = $(optflags) $(debugflags) $(warnflags)
+cxxflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wno-tautological-compare -Wno-parentheses-equality -Wno-constant-logical-operand -Wno-self-assign -Wunused-variable -Wimplicit-int -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wshorten-64-to-32 -Wimplicit-function-declaration -Wdivision-by-zero -Wdeprecated-declarations -Wextra-tokens
+CCDLFLAGS = -fno-common
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -pipe $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS =  -I/Users/koji_dev/.rbenv/versions/2.5.1/include  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT $(DEFS) $(cppflags) -DRUBY_TYPE=ruby -DRUBY_RUBY -DRUBY_VERSION=2.5.1 -DRUBY_VERSION_MAJOR=2 -DRUBY_VERSION_MINOR=5 -DRUBY_VERSION_MICRO=1 -DHAS_RB_TIME_TIMESPEC=0 -DHAS_TM_GMTOFF=1 -DHAS_ENCODING_SUPPORT=1 -DHAS_ONIG=1 -DHAS_PRIVATE_ENCODING=0 -DHAS_NANO_TIME=1 -DHAS_RSTRUCT=1 -DHAS_IVAR_HELPERS=1 -DHAS_PROC_WITH_BLOCK=1 -DHAS_GC_GUARD=1 -DHAS_BIGDECIMAL=1 -DHAS_TOP_LEVEL_ST_H=0 -DNEEDS_UIO=1 -DHAS_DATA_OBJECT_WRAP=1 -DUNIFY_FIXNUM_AND_BIGNUM=1 -Wall
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags  = -L. -L/Users/koji_dev/.rbenv/versions/2.5.1/lib  -fstack-protector -L/usr/local/lib
+dldflags = -L/Users/koji_dev/.rbenv/versions/2.5.1/lib  -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = libtool -static
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby.2.5.1
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-darwin17
+sitearch = $(arch)
+ruby_version = 2.5.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS =   -lpthread -lgmp -ldl -lobjc 
+ORIG_SRCS = base64.c builder.c cache.c cache8.c dump.c err.c gen_load.c hash_load.c obj_load.c ox.c parse.c sax.c sax_as.c sax_buf.c sax_hint.c special.c
+SRCS = $(ORIG_SRCS) 
+OBJS = base64.o builder.o cache.o cache8.o dump.o err.o gen_load.o hash_load.o obj_load.o ox.o parse.o sax.o sax_as.o sax_buf.o sax_hint.o special.o
+HDRS = $(srcdir)/type.h $(srcdir)/err.h $(srcdir)/helper.h $(srcdir)/attr.h $(srcdir)/sax_buf.h $(srcdir)/base64.h $(srcdir)/sax_has.h $(srcdir)/sax_stack.h $(srcdir)/cache.h $(srcdir)/buf.h $(srcdir)/cache8.h $(srcdir)/sax.h $(srcdir)/sax_hint.h $(srcdir)/ox.h $(srcdir)/special.h
+LOCAL_HDRS = 
+TARGET = ox
+TARGET_NAME = ox
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.sitearchdir.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object $(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+	$(Q) $(POSTLINK)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/vendor/bundle/ruby/2.5.0/gems/ox-2.10.0/ext/ox/attr.h

@@ -0,0 +1,84 @@
+/* attr.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OX_ATTR_H__
+#define __OX_ATTR_H__
+
+#include "ox.h"
+
+#define ATTR_STACK_INC	8
+
+typedef struct _Attr {
+    const char	*name;
+    const char	*value;
+} *Attr;
+
+typedef struct _AttrStack {
+    struct _Attr	base[ATTR_STACK_INC];
+    Attr		head;	/* current stack */
+    Attr		end;	/* stack end */
+    Attr		tail;	/* pointer to one past last element name on stack */
+} *AttrStack;
+
+inline static void
+attr_stack_init(AttrStack stack) {
+    stack->head = stack->base;
+    stack->end = stack->base + sizeof(stack->base) / sizeof(struct _Attr);
+    stack->tail = stack->head;
+    stack->head->name = 0;
+}
+
+inline static int
+attr_stack_empty(AttrStack stack) {
+    return (stack->head == stack->tail);
+}
+
+inline static void
+attr_stack_cleanup(AttrStack stack) {
+    if (stack->base != stack->head) {
+        xfree(stack->head);
+	stack->head = stack->base;
+    }
+}
+
+inline static void
+attr_stack_push(AttrStack stack, const char *name, const char *value) {
+    if (stack->end <= stack->tail + 1) {
+	size_t	len = stack->end - stack->head;
+	size_t	toff = stack->tail - stack->head;
+
+	if (stack->base == stack->head) {
+	    stack->head = ALLOC_N(struct _Attr, len + ATTR_STACK_INC);
+	    memcpy(stack->head, stack->base, sizeof(struct _Attr) * len);
+	} else {
+	    REALLOC_N(stack->head, struct _Attr, len + ATTR_STACK_INC);
+	}
+	stack->tail = stack->head + toff;
+	stack->end = stack->head + len + ATTR_STACK_INC;
+    }
+    stack->tail->name = name;
+    stack->tail->value = value;
+    stack->tail++;
+    stack->tail->name = 0; // terminate
+}
+
+inline static Attr
+attr_stack_peek(AttrStack stack) {
+    if (stack->head < stack->tail) {
+	return stack->tail - 1;
+    }
+    return 0;
+}
+
+inline static Attr
+attr_stack_pop(AttrStack stack) {
+    if (stack->head < stack->tail) {
+	stack->tail--;
+	return stack->tail;
+    }
+    return 0;
+}
+
+#endif /* __OX_ATTR_H__ */