bool Step::predicatesAreContextListInsensitive() const
{
for (size_t i = 0; i < m_predicates.size(); ++i) {
Predicate* predicate = m_predicates[i].get();
if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
return false;
}
for (size_t i = 0; i < nodeTest().mergedPredicates().size(); ++i) {
Predicate* predicate = nodeTest().mergedPredicates()[i].get();
if (predicate->isContextPositionSensitive() || predicate->isContextSizeSensitive())
return false;
}
return true;
}
void Step::optimize()
{
// Evaluate predicates as part of node test if possible to avoid building
// unnecessary NodeSets.
// E.g., there is no need to build a set of all "foo" nodes to evaluate
// "foo[@bar]", we can check the predicate while enumerating.
// This optimization can be applied to predicates that are not context node
// list sensitive, or to first predicate that is only context position
// sensitive, e.g. foo[position() mod 2 = 0].
WillBeHeapVector<OwnPtrWillBeMember<Predicate> > remainingPredicates;
for (size_t i = 0; i < m_predicates.size(); ++i) {
OwnPtrWillBeRawPtr<Predicate> predicate(m_predicates[i].release());
if ((!predicate->isContextPositionSensitive() || nodeTest().mergedPredicates().isEmpty()) && !predicate->isContextSizeSensitive() && remainingPredicates.isEmpty()) {
nodeTest().mergedPredicates().append(predicate.release());
} else {
remainingPredicates.append(predicate.release());
}
}
swap(remainingPredicates, m_predicates);
}
/*! \fn afterFlashInitTests(void)
* \brief Test functions launched after flash init
*/
void afterFlashInitTests(void)
{
//#define TEST_NODE
#ifdef TEST_NODE
nodeTest();
// spin
while(1);
#endif
//#define TEST_HID_AND_CDC
#ifdef TEST_HID_AND_CDC
//Show_String("Z",FALSE,2,0);
//usbKeyboardPress(KEY_S, 0);
while(1)
{
int n = usb_serial_getchar();
if (n >= 0)
{
usb_serial_putchar(n);
oledSetXY(2,0);
oledPutch((char)n);
//usbKeyboardPress(n,0);
}
}
#endif /* TEST_HID_AND_CDC */
//#define NESSIE_TEST_VECTORS
#ifdef NESSIE_TEST_VECTORS
while(1)
{
// msg into oled display
oledSetXY(2,0);
printf_P(PSTR("send s to start nessie test"));
int input0 = usb_serial_getchar();
nessieOutput = &usb_serial_putchar;
// do nessie test after sending s or S chars
if (input0 == 's' || input0 == 'S')
{
nessieTest(1);
nessieTest(2);
nessieTest(3);
nessieTest(4);
nessieTest(5);
nessieTest(6);
nessieTest(7);
nessieTest(8);
}
}
#endif
//#define CTR_TEST_VECTORS
#ifdef CTR_TEST_VECTORS
while(1)
{
// msg into oled display
oledSetXY(2,0);
printf_P(PSTR("send s to start CTR test"));
int input1 = usb_serial_getchar();
ctrTestOutput = &usb_serial_putchar;
// do ctr test after sending s or S chars
if (input1 == 's' || input1 == 'S')
{
aes256CtrTest();
}
}
#endif
//#define TEST_CTR_SPEED
#ifdef TEST_CTR_SPEED
// msg into oled display
oledSetXY(2,0);
usbPrintf_P(PSTR("CTR speed TEST with 1000 encryptions\n"));
usbPrintf_P(PSTR("Time:"));
usbPrintf_P(PSTR("%lu ms"), aes256CtrSpeedTest());
while(1);
#endif
//#define TEST_RNG
#ifdef TEST_RNG
while(1)
{
// init avrentropy library
EntropyInit();
// msg into oled display
oledSetXY(2,0);
printf_P(PSTR("send s to start entropy"));
int input2 = usb_serial_getchar();
uint32_t randomNumCtr;
// do nessie test after sending s or S chars
if (input2 == 's' || input2 == 'S')
{
while(EntropyAvailable() < 2);
EntropyRandom8();
usb_serial_putchar(EntropyBytesAvailable());
for(randomNumCtr=0; randomNumCtr<25; randomNumCtr++)
{
usb_serial_putchar(EntropyRandom8());
}
}
}
#endif
}
// Result nodes are ordered in axis order. Node test (including merged
// predicates) is applied.
void Step::nodesInAxis(EvaluationContext& evaluationContext, Node* context, NodeSet& nodes) const
{
ASSERT(nodes.isEmpty());
switch (m_axis) {
case ChildAxis:
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, ChildAxis, nodeTest()))
nodes.append(n);
}
return;
case DescendantAxis:
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context)) {
if (nodeMatches(evaluationContext, n, DescendantAxis, nodeTest()))
nodes.append(n);
}
return;
case ParentAxis:
if (context->isAttributeNode()) {
Element* n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, ParentAxis, nodeTest()))
nodes.append(n);
} else {
ContainerNode* n = context->parentNode();
if (n && nodeMatches(evaluationContext, n, ParentAxis, nodeTest()))
nodes.append(n);
}
return;
case AncestorAxis: {
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, AncestorAxis, nodeTest()))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode()) {
if (nodeMatches(evaluationContext, n, AncestorAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
}
case FollowingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE)
return;
for (Node* n = context->nextSibling(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, FollowingSiblingAxis, nodeTest()))
nodes.append(n);
}
return;
case PrecedingSiblingAxis:
if (context->nodeType() == Node::ATTRIBUTE_NODE)
return;
for (Node* n = context->previousSibling(); n; n = n->previousSibling()) {
if (nodeMatches(evaluationContext, n, PrecedingSiblingAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
case FollowingAxis:
if (context->isAttributeNode()) {
for (Node* p = NodeTraversal::next(*toAttr(context)->ownerElement()); p; p = NodeTraversal::next(*p)) {
if (nodeMatches(evaluationContext, p, FollowingAxis, nodeTest()))
nodes.append(p);
}
} else {
for (Node* p = context; !isRootDomNode(p); p = p->parentNode()) {
for (Node* n = p->nextSibling(); n; n = n->nextSibling()) {
if (nodeMatches(evaluationContext, n, FollowingAxis, nodeTest()))
nodes.append(n);
for (Node* c = n->firstChild(); c; c = NodeTraversal::next(*c, n)) {
if (nodeMatches(evaluationContext, c, FollowingAxis, nodeTest()))
nodes.append(c);
}
}
}
}
return;
case PrecedingAxis: {
if (context->isAttributeNode())
context = toAttr(context)->ownerElement();
Node* n = context;
while (ContainerNode* parent = n->parentNode()) {
for (n = NodeTraversal::previous(*n); n != parent; n = NodeTraversal::previous(*n)) {
if (nodeMatches(evaluationContext, n, PrecedingAxis, nodeTest()))
nodes.append(n);
}
n = parent;
}
nodes.markSorted(false);
return;
}
case AttributeAxis: {
if (!context->isElementNode())
return;
Element* contextElement = toElement(context);
// Avoid lazily creating attribute nodes for attributes that we do not
// need anyway.
if (nodeTest().kind() == NodeTest::NameTest && nodeTest().data() != starAtom) {
RefPtrWillBeRawPtr<Node> n = contextElement->getAttributeNodeNS(nodeTest().namespaceURI(), nodeTest().data());
// In XPath land, namespace nodes are not accessible on the attribute axis.
if (n && n->namespaceURI() != XMLNSNames::xmlnsNamespaceURI) {
// Still need to check merged predicates.
if (nodeMatches(evaluationContext, n.get(), AttributeAxis, nodeTest()))
nodes.append(n.release());
}
return;
}
AttributeCollection attributes = contextElement->attributes();
AttributeCollection::iterator end = attributes.end();
for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
RefPtrWillBeRawPtr<Attr> attr = contextElement->ensureAttr(it->name());
if (nodeMatches(evaluationContext, attr.get(), AttributeAxis, nodeTest()))
nodes.append(attr.release());
}
return;
}
case NamespaceAxis:
// XPath namespace nodes are not implemented.
return;
case SelfAxis:
if (nodeMatches(evaluationContext, context, SelfAxis, nodeTest()))
nodes.append(context);
return;
case DescendantOrSelfAxis:
if (nodeMatches(evaluationContext, context, DescendantOrSelfAxis, nodeTest()))
nodes.append(context);
// In XPath model, attribute nodes do not have children.
if (context->isAttributeNode())
return;
for (Node* n = context->firstChild(); n; n = NodeTraversal::next(*n, context)) {
if (nodeMatches(evaluationContext, n, DescendantOrSelfAxis, nodeTest()))
nodes.append(n);
}
return;
case AncestorOrSelfAxis: {
if (nodeMatches(evaluationContext, context, AncestorOrSelfAxis, nodeTest()))
nodes.append(context);
Node* n = context;
if (context->isAttributeNode()) {
n = toAttr(context)->ownerElement();
if (nodeMatches(evaluationContext, n, AncestorOrSelfAxis, nodeTest()))
nodes.append(n);
}
for (n = n->parentNode(); n; n = n->parentNode()) {
if (nodeMatches(evaluationContext, n, AncestorOrSelfAxis, nodeTest()))
nodes.append(n);
}
nodes.markSorted(false);
return;
}
}
ASSERT_NOT_REACHED();
}
