Nokogiri_precompiled_aarch64_dedshit 1.14.5

data/ext/java/nokogiri/internals/c14n/NameSpaceSymbTable.java

@@ -0,0 +1,452 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package nokogiri.internals.c14n;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Node;
+
+/**
+ * A stack based Symbol Table.
+ *<br>For speed reasons all the symbols are introduced in the same map,
+ * and at the same time in a list so it can be removed when the frame is pop back.
+ * @author Raul Benito
+ */
+public class NameSpaceSymbTable
+{
+
+  private static final String XMLNS = "xmlns";
+  private static final SymbMap initialMap = new SymbMap();
+
+  static
+  {
+    NameSpaceSymbEntry ne = new NameSpaceSymbEntry("", null, true, XMLNS);
+    ne.lastrendered = "";
+    initialMap.put(XMLNS, ne);
+  }
+
+  /**The map betwen prefix-> entry table. */
+  private SymbMap symb;
+
+  /**The stacks for removing the definitions when doing pop.*/
+  private List<SymbMap> level;
+  private boolean cloned = true;
+
+  /**
+   * Default constractor
+   **/
+  public
+  NameSpaceSymbTable()
+  {
+    level = new ArrayList<SymbMap>();
+    //Insert the default binding for xmlns.
+    symb = (SymbMap) initialMap.clone();
+  }
+
+  /**
+   * Get all the unrendered nodes in the name space.
+   * For Inclusive rendering
+   * @param result the list where to fill the unrendered xmlns definitions.
+   **/
+  public void
+  getUnrenderedNodes(Collection<Attr> result)
+  {
+    Iterator<NameSpaceSymbEntry> it = symb.entrySet().iterator();
+    while (it.hasNext()) {
+      NameSpaceSymbEntry n = it.next();
+      //put them rendered?
+      if ((!n.rendered) && (n.n != null)) {
+        n = (NameSpaceSymbEntry) n.clone();
+        needsClone();
+        symb.put(n.prefix, n);
+        n.lastrendered = n.uri;
+        n.rendered = true;
+
+        result.add(n.n);
+      }
+    }
+  }
+
+  /**
+   * Push a frame for visible namespace.
+   * For Inclusive rendering.
+   **/
+  public void
+  outputNodePush()
+  {
+    push();
+  }
+
+  /**
+   * Pop a frame for visible namespace.
+   **/
+  public void
+  outputNodePop()
+  {
+    pop();
+  }
+
+  /**
+   * Push a frame for a node.
+   * Inclusive or Exclusive.
+   **/
+  public void
+  push()
+  {
+    //Put the number of namespace definitions in the stack.
+    level.add(null);
+    cloned = false;
+  }
+
+  /**
+   * Pop a frame.
+   * Inclusive or Exclusive.
+   **/
+  public void
+  pop()
+  {
+    int size = level.size() - 1;
+    Object ob = level.remove(size);
+    if (ob != null) {
+      symb = (SymbMap)ob;
+      if (size == 0) {
+        cloned = false;
+      } else {
+        cloned = (level.get(size - 1) != symb);
+      }
+    } else {
+      cloned = false;
+    }
+  }
+
+  final void
+  needsClone()
+  {
+    if (!cloned) {
+      level.set(level.size() - 1, symb);
+      symb = (SymbMap) symb.clone();
+      cloned = true;
+    }
+  }
+
+
+  /**
+   * Gets the attribute node that defines the binding for the prefix.
+   * @param prefix the prefix to obtain the attribute.
+   * @return null if there is no need to render the prefix. Otherwise the node of
+   * definition.
+   **/
+  public Attr
+  getMapping(String prefix)
+  {
+    NameSpaceSymbEntry entry = symb.get(prefix);
+    if (entry == null) {
+      //There is no definition for the prefix(a bug?).
+      return null;
+    }
+    if (entry.rendered) {
+      //No need to render an entry already rendered.
+      return null;
+    }
+    // Mark this entry as render.
+    entry = (NameSpaceSymbEntry) entry.clone();
+    needsClone();
+    symb.put(prefix, entry);
+    entry.rendered = true;
+    entry.lastrendered = entry.uri;
+    // Return the node for outputing.
+    return entry.n;
+  }
+
+  /**
+   * Gets a definition without mark it as render.
+   * For render in exclusive c14n the namespaces in the include prefixes.
+   * @param prefix The prefix whose definition is neaded.
+   * @return the attr to render, null if there is no need to render
+   **/
+  public Attr
+  getMappingWithoutRendered(String prefix)
+  {
+    NameSpaceSymbEntry entry = symb.get(prefix);
+    if (entry == null) {
+      return null;
+    }
+    if (entry.rendered) {
+      return null;
+    }
+    return entry.n;
+  }
+
+  /**
+   * Adds the mapping for a prefix.
+   * @param prefix the prefix of definition
+   * @param uri the Uri of the definition
+   * @param n the attribute that have the definition
+   * @return true if there is already defined.
+   **/
+  public boolean
+  addMapping(String prefix, String uri, Attr n)
+  {
+    NameSpaceSymbEntry ob = symb.get(prefix);
+    if ((ob != null) && uri.equals(ob.uri)) {
+      //If we have it previously defined. Don't keep working.
+      return false;
+    }
+    //Creates and entry in the table for this new definition.
+    NameSpaceSymbEntry ne = new NameSpaceSymbEntry(uri, n, false, prefix);
+    needsClone();
+    symb.put(prefix, ne);
+    if (ob != null) {
+      //We have a previous definition store it for the pop.
+      //Check if a previous definition(not the inmidiatly one) has been rendered.
+      ne.lastrendered = ob.lastrendered;
+      if ((ob.lastrendered != null) && (ob.lastrendered.equals(uri))) {
+        //Yes it is. Mark as rendered.
+        ne.rendered = true;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Adds a definition and mark it as render.
+   * For inclusive c14n.
+   * @param prefix the prefix of definition
+   * @param uri the Uri of the definition
+   * @param n the attribute that have the definition
+   * @return the attr to render, null if there is no need to render
+   **/
+  public Node
+  addMappingAndRender(String prefix, String uri, Attr n)
+  {
+    NameSpaceSymbEntry ob = symb.get(prefix);
+
+    if ((ob != null) && uri.equals(ob.uri)) {
+      if (!ob.rendered) {
+        ob = (NameSpaceSymbEntry) ob.clone();
+        needsClone();
+        symb.put(prefix, ob);
+        ob.lastrendered = uri;
+        ob.rendered = true;
+        return ob.n;
+      }
+      return null;
+    }
+
+    NameSpaceSymbEntry ne = new NameSpaceSymbEntry(uri, n, true, prefix);
+    ne.lastrendered = uri;
+    needsClone();
+    symb.put(prefix, ne);
+    if ((ob != null) && (ob.lastrendered != null) && (ob.lastrendered.equals(uri))) {
+      ne.rendered = true;
+      return null;
+    }
+    return ne.n;
+  }
+
+  public int
+  getLevel()
+  {
+    return level.size();
+  }
+
+  public void
+  removeMapping(String prefix)
+  {
+    NameSpaceSymbEntry ob = symb.get(prefix);
+
+    if (ob != null) {
+      needsClone();
+      symb.put(prefix, null);
+    }
+  }
+
+  public void
+  removeMappingIfNotRender(String prefix)
+  {
+    NameSpaceSymbEntry ob = symb.get(prefix);
+
+    if (ob != null && !ob.rendered) {
+      needsClone();
+      symb.put(prefix, null);
+    }
+  }
+
+  public boolean
+  removeMappingIfRender(String prefix)
+  {
+    NameSpaceSymbEntry ob = symb.get(prefix);
+
+    if (ob != null && ob.rendered) {
+      needsClone();
+      symb.put(prefix, null);
+    }
+    return false;
+  }
+}
+
+/**
+ * The internal structure of NameSpaceSymbTable.
+ **/
+class NameSpaceSymbEntry implements Cloneable
+{
+
+  String prefix;
+
+  /**The URI that the prefix defines */
+  String uri;
+
+  /**The last output in the URI for this prefix (This for speed reason).*/
+  String lastrendered = null;
+
+  /**This prefix-URI has been already render or not.*/
+  boolean rendered = false;
+
+  /**The attribute to include.*/
+  Attr n;
+
+  NameSpaceSymbEntry(String name, Attr n, boolean rendered, String prefix)
+  {
+    this.uri = name;
+    this.rendered = rendered;
+    this.n = n;
+    this.prefix = prefix;
+  }
+
+  /** @inheritDoc */
+  public Object
+  clone()
+  {
+    try {
+      return super.clone();
+    } catch (CloneNotSupportedException e) {
+      return null;
+    }
+  }
+}
+
+class SymbMap implements Cloneable
+{
+  int free = 23;
+  NameSpaceSymbEntry[] entries;
+  String[] keys;
+
+  SymbMap()
+  {
+    entries = new NameSpaceSymbEntry[free];
+    keys = new String[free];
+  }
+
+  void
+  put(String key, NameSpaceSymbEntry value)
+  {
+    int index = index(key);
+    Object oldKey = keys[index];
+    keys[index] = key;
+    entries[index] = value;
+    if ((oldKey == null || !oldKey.equals(key)) && (--free == 0)) {
+      free = entries.length;
+      int newCapacity = free << 2;
+      rehash(newCapacity);
+    }
+  }
+
+  List<NameSpaceSymbEntry>
+  entrySet()
+  {
+    List<NameSpaceSymbEntry> a = new ArrayList<NameSpaceSymbEntry>();
+    for (int i = 0; i < entries.length; i++) {
+      if ((entries[i] != null) && !("".equals(entries[i].uri))) {
+        a.add(entries[i]);
+      }
+    }
+    return a;
+  }
+
+  protected int
+  index(Object obj)
+  {
+    Object[] set = keys;
+    int length = set.length;
+    //abs of index
+    int index = (obj.hashCode() & 0x7fffffff) % length;
+    Object cur = set[index];
+
+    if (cur == null || (cur.equals(obj))) {
+      return index;
+    }
+    length--;
+    do {
+      index = index == length ? 0 : ++index;
+      cur = set[index];
+    } while (cur != null && (!cur.equals(obj)));
+    return index;
+  }
+
+  /**
+   * rehashes the map to the new capacity.
+   *
+   * @param newCapacity an <code>int</code> value
+   */
+  protected void
+  rehash(int newCapacity)
+  {
+    int oldCapacity = keys.length;
+    String oldKeys[] = keys;
+    NameSpaceSymbEntry oldVals[] = entries;
+
+    keys = new String[newCapacity];
+    entries = new NameSpaceSymbEntry[newCapacity];
+
+    for (int i = oldCapacity; i-- > 0;) {
+      if (oldKeys[i] != null) {
+        String o = oldKeys[i];
+        int index = index(o);
+        keys[index] = o;
+        entries[index] = oldVals[i];
+      }
+    }
+  }
+
+  NameSpaceSymbEntry
+  get(String key)
+  {
+    return entries[index(key)];
+  }
+
+  protected Object
+  clone()
+  {
+    try {
+      SymbMap copy = (SymbMap) super.clone();
+      copy.entries = new NameSpaceSymbEntry[entries.length];
+      System.arraycopy(entries, 0, copy.entries, 0, entries.length);
+      copy.keys = new String[keys.length];
+      System.arraycopy(keys, 0, copy.keys, 0, keys.length);
+
+      return copy;
+    } catch (CloneNotSupportedException e) {
+      e.printStackTrace();
+    }
+    return null;
+  }
+}

data/ext/java/nokogiri/internals/c14n/NodeFilter.java

@@ -0,0 +1,52 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package nokogiri.internals.c14n;
+
+import org.w3c.dom.Node;
+
+/**
+ * An interface to tell to the c14n if a node is included or not in the output
+ */
+public interface NodeFilter
+{
+
+  /**
+   * Tells if a node must be output in c14n.
+   * @param n
+   * @return 1 if the node should be output.
+   * 		   0 if node must not be output,
+   * 		  -1 if the node and all it's child must not be output.
+   *
+   */
+  int isNodeInclude(Node n);
+
+  /**
+   * Tells if a node must be output in a c14n.
+   * The caller must assured that this method is always call
+   * in document order. The implementations can use this
+   * restriction to optimize the transformation.
+   * @param n
+   * @param level the relative level in the tree
+   * @return 1 if the node should be output.
+   * 		   0 if node must not be output,
+   * 		  -1 if the node and all it's child must not be output.
+   */
+  int isNodeIncludeDO(Node n, int level);
+
+}

data/ext/java/nokogiri/internals/c14n/UtfHelpper.java

@@ -0,0 +1,190 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package nokogiri.internals.c14n;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Map;
+
+public final class UtfHelpper
+{
+
+  private
+  UtfHelpper()
+  {
+    // complete
+  }
+
+  public static void
+  writeByte(
+    final String str,
+    final OutputStream out,
+    Map<String, byte[]> cache
+  ) throws IOException
+  {
+    byte[] result = cache.get(str);
+    if (result == null) {
+      result = getStringInUtf8(str);
+      cache.put(str, result);
+    }
+
+    out.write(result);
+  }
+
+  public static void
+  writeCharToUtf8(final char c, final OutputStream out) throws IOException
+  {
+    if (c < 0x80) {
+      out.write(c);
+      return;
+    }
+    if ((c >= 0xD800 && c <= 0xDBFF) || (c >= 0xDC00 && c <= 0xDFFF)) {
+      //No Surrogates in sun java
+      out.write(0x3f);
+      return;
+    }
+    int bias;
+    int write;
+    char ch;
+    if (c > 0x07FF) {
+      ch = (char)(c >>> 12);
+      write = 0xE0;
+      if (ch > 0) {
+        write |= (ch & 0x0F);
+      }
+      out.write(write);
+      write = 0x80;
+      bias = 0x3F;
+    } else {
+      write = 0xC0;
+      bias = 0x1F;
+    }
+    ch = (char)(c >>> 6);
+    if (ch > 0) {
+      write |= (ch & bias);
+    }
+    out.write(write);
+    out.write(0x80 | ((c) & 0x3F));
+
+  }
+
+  public static void
+  writeStringToUtf8(
+    final String str,
+    final OutputStream out
+  ) throws IOException
+  {
+    final int length = str.length();
+    int i = 0;
+    char c;
+    while (i < length) {
+      c = str.charAt(i++);
+      if (c < 0x80)  {
+        out.write(c);
+        continue;
+      }
+      if ((c >= 0xD800 && c <= 0xDBFF) || (c >= 0xDC00 && c <= 0xDFFF)) {
+        //No Surrogates in sun java
+        out.write(0x3f);
+        continue;
+      }
+      char ch;
+      int bias;
+      int write;
+      if (c > 0x07FF) {
+        ch = (char)(c >>> 12);
+        write = 0xE0;
+        if (ch > 0) {
+          write |= (ch & 0x0F);
+        }
+        out.write(write);
+        write = 0x80;
+        bias = 0x3F;
+      } else {
+        write = 0xC0;
+        bias = 0x1F;
+      }
+      ch = (char)(c >>> 6);
+      if (ch > 0) {
+        write |= (ch & bias);
+      }
+      out.write(write);
+      out.write(0x80 | ((c) & 0x3F));
+
+    }
+
+  }
+
+  public static byte[]
+  getStringInUtf8(final String str)
+  {
+    final int length = str.length();
+    boolean expanded = false;
+    byte[] result = new byte[length];
+    int i = 0;
+    int out = 0;
+    char c;
+    while (i < length) {
+      c = str.charAt(i++);
+      if (c < 0x80) {
+        result[out++] = (byte)c;
+        continue;
+      }
+      if ((c >= 0xD800 && c <= 0xDBFF) || (c >= 0xDC00 && c <= 0xDFFF)) {
+        //No Surrogates in sun java
+        result[out++] = 0x3f;
+        continue;
+      }
+      if (!expanded) {
+        byte newResult[] = new byte[3 * length];
+        System.arraycopy(result, 0, newResult, 0, out);
+        result = newResult;
+        expanded = true;
+      }
+      char ch;
+      int bias;
+      byte write;
+      if (c > 0x07FF) {
+        ch = (char)(c >>> 12);
+        write = (byte)0xE0;
+        if (ch > 0) {
+          write |= (ch & 0x0F);
+        }
+        result[out++] = write;
+        write = (byte)0x80;
+        bias = 0x3F;
+      } else {
+        write = (byte)0xC0;
+        bias = 0x1F;
+      }
+      ch = (char)(c >>> 6);
+      if (ch > 0) {
+        write |= (ch & bias);
+      }
+      result[out++] = write;
+      result[out++] = (byte)(0x80 | ((c) & 0x3F));
+    }
+    if (expanded) {
+      byte newResult[] = new byte[out];
+      System.arraycopy(result, 0, newResult, 0, out);
+      result = newResult;
+    }
+    return result;
+  }
+}