From 933e74473a23c0090eaaae9c6122a0e0d192df15 Mon Sep 17 00:00:00 2001
From: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Date: Tue, 22 Sep 2009 16:24:07 -0300
Subject: QGraphicsAnchorLayout: add autotests for QSizePolicy::ExpandFlag

Add autotests that use the ExpandFlag via QSizePolicy::Expanding
policy. Those tests cover the simple cases and behaviours with
sequential and parallel anchor setups.

Signed-off-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Reviewed-by: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
---
 .../tst_qgraphicsanchorlayout.cpp                  | 214 +++++++++++++++++++++
 1 file changed, 214 insertions(+)

diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index 9f13aca..e898edb 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -69,6 +69,9 @@ private slots:
     void delete_anchor();
     void conflicts();
     void sizePolicy();
+    void expandingSequence();
+    void expandingSequenceFairDistribution();
+    void expandingParallel();
 };
 
 class RectWidget : public QGraphicsWidget
@@ -586,6 +589,20 @@ void tst_QGraphicsAnchorLayout::snake()
     QCOMPARE(b->geometry(), QRectF(90.0, 100.0, 10.0, 100.0));
     QCOMPARE(c->geometry(), QRectF(90.0, 200.0, 100.0, 100.0));
     QCOMPARE(p.size(), layoutMaximumSize);
+
+    QVERIFY(layoutHasConflict(l) == false);
+
+    // Test QSizePolicy::ExpandFlag, it shouldn't change the extreme
+    // points of the layout...
+    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+
+    QSizeF newLayoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QSizeF newLayoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QSizeF newLayoutPreferredSize = l->effectiveSizeHint(Qt::PreferredSize);
+
+    QCOMPARE(layoutMinimumSize, newLayoutMinimumSize);
+    QCOMPARE(layoutMaximumSize, newLayoutMaximumSize);
+    QCOMPARE(layoutPreferredSize, newLayoutPreferredSize);
 }
 
 void tst_QGraphicsAnchorLayout::snakeOppositeDirections()
@@ -1308,5 +1325,202 @@ void tst_QGraphicsAnchorLayout::conflicts()
     delete p;
 }
 
+void tst_QGraphicsAnchorLayout::expandingSequence()
+{
+    QSizeF min(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF max(100, 10);
+
+    QGraphicsWidget *a = createItem(min, pref, max, "a");
+    QGraphicsWidget *b = createItem(min, pref, max, "b");
+
+    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+
+    // vertical
+    l->addAnchors(l, a, Qt::Vertical);
+    l->addAnchors(l, b, Qt::Vertical);
+
+    QCOMPARE(l->count(), 2);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize.width(), qreal(20));
+
+    QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
+    p.resize(layoutExpandedSize);
+
+    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
+    QCOMPARE(a->geometry().size(), pref);
+    QCOMPARE(b->geometry().size(), max);
+
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize.width(), qreal(200));
+}
+
+void tst_QGraphicsAnchorLayout::expandingSequenceFairDistribution()
+{
+    QSizeF min(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF max(100, 10);
+
+    QGraphicsWidget *a = createItem(min, pref, max, "a");
+    QGraphicsWidget *b = createItem(min, pref, max, "b");
+    QGraphicsWidget *c = createItem(min, pref, max, "c");
+    QGraphicsWidget *d = createItem(min, pref, max, "d");
+
+    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+    d->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
+    setAnchor(l, c, Qt::AnchorRight, d, Qt::AnchorLeft, 0);
+    setAnchor(l, d, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+
+    // vertical
+    l->addAnchors(l, a, Qt::Vertical);
+    l->addAnchors(l, b, Qt::Vertical);
+    l->addAnchors(l, c, Qt::Vertical);
+    l->addAnchors(l, d, Qt::Vertical);
+
+    QCOMPARE(l->count(), 4);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize.width(), qreal(40));
+
+    QSizeF layoutPartialExpandedSize((2 * pref.width()) + (2 * (pref.width() + 10)),
+                                     layoutMinimumSize.height());
+    p.resize(layoutPartialExpandedSize);
+
+    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
+    QCOMPARE(a->geometry().size(), pref);
+    QCOMPARE(b->geometry().size(), pref + QSizeF(10, 0));
+    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(d->geometry().size(), pref + QSizeF(10, 0));
+
+    QSizeF layoutExpandedSize((2 * pref.width()) + (2 * max.width()),
+                              layoutMinimumSize.height());
+    p.resize(layoutExpandedSize);
+
+    QCOMPARE(a->geometry().size(), pref);
+    QCOMPARE(b->geometry().size(), max);
+    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(d->geometry().size(), max);
+
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize.width(), qreal(400));
+
+    // Now we change D to have more "room for growth" from its preferred size
+    // to its maximum size. We expect a proportional fair distribution. Note that
+    // this seems to not conform with what QGraphicsLinearLayout does.
+    d->setMaximumSize(QSizeF(150, 10));
+
+    QSizeF newLayoutExpandedSize((2 * pref.width()) + (max.width() + 150),
+                              layoutMinimumSize.height());
+    p.resize(newLayoutExpandedSize);
+
+    QCOMPARE(a->geometry().size(), pref);
+    QCOMPARE(b->geometry().size(), max);
+    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(d->geometry().size(), QSizeF(150, 10));
+
+    QSizeF newLayoutPartialExpandedSize((4 * pref.width()) + 75,
+                                        layoutMinimumSize.height());
+
+    QCOMPARE(a->geometry().size(), pref);
+    QCOMPARE(b->geometry().size(), pref + QSizeF(25, 0));
+    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(d->geometry().size(), pref + QSizeF(50, 0));
+}
+
+void tst_QGraphicsAnchorLayout::expandingParallel()
+{
+    QSizeF min(10, 10);
+    QSizeF pref(50, 10);
+    QSizeF max(100, 50);
+
+    QGraphicsWidget *a = createItem(min, pref, max, "a");
+    QGraphicsWidget *b = createItem(min, pref, max, "b");
+    QGraphicsWidget *c = createItem(min, pref, max, "c");
+
+    b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+
+    QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    // horizontal
+    setAnchor(l, l, Qt::AnchorLeft, a, Qt::AnchorLeft, 0);
+    setAnchor(l, l, Qt::AnchorLeft, b, Qt::AnchorLeft, 0);
+
+    setAnchor(l, a, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
+    setAnchor(l, b, Qt::AnchorRight, c, Qt::AnchorLeft, 0);
+
+    setAnchor(l, c, Qt::AnchorRight, l, Qt::AnchorRight, 0);
+
+    // vertical
+    l->addAnchors(l, c, Qt::Vertical);
+    setAnchor(l, l, Qt::AnchorTop, a, Qt::AnchorTop, 0);
+    setAnchor(l, a, Qt::AnchorBottom, c, Qt::AnchorVerticalCenter, 0);
+    setAnchor(l, b, Qt::AnchorTop, c, Qt::AnchorVerticalCenter, 0);
+    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom, 0);
+
+    QCOMPARE(l->count(), 3);
+
+    QGraphicsWidget p;
+    p.setLayout(l);
+
+    QSizeF layoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(layoutMinimumSize.width(), qreal(20));
+
+    QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
+    p.resize(layoutExpandedSize);
+
+    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
+    QCOMPARE(a->geometry().size(), max);
+    QCOMPARE(b->geometry().size(), max);
+    QCOMPARE(c->geometry().size(), pref);
+
+    QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(layoutMaximumSize.width(), qreal(200));
+
+    //
+    // Change the parallel connection to a paralell connection of b with a center...
+    //
+    QGraphicsAnchor *anchor = l->anchor(b, Qt::AnchorRight, c, Qt::AnchorLeft);
+    delete anchor;
+    setAnchor(l, b, Qt::AnchorRight, a, Qt::AnchorHorizontalCenter, 0);
+    a->setMaximumSize(max + QSizeF(100, 0));
+
+    QSizeF newLayoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
+    QCOMPARE(newLayoutMinimumSize.width(), qreal(30));
+
+    QSizeF newLayoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
+    p.resize(newLayoutExpandedSize);
+
+    QCOMPARE(a->geometry().size(), max);
+    QCOMPARE(b->geometry().size(), max);
+    QCOMPARE(c->geometry().size(), pref);
+
+    QSizeF newLayoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
+    QCOMPARE(newLayoutMaximumSize.width(), qreal(300));
+}
+
 QTEST_MAIN(tst_QGraphicsAnchorLayout)
 #include "tst_qgraphicsanchorlayout.moc"
-- 
cgit v0.12


From bfc1a75616e1c96a018349084fae844d7efbc177 Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Tue, 22 Sep 2009 14:20:10 -0300
Subject: QGraphicsAnchorLayout: Add data structures for Expanding size policy

Adding required members for the upcoming support of the
QSizePolicy::Expand flag.

In this state, running with simplification will probably not work.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Artur Duque de Souza <artur.souza@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 44 +++++++++++++++++++-----
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   | 20 ++++++++---
 2 files changed, 51 insertions(+), 13 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index f75118b..fc3bc8a 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -94,7 +94,9 @@ qreal QGraphicsAnchorPrivate::spacing() const
 
 void AnchorData::refreshSizeHints(qreal effectiveSpacing)
 {
-    if (!isLayoutAnchor && from->m_item == to->m_item) {
+    isExpanding = 0;
+
+    if (!isLayoutAnchor && (from->m_item == to->m_item)) {
         QGraphicsLayoutItem *item = from->m_item;
 
         const QGraphicsAnchorLayoutPrivate::Orientation orient = QGraphicsAnchorLayoutPrivate::edgeOrientation(from->m_edge);
@@ -138,6 +140,9 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
         if (policy & QSizePolicy::IgnoreFlag)
             prefSize = minSize;
 
+        if (policy & QSizePolicy::ExpandFlag)
+            isExpanding = 1;
+
         bool hasCenter = (from->m_edge == centerEdge || to->m_edge == centerEdge);
 
         if (hasCenter) {
@@ -155,6 +160,7 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
         // recalculate and override the values we set here.
         sizeAtMinimum = prefSize;
         sizeAtPreferred = prefSize;
+        sizeAtExpanding = prefSize;
         sizeAtMaximum = prefSize;
 
     } else if (!hasSize) {
@@ -165,6 +171,7 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
 
         sizeAtMinimum = prefSize;
         sizeAtPreferred = prefSize;
+        sizeAtExpanding = prefSize;
         sizeAtMaximum = prefSize;
     }
 }
@@ -357,6 +364,12 @@ QGraphicsAnchorLayoutPrivate::QGraphicsAnchorLayoutPrivate()
     : calculateGraphCacheDirty(1)
 {
     for (int i = 0; i < NOrientations; ++i) {
+        for (int j = 0; j < 3; ++j) {
+            sizeHints[i][j] = -1;
+        }
+        sizeAtExpanding[i] = -1;
+        interpolationProgress[i] = -1;
+
         spacings[i] = -1;
         graphSimplified[i] = false;
         graphHasConflicts[i] = false;
@@ -1649,6 +1662,10 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
             sizeHints[orientation][Qt::PreferredSize] = pref;
             sizeHints[orientation][Qt::MaximumSize] = max;
 
+            // XXX implement Expanding simplex
+            for (int i = 0; i < trunkVariables.count(); ++i)
+                trunkVariables.at(i)->sizeAtExpanding = trunkVariables.at(i)->sizeAtPreferred;
+            sizeAtExpanding[orientation] = pref;
         }
     } else {
 #if 0
@@ -1664,6 +1681,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         AnchorData *ad = trunkPath.positives.toList()[0];
         ad->sizeAtMinimum = ad->minSize;
         ad->sizeAtPreferred = ad->prefSize;
+        ad->sizeAtExpanding = ad->prefSize;
         ad->sizeAtMaximum = ad->maxSize;
 
         // Propagate
@@ -1672,6 +1690,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         sizeHints[orientation][Qt::MinimumSize] = ad->sizeAtMinimum;
         sizeHints[orientation][Qt::PreferredSize] = ad->sizeAtPreferred;
         sizeHints[orientation][Qt::MaximumSize] = ad->sizeAtMaximum;
+        sizeAtExpanding[orientation] = ad->sizeAtPreferred;
     }
 
     // Delete the constraints, we won't use them anymore.
@@ -1701,6 +1720,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
                 AnchorData *ad = partVariables[j];
                 Q_ASSERT(ad);
                 ad->sizeAtMinimum = ad->sizeAtPreferred;
+                ad->sizeAtExpanding = ad->sizeAtPreferred;
                 ad->sizeAtMaximum = ad->sizeAtPreferred;
                 ad->updateChildrenSizes();
             }
@@ -2058,9 +2078,13 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation(
         interpolationInterval[orientation] = MinToPreferred;
         lower = sizeHints[orientation][Qt::MinimumSize];
         upper = sizeHints[orientation][Qt::PreferredSize];
-    } else {
-        interpolationInterval[orientation] = PreferredToMax;
+    } else if (current < sizeAtExpanding[orientation]) {
+        interpolationInterval[orientation] = PreferredToExpanding;
         lower = sizeHints[orientation][Qt::PreferredSize];
+        upper = sizeAtExpanding[orientation];
+    } else {
+        interpolationInterval[orientation] = ExpandingToMax;
+        lower = sizeAtExpanding[orientation];
         upper = sizeHints[orientation][Qt::MaximumSize];
     }
 
@@ -2075,11 +2099,12 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation(
   \internal
 
   Calculate the current Edge size based on the current Layout size and the
-  size the edge is supposed to have when:
+  size the edge is supposed to have when the layout is at its:
 
-   - the layout is at its minimum size.
-   - the layout is at its preferred size.
-   - the layout is at its maximum size.
+   - minimum size,
+   - preferred size,
+   - size when all expanding anchors are expanded,
+   - maximum size.
 
    These three key values are calculated in advance using linear
    programming (more expensive) or the simplification algorithm, then
@@ -2099,8 +2124,11 @@ void QGraphicsAnchorLayoutPrivate::interpolateEdge(AnchorVertex *base,
     if (interpolationInterval[orientation] == MinToPreferred) {
         lower = edge->sizeAtMinimum;
         upper = edge->sizeAtPreferred;
-    } else {
+    } else if (interpolationInterval[orientation] == PreferredToExpanding) {
         lower = edge->sizeAtPreferred;
+        upper = edge->sizeAtExpanding;
+    } else {
+        lower = edge->sizeAtExpanding;
         upper = edge->sizeAtMaximum;
     }
 
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index c86bfa3..4c6c2aa 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -153,7 +153,8 @@ struct AnchorData : public QSimplexVariable {
         : QSimplexVariable(), from(0), to(0),
           minSize(minimumSize), prefSize(preferredSize),
           maxSize(maximumSize), sizeAtMinimum(preferredSize),
-          sizeAtPreferred(preferredSize), sizeAtMaximum(preferredSize),
+          sizeAtPreferred(preferredSize), sizeAtExpanding(preferredSize),
+          sizeAtMaximum(preferredSize),
           graphicsAnchor(0),
           skipInPreferred(0), type(Normal), hasSize(true),
           isLayoutAnchor(false) {}
@@ -161,7 +162,8 @@ struct AnchorData : public QSimplexVariable {
     AnchorData(qreal size)
         : QSimplexVariable(), from(0), to(0),
           minSize(size), prefSize(size), maxSize(size),
-          sizeAtMinimum(size), sizeAtPreferred(size), sizeAtMaximum(size),
+          sizeAtMinimum(size), sizeAtPreferred(size), sizeAtExpanding(size),
+          sizeAtMaximum(size),
           graphicsAnchor(0),
           skipInPreferred(0), type(Normal), hasSize(true),
           isLayoutAnchor(false) {}
@@ -169,7 +171,8 @@ struct AnchorData : public QSimplexVariable {
     AnchorData()
         : QSimplexVariable(), from(0), to(0),
           minSize(0), prefSize(0), maxSize(0),
-          sizeAtMinimum(0), sizeAtPreferred(0), sizeAtMaximum(0),
+          sizeAtMinimum(0), sizeAtPreferred(0), sizeAtExpanding(0),
+          sizeAtMaximum(0),
           graphicsAnchor(0),
           skipInPreferred(0), type(Normal), hasSize(false),
           isLayoutAnchor(false) {}
@@ -192,6 +195,7 @@ struct AnchorData : public QSimplexVariable {
         maxSize = size;
         sizeAtMinimum = size;
         sizeAtPreferred = size;
+        sizeAtExpanding = size;
         sizeAtMaximum = size;
         hasSize = true;
     }
@@ -218,6 +222,7 @@ struct AnchorData : public QSimplexVariable {
     // calculated by the Simplex solver based on the current layout setup.
     qreal sizeAtMinimum;
     qreal sizeAtPreferred;
+    qreal sizeAtExpanding;
     qreal sizeAtMaximum;
     QGraphicsAnchor *graphicsAnchor;
 
@@ -225,12 +230,15 @@ struct AnchorData : public QSimplexVariable {
     uint type : 2;            // either Normal, Sequential or Parallel
     uint hasSize : 1;         // if false, get size from style.
     uint isLayoutAnchor : 1;  // if this anchor is connected to a layout 'edge'
+    uint isExpanding : 1;     // if true, expands before other anchors
+
 protected:
     AnchorData(Type type, qreal size = 0)
         : QSimplexVariable(), from(0), to(0),
           minSize(size), prefSize(size),
           maxSize(size), sizeAtMinimum(size),
-          sizeAtPreferred(size), sizeAtMaximum(size),
+          sizeAtPreferred(size), sizeAtExpanding(size),
+          sizeAtMaximum(size),
           graphicsAnchor(0),
           skipInPreferred(0), type(type), hasSize(true),
           isLayoutAnchor(false) {}
@@ -355,7 +363,8 @@ public:
     // Interval represents which interpolation interval are we operating in.
     enum Interval {
         MinToPreferred = 0,
-        PreferredToMax
+        PreferredToExpanding,
+        ExpandingToMax
     };
 
     // Several structures internal to the layout are duplicated to handle
@@ -496,6 +505,7 @@ public:
     qreal spacings[NOrientations];
     // Size hints from simplex engine
     qreal sizeHints[2][3];
+    qreal sizeAtExpanding[2];
 
     // Items
     QVector<QGraphicsLayoutItem *> items;
-- 
cgit v0.12


From 1728f846d9fb53a699782005d6478c0f23f9b82e Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Wed, 23 Sep 2009 16:02:35 -0300
Subject: QGraphicsAnchorLayout: Enabling Simplex support for Expanding size
 policy

To support the expanding size policy we had to change the way the setup
process work. Previously we used to calculate three key-frames using
the simplex solver:

 - sizeAtMinimum: the value an anchor should be in when the layout is
                  at its minimum size. Calculated using simplex solver
	          to minimize the layout size.
 - sizeAtPreferred: the value an anchor should be in when the layout is
                    at its preferred size. Calculated using simplex solver
	            to minimize the deviation from the items preferred
	            sizes.
 - sizeAtMaximum: the value an anchor should be in when the layout is
	          at its maximum size. Calculated using simplex solver
                  to maximize the layout size.

That worked fine but didn't diferentiate standard items from the
"expanding" ones. In other words, all items would grow from their
sizeAtPreferred to their sizeAtMaximum at the same rate.

To support the idea of "expanding" items, ie. items that should grow
faster than the others, we added a fourth state, between preferred
and maximum.

Now we have the following interpolation order:

 sizeAtMinimum -> sizeAtPreferred -> sizeAtExpanding -> sizeAtMaximum.

The definition of the "expanding" state is that all "expanding" items
should have grown all the way to their "sizeAtMaximum" values whereas
non expanding items should have kept their preferred sizes. The only
exception is that non-expanding items are allowed to grow if that is
necessary to allow the "expanding" items to reach their sizeAtMaximum.

So, the visual result is that if the layout is resized from its
preferred size to its maximum size, the expanding items will grow
first and then, in a second phase, the other items will grow.

This commit adds QGALPrivate::solveExpanding() and calls it from
calculateGraphs().

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Artur Duque de Souza <artur.souza@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 98 +++++++++++++++++++++---
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   |  1 +
 2 files changed, 88 insertions(+), 11 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index fc3bc8a..93ccf83 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -1635,11 +1635,18 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         qreal min, max;
         feasible = solveMinMax(trunkConstraints, trunkPath, &min, &max);
 
-        // Solve for preferred. The objective function is calculated from the constraints
-        // and variables internally.
-        feasible &= solvePreferred(trunkConstraints);
-
         if (feasible) {
+            // Solve for preferred. The objective function is calculated from the constraints
+            // and variables internally.
+            solvePreferred(trunkConstraints);
+
+            // remove sizeHintConstraints from trunkConstraints
+            trunkConstraints = parts[0];
+
+            // Solve for expanding. The objective function and the constraints from items
+            // are calculated internally.
+            solveExpanding(trunkConstraints);
+
             // Propagate the new sizes down the simplified graph, ie. tell the
             // group anchors to set their children anchors sizes.
 
@@ -1649,23 +1656,23 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
             for (int i = 0; i < trunkVariables.count(); ++i)
                 trunkVariables.at(i)->updateChildrenSizes();
 
-            // Calculate and set the preferred size for the layout from the edge sizes that
-            // were calculated above.
+            // Calculate and set the preferred and expanding sizes for the layout,
+            // from the edge sizes that were calculated above.
             qreal pref(0.0);
+            qreal expanding(0.0);
             foreach (const AnchorData *ad, trunkPath.positives) {
                 pref += ad->sizeAtPreferred;
+                expanding += ad->sizeAtExpanding;
             }
             foreach (const AnchorData *ad, trunkPath.negatives) {
                 pref -= ad->sizeAtPreferred;
+                expanding -= ad->sizeAtExpanding;
             }
+
             sizeHints[orientation][Qt::MinimumSize] = min;
             sizeHints[orientation][Qt::PreferredSize] = pref;
             sizeHints[orientation][Qt::MaximumSize] = max;
-
-            // XXX implement Expanding simplex
-            for (int i = 0; i < trunkVariables.count(); ++i)
-                trunkVariables.at(i)->sizeAtExpanding = trunkVariables.at(i)->sizeAtPreferred;
-            sizeAtExpanding[orientation] = pref;
+            sizeAtExpanding[orientation] = expanding;
         }
     } else {
 #if 0
@@ -2315,6 +2322,75 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(QList<QSimplexConstraint *> co
     return feasible;
 }
 
+void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> constraints)
+{
+    QList<AnchorData *> variables = getVariables(constraints);
+    QList<QSimplexConstraint *> itemConstraints;
+    QSimplexConstraint *objective = new QSimplexConstraint;
+
+    // Use all items that belong to trunk to:
+    //  - add solveExpanding-specific item constraints
+    //  - create the objective function
+    for (int i = 0; i < variables.size(); ++i) {
+        AnchorData *ad = variables[i];
+        if (ad->isExpanding) {
+            // Add constraint to lock expanding anchor in its sizeAtMaximum
+            QSimplexConstraint *itemC = new QSimplexConstraint;
+            itemC->ratio = QSimplexConstraint::Equal;
+            itemC->variables.insert(ad, 1.0);
+            itemC->constant = ad->sizeAtMaximum;
+            itemConstraints << itemC;
+        } else {
+            // Add constraints to lock anchor between their sizeAtPreferred and sizeAtMaximum
+            QSimplexConstraint *itemC = new QSimplexConstraint;
+            itemC->ratio = QSimplexConstraint::MoreOrEqual;
+            itemC->variables.insert(ad, 1.0);
+            itemC->constant = qMin(ad->sizeAtPreferred, ad->sizeAtMaximum);
+            itemConstraints << itemC;
+
+            itemC = new QSimplexConstraint;
+            itemC->ratio = QSimplexConstraint::LessOrEqual;
+            itemC->variables.insert(ad, 1.0);
+            itemC->constant = qMax(ad->sizeAtPreferred, ad->sizeAtMaximum);
+            itemConstraints << itemC;
+
+            // Add anchor to objective function
+            if (ad->sizeAtPreferred < ad->sizeAtMaximum) {
+                // Try to shrink this variable towards its sizeAtPreferred value
+                objective->variables.insert(ad, 1.0);
+            } else {
+                // Try to grow this variable towards its sizeAtPreferred value
+                objective->variables.insert(ad, -1.0);
+            }
+        }
+    }
+
+    // Solve
+    if (objective->variables.size() == variables.size()) {
+        // If no anchors are expanding, we don't need to run the simplex
+        // Set all variables to their preferred size
+        for (int i = 0; i < variables.size(); ++i) {
+            variables[i]->sizeAtExpanding = variables[i]->sizeAtPreferred;
+        }
+    } else {
+        // Run simplex
+        QSimplex simplex;
+        bool feasible = simplex.setConstraints(constraints + itemConstraints);
+        Q_ASSERT(feasible);
+
+        simplex.setObjective(objective);
+        simplex.solveMin();
+
+        // Collect results
+        for (int i = 0; i < variables.size(); ++i) {
+            variables[i]->sizeAtExpanding = variables[i]->result;
+        }
+    }
+
+    delete objective;
+    qDeleteAll(itemConstraints);
+}
+
 /*!
     \internal
     Returns true if there are no arrangement that satisfies all constraints.
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 4c6c2aa..47df786 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -495,6 +495,7 @@ public:
     bool solveMinMax(QList<QSimplexConstraint *> constraints,
                      GraphPath path, qreal *min, qreal *max);
     bool solvePreferred(QList<QSimplexConstraint *> constraints);
+    void solveExpanding(QList<QSimplexConstraint *> constraints);
     bool hasConflicts() const;
 
 #ifdef QT_DEBUG
-- 
cgit v0.12


From e210bea72ef65f99babb4c6f5bd442184c671d3b Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Thu, 24 Sep 2009 11:16:16 -0300
Subject: QGraphicsAnchorLayout Tests: Enable expanding tests

Removing QEXPECT_FAIL and making minor corrections on expected
values.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Artur Duque de Souza <artur.souza@openbossa.org>
---
 .../qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index e898edb..4ad48c7 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -1359,7 +1359,6 @@ void tst_QGraphicsAnchorLayout::expandingSequence()
     QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
     p.resize(layoutExpandedSize);
 
-    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
     QCOMPARE(a->geometry().size(), pref);
     QCOMPARE(b->geometry().size(), max);
 
@@ -1409,7 +1408,6 @@ void tst_QGraphicsAnchorLayout::expandingSequenceFairDistribution()
                                      layoutMinimumSize.height());
     p.resize(layoutPartialExpandedSize);
 
-    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
     QCOMPARE(a->geometry().size(), pref);
     QCOMPARE(b->geometry().size(), pref + QSizeF(10, 0));
     QCOMPARE(c->geometry().size(), pref);
@@ -1443,6 +1441,7 @@ void tst_QGraphicsAnchorLayout::expandingSequenceFairDistribution()
 
     QSizeF newLayoutPartialExpandedSize((4 * pref.width()) + 75,
                                         layoutMinimumSize.height());
+    p.resize(newLayoutPartialExpandedSize);
 
     QCOMPARE(a->geometry().size(), pref);
     QCOMPARE(b->geometry().size(), pref + QSizeF(25, 0));
@@ -1454,11 +1453,12 @@ void tst_QGraphicsAnchorLayout::expandingParallel()
 {
     QSizeF min(10, 10);
     QSizeF pref(50, 10);
-    QSizeF max(100, 50);
+    QSizeF max(100, 10);
+    QSizeF max2(100, 50);
 
     QGraphicsWidget *a = createItem(min, pref, max, "a");
     QGraphicsWidget *b = createItem(min, pref, max, "b");
-    QGraphicsWidget *c = createItem(min, pref, max, "c");
+    QGraphicsWidget *c = createItem(min, pref, max2, "c");
 
     b->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
 
@@ -1492,10 +1492,9 @@ void tst_QGraphicsAnchorLayout::expandingParallel()
     QSizeF layoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
     p.resize(layoutExpandedSize);
 
-    QEXPECT_FAIL("", "Support for QSizePolicy::ExpandFlag not yet available", Abort);
     QCOMPARE(a->geometry().size(), max);
     QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(c->geometry().size(), QSizeF(pref.width(), 20));
 
     QSizeF layoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
     QCOMPARE(layoutMaximumSize.width(), qreal(200));
@@ -1511,12 +1510,12 @@ void tst_QGraphicsAnchorLayout::expandingParallel()
     QSizeF newLayoutMinimumSize = l->effectiveSizeHint(Qt::MinimumSize);
     QCOMPARE(newLayoutMinimumSize.width(), qreal(30));
 
-    QSizeF newLayoutExpandedSize(pref.width() + max.width(), layoutMinimumSize.height());
+    QSizeF newLayoutExpandedSize = layoutExpandedSize + QSizeF(100, 0);
     p.resize(newLayoutExpandedSize);
 
-    QCOMPARE(a->geometry().size(), max);
+    QCOMPARE(a->geometry().size(), max + QSizeF(100, 0));
     QCOMPARE(b->geometry().size(), max);
-    QCOMPARE(c->geometry().size(), pref);
+    QCOMPARE(c->geometry().size(), QSizeF(pref.width(), 20));
 
     QSizeF newLayoutMaximumSize = l->effectiveSizeHint(Qt::MaximumSize);
     QCOMPARE(newLayoutMaximumSize.width(), qreal(300));
-- 
cgit v0.12


From 5dd77be3acfb53b44d7d6b0015af0c33124ab84a Mon Sep 17 00:00:00 2001
From: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Date: Thu, 24 Sep 2009 17:09:16 -0300
Subject: QGraphicsAnchorLayout: cleaning up AnchorData

Use just one constructor for AnchorData and tweak the struct when
necessary. Also use the function refreshSizeHints() for Normal anchors
to get the item information instead of passing to the constructor.

This has the advantage that we don't need to replicate the code for
checking and updating the size hint and size policies. Note that the
code before only considered the size policies after the first
refreshSizeHints() -- which we know will be called after the
simplification, so the assumption seems to be correct, but we don't
depend on that anymore..

Signed-off-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Reviewed-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 89 ++++++++++++------------
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   | 53 ++++----------
 2 files changed, 59 insertions(+), 83 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 93ccf83..dc8d211 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -94,8 +94,6 @@ qreal QGraphicsAnchorPrivate::spacing() const
 
 void AnchorData::refreshSizeHints(qreal effectiveSpacing)
 {
-    isExpanding = 0;
-
     if (!isLayoutAnchor && (from->m_item == to->m_item)) {
         QGraphicsLayoutItem *item = from->m_item;
 
@@ -140,9 +138,6 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
         if (policy & QSizePolicy::IgnoreFlag)
             prefSize = minSize;
 
-        if (policy & QSizePolicy::ExpandFlag)
-            isExpanding = 1;
-
         bool hasCenter = (from->m_edge == centerEdge || to->m_edge == centerEdge);
 
         if (hasCenter) {
@@ -151,6 +146,14 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
             maxSize /= 2;
         }
 
+        if (policy & QSizePolicy::ExpandFlag) {
+            isExpanding = 1;
+            expSize = maxSize;
+        } else {
+            isExpanding = 0;
+            expSize = prefSize;
+        }
+
         // Set the anchor effective sizes to preferred.
         //
         // Note: The idea here is that all items should remain at their
@@ -167,8 +170,11 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
         // Anchor has no size defined, use given default information
         minSize = effectiveSpacing;
         prefSize = effectiveSpacing;
+        expSize = effectiveSpacing;
         maxSize = effectiveSpacing;
 
+        isExpanding = 0;
+
         sizeAtMinimum = prefSize;
         sizeAtPreferred = prefSize;
         sizeAtExpanding = prefSize;
@@ -830,9 +836,10 @@ void QGraphicsAnchorLayoutPrivate::createLayoutEdges()
     QGraphicsLayoutItem *layout = q;
 
     // Horizontal
-    AnchorData *data = new AnchorData(0, 0, QWIDGETSIZE_MAX);
+    AnchorData *data = new AnchorData;
     addAnchor_helper(layout, Qt::AnchorLeft, layout,
-              Qt::AnchorRight, data);
+                     Qt::AnchorRight, data);
+    data->maxSize = QWIDGETSIZE_MAX;
     data->skipInPreferred = 1;
 
     // Set the Layout Left edge as the root of the horizontal graph.
@@ -840,9 +847,10 @@ void QGraphicsAnchorLayoutPrivate::createLayoutEdges()
     graph[Horizontal].setRootVertex(v);
 
     // Vertical
-    data = new AnchorData(0, 0, QWIDGETSIZE_MAX);
+    data = new AnchorData;
     addAnchor_helper(layout, Qt::AnchorTop, layout,
-              Qt::AnchorBottom, data);
+                     Qt::AnchorBottom, data);
+    data->maxSize = QWIDGETSIZE_MAX;
     data->skipInPreferred = 1;
 
     // Set the Layout Top edge as the root of the vertical graph.
@@ -869,19 +877,15 @@ void QGraphicsAnchorLayoutPrivate::createItemEdges(QGraphicsLayoutItem *item)
 
     items.append(item);
 
-    QSizeF minSize = item->effectiveSizeHint(Qt::MinimumSize);
-    QSizeF prefSize = item->effectiveSizeHint(Qt::PreferredSize);
-    QSizeF maxSize = item->effectiveSizeHint(Qt::MaximumSize);
-
-    // Horizontal
-    AnchorData *data = new AnchorData(minSize.width(), prefSize.width(), maxSize.width());
-    addAnchor_helper(item, Qt::AnchorLeft, item,
-              Qt::AnchorRight, data);
+    // Create horizontal and vertical internal anchors for the item and
+    // refresh its size hint / policy values.
+    AnchorData *data = new AnchorData;
+    addAnchor_helper(item, Qt::AnchorLeft, item, Qt::AnchorRight, data);
+    data->refreshSizeHints(0); // 0 = effectiveSpacing, will not be used
 
-    // Vertical
-    data = new AnchorData(minSize.height(), prefSize.height(), maxSize.height());
-    addAnchor_helper(item, Qt::AnchorTop, item,
-              Qt::AnchorBottom, data);
+    data = new AnchorData;
+    addAnchor_helper(item, Qt::AnchorTop, item, Qt::AnchorBottom, data);
+    data->refreshSizeHints(0); // 0 = effectiveSpacing, will not be used
 }
 
 /*!
@@ -934,20 +938,17 @@ void QGraphicsAnchorLayoutPrivate::createCenterAnchors(
     Q_ASSERT(first && last);
 
     // Create new anchors
-    AnchorData *oldData = graph[orientation].edgeData(first, last);
-
-    qreal minimumSize = oldData->minSize / 2;
-    qreal preferredSize = oldData->prefSize / 2;
-    qreal maximumSize = oldData->maxSize / 2;
-
     QSimplexConstraint *c = new QSimplexConstraint;
-    AnchorData *data = new AnchorData(minimumSize, preferredSize, maximumSize);
+
+    AnchorData *data = new AnchorData;
     c->variables.insert(data, 1.0);
     addAnchor_helper(item, firstEdge, item, centerEdge, data);
+    data->refreshSizeHints(0);
 
-    data = new AnchorData(minimumSize, preferredSize, maximumSize);
+    data = new AnchorData;
     c->variables.insert(data, -1.0);
     addAnchor_helper(item, centerEdge, item, lastEdge, data);
+    data->refreshSizeHints(0);
 
     itemCenterConstraints[orientation].append(c);
 
@@ -1008,14 +1009,9 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors(
 
     if (substitute) {
         // Create the new anchor that should substitute the left-center-right anchors.
-        AnchorData *oldData = g.edgeData(first, center);
-
-        qreal minimumSize = oldData->minSize * 2;
-        qreal preferredSize = oldData->prefSize * 2;
-        qreal maximumSize = oldData->maxSize * 2;
-
-        AnchorData *data = new AnchorData(minimumSize, preferredSize, maximumSize);
+        AnchorData *data = new AnchorData;
         addAnchor_helper(item, firstEdge, item, lastEdge, data);
+        data->refreshSizeHints(0);
 
         // Remove old anchors
         removeAnchor_helper(first, center);
@@ -1133,7 +1129,7 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi
     // Use heuristics to find out what the user meant with this anchor.
     correctEdgeDirection(firstItem, firstEdge, secondItem, secondEdge);
 
-    AnchorData *data;
+    AnchorData *data = new AnchorData;
     if (!spacing) {
         // If firstItem or secondItem is the layout itself, the spacing will default to 0.
         // Otherwise, the following matrix is used (questionmark means that the spacing
@@ -1143,22 +1139,25 @@ QGraphicsAnchor *QGraphicsAnchorLayoutPrivate::addAnchor(QGraphicsLayoutItem *fi
         //  Left    0       0       ?
         //  HCenter 0       0       0
         //  Right   ?       0       0
-        if (firstItem != q
-            && secondItem != q
-            && pickEdge(firstEdge, Horizontal) != Qt::AnchorHorizontalCenter
-            && oppositeEdge(firstEdge) == secondEdge) {
-            data = new AnchorData;      // ask the style later
+        if (firstItem == q
+            || secondItem == q
+            || pickEdge(firstEdge, Horizontal) == Qt::AnchorHorizontalCenter
+            || oppositeEdge(firstEdge) != secondEdge) {
+            data->setFixedSize(0);
         } else {
-            data = new AnchorData(0);   // spacing should be 0
+            data->unsetSize();
         }
         addAnchor_helper(firstItem, firstEdge, secondItem, secondEdge, data);
+
     } else if (*spacing >= 0) {
-        data = new AnchorData(*spacing);
+        data->setFixedSize(*spacing);
         addAnchor_helper(firstItem, firstEdge, secondItem, secondEdge, data);
+
     } else {
-        data = new AnchorData(-*spacing);
+        data->setFixedSize(-*spacing);
         addAnchor_helper(secondItem, secondEdge, firstItem, firstEdge, data);
     }
+
     return acquireGraphicsAnchor(data);
 }
 
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 47df786..047be39 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -149,33 +149,15 @@ struct AnchorData : public QSimplexVariable {
         Sequential,
         Parallel
     };
-    AnchorData(qreal minimumSize, qreal preferredSize, qreal maximumSize)
-        : QSimplexVariable(), from(0), to(0),
-          minSize(minimumSize), prefSize(preferredSize),
-          maxSize(maximumSize), sizeAtMinimum(preferredSize),
-          sizeAtPreferred(preferredSize), sizeAtExpanding(preferredSize),
-          sizeAtMaximum(preferredSize),
-          graphicsAnchor(0),
-          skipInPreferred(0), type(Normal), hasSize(true),
-          isLayoutAnchor(false) {}
-
-    AnchorData(qreal size)
-        : QSimplexVariable(), from(0), to(0),
-          minSize(size), prefSize(size), maxSize(size),
-          sizeAtMinimum(size), sizeAtPreferred(size), sizeAtExpanding(size),
-          sizeAtMaximum(size),
-          graphicsAnchor(0),
-          skipInPreferred(0), type(Normal), hasSize(true),
-          isLayoutAnchor(false) {}
 
     AnchorData()
         : QSimplexVariable(), from(0), to(0),
-          minSize(0), prefSize(0), maxSize(0),
-          sizeAtMinimum(0), sizeAtPreferred(0), sizeAtExpanding(0),
-          sizeAtMaximum(0),
-          graphicsAnchor(0),
-          skipInPreferred(0), type(Normal), hasSize(false),
-          isLayoutAnchor(false) {}
+          minSize(0), prefSize(0), expSize(0), maxSize(0),
+          sizeAtMinimum(0), sizeAtPreferred(0),
+          sizeAtExpanding(0), sizeAtMaximum(0),
+          graphicsAnchor(0), skipInPreferred(0),
+          type(Normal), hasSize(true), isLayoutAnchor(false),
+          isExpanding(false) {}
 
     virtual void updateChildrenSizes() {}
     virtual void refreshSizeHints(qreal effectiveSpacing);
@@ -192,6 +174,7 @@ struct AnchorData : public QSimplexVariable {
     {
         minSize = size;
         prefSize = size;
+        expSize = size;
         maxSize = size;
         sizeAtMinimum = size;
         sizeAtPreferred = size;
@@ -215,6 +198,7 @@ struct AnchorData : public QSimplexVariable {
     // size.
     qreal minSize;
     qreal prefSize;
+    qreal expSize;
     qreal maxSize;
 
     // These attributes define which sizes should that anchor be in when the
@@ -231,17 +215,6 @@ struct AnchorData : public QSimplexVariable {
     uint hasSize : 1;         // if false, get size from style.
     uint isLayoutAnchor : 1;  // if this anchor is connected to a layout 'edge'
     uint isExpanding : 1;     // if true, expands before other anchors
-
-protected:
-    AnchorData(Type type, qreal size = 0)
-        : QSimplexVariable(), from(0), to(0),
-          minSize(size), prefSize(size),
-          maxSize(size), sizeAtMinimum(size),
-          sizeAtPreferred(size), sizeAtExpanding(size),
-          sizeAtMaximum(size),
-          graphicsAnchor(0),
-          skipInPreferred(0), type(type), hasSize(true),
-          isLayoutAnchor(false) {}
 };
 
 #ifdef QT_DEBUG
@@ -253,8 +226,10 @@ inline QString AnchorData::toString() const
 
 struct SequentialAnchorData : public AnchorData
 {
-    SequentialAnchorData() : AnchorData(AnchorData::Sequential)
+    SequentialAnchorData() : AnchorData()
     {
+        type = AnchorData::Sequential;
+        hasSize = true;
 #ifdef QT_DEBUG
         name = QLatin1String("SequentialAnchorData");
 #endif
@@ -278,9 +253,11 @@ struct SequentialAnchorData : public AnchorData
 struct ParallelAnchorData : public AnchorData
 {
     ParallelAnchorData(AnchorData *first, AnchorData *second)
-        : AnchorData(AnchorData::Parallel),
-        firstEdge(first), secondEdge(second)
+        : AnchorData(), firstEdge(first), secondEdge(second)
     {
+        type = AnchorData::Parallel;
+        hasSize = true;
+
         // ### Those asserts force that both child anchors have the same direction,
         // but can't we simplify a pair of anchors in opposite directions?
         Q_ASSERT(first->from == second->from);
-- 
cgit v0.12


From bcd08ab82b5df13f7687a504f868cb8b6ff8b75e Mon Sep 17 00:00:00 2001
From: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Date: Fri, 25 Sep 2009 16:13:18 -0300
Subject: QGraphicsAnchorLayout: avoid code duplication when initializing
 complex anchors

Now we can use refreshSizeHints_helper() to initialize complex
anchors (parallel and sequential). This avoids duplication of
code in the function simplifySequentialChunk().

This commit also 'disable' ExpandFlag temporarily, stabilizing the
tests for the simplification. The next commit should re-enable it
implementing the necessary code for simplification as well.

Signed-off-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Reviewed-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 102 +++++++++++------------
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   |   4 +
 2 files changed, 54 insertions(+), 52 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index dc8d211..dd46722 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -146,13 +146,15 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
             maxSize /= 2;
         }
 
-        if (policy & QSizePolicy::ExpandFlag) {
-            isExpanding = 1;
-            expSize = maxSize;
-        } else {
-            isExpanding = 0;
-            expSize = prefSize;
-        }
+        // ###
+        expSize = prefSize;
+        // if (policy & QSizePolicy::ExpandFlag) {
+        //     isExpanding = 1;
+        //     expSize = maxSize;
+        // } else {
+        //     isExpanding = 0;
+        //     expSize = prefSize;
+        // }
 
         // Set the anchor effective sizes to preferred.
         //
@@ -187,6 +189,7 @@ void ParallelAnchorData::updateChildrenSizes()
     firstEdge->sizeAtMinimum = secondEdge->sizeAtMinimum = sizeAtMinimum;
     firstEdge->sizeAtPreferred = secondEdge->sizeAtPreferred = sizeAtPreferred;
     firstEdge->sizeAtMaximum = secondEdge->sizeAtMaximum = sizeAtMaximum;
+    firstEdge->sizeAtExpanding = secondEdge->sizeAtExpanding = sizeAtPreferred;
 
     firstEdge->updateChildrenSizes();
     secondEdge->updateChildrenSizes();
@@ -194,9 +197,16 @@ void ParallelAnchorData::updateChildrenSizes()
 
 void ParallelAnchorData::refreshSizeHints(qreal effectiveSpacing)
 {
-    // First refresh children information
-    firstEdge->refreshSizeHints(effectiveSpacing);
-    secondEdge->refreshSizeHints(effectiveSpacing);
+    refreshSizeHints_helper(effectiveSpacing);
+}
+
+void ParallelAnchorData::refreshSizeHints_helper(qreal effectiveSpacing,
+                                                 bool refreshChildren)
+{
+    if (refreshChildren) {
+        firstEdge->refreshSizeHints(effectiveSpacing);
+        secondEdge->refreshSizeHints(effectiveSpacing);
+    }
 
     // ### should we warn if the parallel connection is invalid?
     // e.g. 1-2-3 with 10-20-30, the minimum of the latter is
@@ -208,9 +218,13 @@ void ParallelAnchorData::refreshSizeHints(qreal effectiveSpacing)
     prefSize = qMax(firstEdge->prefSize, secondEdge->prefSize);
     prefSize = qMin(prefSize, maxSize);
 
+    // ###
+    expSize = prefSize;
+
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
+    sizeAtExpanding = prefSize;
     sizeAtMaximum = prefSize;
 }
 
@@ -277,30 +291,46 @@ void SequentialAnchorData::updateChildrenSizes()
         bandSize = maxFactor > 0 ? e->maxSize - e->prefSize : e->prefSize - e->minSize;
         e->sizeAtMaximum = e->prefSize + bandSize * maxFactor;
 
+        // ###
+        e->sizeAtExpanding = e->sizeAtPreferred;
+
         e->updateChildrenSizes();
     }
 }
 
 void SequentialAnchorData::refreshSizeHints(qreal effectiveSpacing)
 {
+    refreshSizeHints_helper(effectiveSpacing);
+}
+
+void SequentialAnchorData::refreshSizeHints_helper(qreal effectiveSpacing,
+                                                   bool refreshChildren)
+{
     minSize = 0;
     prefSize = 0;
+    expSize = 0;
     maxSize = 0;
 
     for (int i = 0; i < m_edges.count(); ++i) {
         AnchorData *edge = m_edges.at(i);
 
-        // First refresh children information
-        edge->refreshSizeHints(effectiveSpacing);
+        // If it's the case refresh children information first
+        if (refreshChildren)
+            edge->refreshSizeHints(effectiveSpacing);
 
         minSize += edge->minSize;
         prefSize += edge->prefSize;
+        expSize += edge->expSize;
         maxSize += edge->maxSize;
     }
 
+    // ###
+    expSize = prefSize;
+
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
+    sizeAtExpanding = prefSize;
     sizeAtMaximum = prefSize;
 }
 
@@ -441,39 +471,21 @@ static bool simplifySequentialChunk(Graph<AnchorVertex, AnchorData> *graph,
     qDebug("simplifying [%s] to [%s - %s]", qPrintable(strPath), qPrintable(before->toString()), qPrintable(after->toString()));
 #endif
 
-    qreal min = 0;
-    qreal pref = 0;
-    qreal max = 0;
-
     SequentialAnchorData *sequence = new SequentialAnchorData;
     AnchorVertex *prev = before;
     AnchorData *data;
     for (i = 0; i <= vertices.count(); ++i) {
         AnchorVertex *next = (i < vertices.count()) ? vertices.at(i) : after;
         data = graph->takeEdge(prev, next);
-        min += data->minSize;
-        pref += data->prefSize;
-        max = checkAdd(max, data->maxSize);
         sequence->m_edges.append(data);
         prev = next;
     }
-
-    // insert new
-    sequence->minSize = min;
-    sequence->prefSize = pref;
-    sequence->maxSize = max;
-
-    // Unless these values are overhidden by the simplex solver later-on,
-    // anchors will keep their own preferred size.
-    sequence->sizeAtMinimum = pref;
-    sequence->sizeAtPreferred = pref;
-    sequence->sizeAtMaximum = pref;
-
     sequence->setVertices(vertices);
-
     sequence->from = before;
     sequence->to = after;
 
+    sequence->refreshSizeHints_helper(0, false);
+
     // data here is the last edge in the sequence
     // ### this seems to be here for supporting reverse order sequences,
     // but doesnt seem to be used right now
@@ -488,25 +500,11 @@ static bool simplifySequentialChunk(Graph<AnchorVertex, AnchorData> *graph,
 
     AnchorData *newAnchor = sequence;
     if (AnchorData *oldAnchor = graph->takeEdge(before, after)) {
-        newAnchor = new ParallelAnchorData(oldAnchor, sequence);
-
-        newAnchor->isLayoutAnchor = (oldAnchor->isLayoutAnchor
+        ParallelAnchorData *parallel = new ParallelAnchorData(oldAnchor, sequence);
+        parallel->isLayoutAnchor = (oldAnchor->isLayoutAnchor
                                      || sequence->isLayoutAnchor);
-
-        min = qMax(oldAnchor->minSize, sequence->minSize);
-        max = qMin(oldAnchor->maxSize, sequence->maxSize);
-
-        pref = qMax(oldAnchor->prefSize, sequence->prefSize);
-        pref = qMin(pref, max);
-
-        newAnchor->minSize = min;
-        newAnchor->prefSize = pref;
-        newAnchor->maxSize = max;
-
-        // Same as above, by default, keep preferred size.
-        newAnchor->sizeAtMinimum = pref;
-        newAnchor->sizeAtPreferred = pref;
-        newAnchor->sizeAtMaximum = pref;
+        parallel->refreshSizeHints_helper(0, false);
+        newAnchor = parallel;
     }
     graph->createEdge(before, after, newAnchor);
 
@@ -1687,7 +1685,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         AnchorData *ad = trunkPath.positives.toList()[0];
         ad->sizeAtMinimum = ad->minSize;
         ad->sizeAtPreferred = ad->prefSize;
-        ad->sizeAtExpanding = ad->prefSize;
+        ad->sizeAtExpanding = ad->expSize;
         ad->sizeAtMaximum = ad->maxSize;
 
         // Propagate
@@ -1696,7 +1694,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         sizeHints[orientation][Qt::MinimumSize] = ad->sizeAtMinimum;
         sizeHints[orientation][Qt::PreferredSize] = ad->sizeAtPreferred;
         sizeHints[orientation][Qt::MaximumSize] = ad->sizeAtMaximum;
-        sizeAtExpanding[orientation] = ad->sizeAtPreferred;
+        sizeAtExpanding[orientation] = ad->sizeAtExpanding;
     }
 
     // Delete the constraints, we won't use them anymore.
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 047be39..8f67b2c 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -238,6 +238,8 @@ struct SequentialAnchorData : public AnchorData
     virtual void updateChildrenSizes();
     virtual void refreshSizeHints(qreal effectiveSpacing);
 
+    void refreshSizeHints_helper(qreal effectiveSpacing, bool refreshChildren = true);
+
     void setVertices(const QVector<AnchorVertex*> &vertices)
     {
         m_children = vertices;
@@ -272,6 +274,8 @@ struct ParallelAnchorData : public AnchorData
     virtual void updateChildrenSizes();
     virtual void refreshSizeHints(qreal effectiveSpacing);
 
+    void refreshSizeHints_helper(qreal effectiveSpacing, bool refreshChildren = true);
+
     AnchorData* firstEdge;
     AnchorData* secondEdge;
 };
-- 
cgit v0.12


From ad69bb73754534f61658a83e85dadb75e603c90a Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Fri, 25 Sep 2009 19:02:21 -0300
Subject: QGraphicsAnchorLayout: Update solveExpanding to handle simplified
 graphs

The previous implementation of solveExpanding would assume that anchors
were either completely expanding (would grow to their sizeAtMaximum) or
non-expanding (would try to remain at their sizeAtPreferred).

What happens however is that with simplification enabled, we may have
anchors that are "partially" expanding. An example is a sequential
anchor that groups together two leaf anchors where only one of them
is expanding.

In this case, the expected size of that group anchor would be the sum
of the max size of the expanding child plus the preferred size of the
non-expanding child.

To handle the above case we added the "expSize" variable. It holds
the expected value at Expanding for each anchor. Based on this, and
the already calculated values of sizeAtMaximum and sizeAtPreferred,
the solver calculates the actual sizeAtExpanding for them.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 84 ++++++++++++++++++++----
 1 file changed, 72 insertions(+), 12 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index dd46722..cf1429c 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -2319,40 +2319,97 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(QList<QSimplexConstraint *> co
     return feasible;
 }
 
+/*! Calculate the "expanding" keyframe
+
+  This new keyframe sits between the already existing sizeAtPreferred and
+  sizeAtMaximum keyframes. Its goal is to modify the interpolation between
+  the latter as to respect the "expanding" size policy of some anchors.
+
+  Previously all items would be subject to a linear interpolation between
+  sizeAtPreferred and sizeAtMaximum values. This will change now, the
+  expanding anchors will change their size before the others. To calculate
+  this keyframe we use the following logic:
+
+  1) Ask each anchor for their desired expanding size (ad->expSize), this
+  value depends on the anchor expanding property in the following way:
+
+  - Expanding anchors want to grow towards their maximum size
+  - Non-expanding anchors want to remain at their preferred size.
+  - Composite anchors want to grow towards somewhere between their
+  preferred sizes. (*)
+
+  2) Clamp their desired values to the value they assume in the neighbour
+  keyframes (sizeAtPreferred and sizeAtExpanding)
+
+  3) Run simplex with a setup that ensures the following:
+
+    a. Anchors will change their value from their sizeAtPreferred towards
+       their sizeAtMaximum as much as required to ensure that ALL anchors
+       reach their respective "desired" expanding sizes.
+
+    b. No anchors will change their value beyond what is NEEDED to satisfy
+       the requirement above.
+
+  The final result is that, at the "expanding" keyframe expanding anchors
+  will grow and take with them all anchors that are parallel to them.
+  However, non-expanding anchors will remain at their preferred size unless
+  they are forced to grow by a parallel expanding anchor.
+
+  Note: For anchors where the sizeAtPreferred is bigger than sizeAtPreferred,
+        the visual effect when the layout grows from its preferred size is
+        the following: Expanding anchors will keep their size while non
+        expanding ones will shrink. Only after non-expanding anchors have
+        shrinked all the way, the expanding anchors will start to shrink too.
+*/
 void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> constraints)
 {
     QList<AnchorData *> variables = getVariables(constraints);
     QList<QSimplexConstraint *> itemConstraints;
     QSimplexConstraint *objective = new QSimplexConstraint;
+    bool hasExpanding = false;
 
-    // Use all items that belong to trunk to:
-    //  - add solveExpanding-specific item constraints
-    //  - create the objective function
+    // Construct the simplex constraints and objective
     for (int i = 0; i < variables.size(); ++i) {
+        // For each anchor
         AnchorData *ad = variables[i];
-        if (ad->isExpanding) {
-            // Add constraint to lock expanding anchor in its sizeAtMaximum
+
+        // Clamp the desired expanding size
+        qreal upperBoundary = qMax(ad->sizeAtPreferred, ad->sizeAtMaximum);
+        qreal lowerBoundary = qMin(ad->sizeAtPreferred, ad->sizeAtMaximum);
+        qreal boundedExpSize = qBound(lowerBoundary, ad->expSize, upperBoundary);
+
+        // Expanding anchors are those that want to move from their preferred size
+        if (boundedExpSize != ad->sizeAtPreferred)
+            hasExpanding = true;
+
+        // Lock anchor between boundedExpSize and sizeAtMaximum (ensure 3.a)
+        if (boundedExpSize == ad->sizeAtMaximum) {
+            // The interval has only one possible value, we can use an "Equal"
+            // constraint and don't need to add this variable to the objective.
             QSimplexConstraint *itemC = new QSimplexConstraint;
             itemC->ratio = QSimplexConstraint::Equal;
             itemC->variables.insert(ad, 1.0);
-            itemC->constant = ad->sizeAtMaximum;
+            itemC->constant = boundedExpSize;
             itemConstraints << itemC;
         } else {
-            // Add constraints to lock anchor between their sizeAtPreferred and sizeAtMaximum
+            // Add MoreOrEqual and LessOrEqual constraints.
             QSimplexConstraint *itemC = new QSimplexConstraint;
             itemC->ratio = QSimplexConstraint::MoreOrEqual;
             itemC->variables.insert(ad, 1.0);
-            itemC->constant = qMin(ad->sizeAtPreferred, ad->sizeAtMaximum);
+            itemC->constant = qMin(boundedExpSize, ad->sizeAtMaximum);
             itemConstraints << itemC;
 
             itemC = new QSimplexConstraint;
             itemC->ratio = QSimplexConstraint::LessOrEqual;
             itemC->variables.insert(ad, 1.0);
-            itemC->constant = qMax(ad->sizeAtPreferred, ad->sizeAtMaximum);
+            itemC->constant = qMax(boundedExpSize, ad->sizeAtMaximum);
             itemConstraints << itemC;
 
-            // Add anchor to objective function
-            if (ad->sizeAtPreferred < ad->sizeAtMaximum) {
+            // Create objective to avoid the anchos from moving away from
+            // the preferred size more than the needed amount. (ensure 3.b)
+            // The objective function is the distance between sizeAtPreferred
+            // and sizeAtExpanding, it will be minimized.
+            if (ad->sizeAtExpanding < ad->sizeAtMaximum) {
                 // Try to shrink this variable towards its sizeAtPreferred value
                 objective->variables.insert(ad, 1.0);
             } else {
@@ -2363,7 +2420,7 @@ void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> co
     }
 
     // Solve
-    if (objective->variables.size() == variables.size()) {
+    if (hasExpanding == false) {
         // If no anchors are expanding, we don't need to run the simplex
         // Set all variables to their preferred size
         for (int i = 0; i < variables.size(); ++i) {
@@ -2372,9 +2429,12 @@ void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> co
     } else {
         // Run simplex
         QSimplex simplex;
+
+        // Satisfy expanding (3.a)
         bool feasible = simplex.setConstraints(constraints + itemConstraints);
         Q_ASSERT(feasible);
 
+        // Reduce damage (3.b)
         simplex.setObjective(objective);
         simplex.solveMin();
 
-- 
cgit v0.12


From ba66cc0bde91e1143ac0a34f249f98e4573a5737 Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Mon, 28 Sep 2009 11:49:42 -0300
Subject: QSimplex: Remove overly conservative assertion

This assertion started failing after the addition of expanding
state. After some investigation we felt that the assertion itself
was too strong and would fail in some valid cases.

The new assertion is formally right as it tests whether the
simplex solver was able to satisfy the simplex constraints,
_exactly_ what it is expected to do.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 src/gui/graphicsview/qsimplex_p.cpp | 24 ++++++------------------
 src/gui/graphicsview/qsimplex_p.h   | 26 +++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp
index 00fc204..95003d2 100644
--- a/src/gui/graphicsview/qsimplex_p.cpp
+++ b/src/gui/graphicsview/qsimplex_p.cpp
@@ -285,24 +285,6 @@ bool QSimplex::setConstraints(const QList<QSimplexConstraint *> newConstraints)
     // anymore.
     clearColumns(firstArtificial, columns - 2);
 
-    #ifdef QT_DEBUG
-    // Ensure that at the end of the simplex each row should either:
-    //  - Have a positive value on the column associated to its variable, or
-    //  - Have zero values in all columns.
-    //
-    // This avoids a regression where restrictions would be lost
-    // due to randomness in the pivotRowForColumn method.
-    for (int i = 1; i < rows; ++i) {
-        int variableIndex = valueAt(i, 0);
-        if (valueAt(i, variableIndex) > 0)
-            continue;
-
-        for (int j = 1; j < columns; ++j) {
-            Q_ASSERT(valueAt(i, j) == 0);
-        }
-    }
-    #endif
-
     return true;
 }
 
@@ -537,6 +519,12 @@ qreal QSimplex::solver(solverFactor factor)
     solveMaxHelper();
     collectResults();
 
+    #ifdef QT_DEBUG
+    for (int i = 0; i < constraints.size(); ++i) {
+        Q_ASSERT(constraints[i]->isSatisfied());
+    }
+    #endif
+
     return factor * valueAt(0, columns - 1);
 }
 
diff --git a/src/gui/graphicsview/qsimplex_p.h b/src/gui/graphicsview/qsimplex_p.h
index 54b080d..b517cb9 100644
--- a/src/gui/graphicsview/qsimplex_p.h
+++ b/src/gui/graphicsview/qsimplex_p.h
@@ -94,8 +94,32 @@ struct QSimplexConstraint
 
     QPair<QSimplexVariable *, qreal> helper;
     QSimplexVariable * artificial;
-};
 
+    #ifdef QT_DEBUG
+    bool isSatisfied() {
+        qreal leftHandSide(0);
+
+        QHash<QSimplexVariable *, qreal>::const_iterator iter;
+        for (iter = variables.constBegin(); iter != variables.constEnd(); ++iter) {
+            leftHandSide += iter.value() * iter.key()->result;
+        }
+
+        Q_ASSERT(constant > 0 || qFuzzyCompare(1, 1 + constant));
+
+        if (qFuzzyCompare(1000 + leftHandSide, 1000 + constant))
+            return true;
+
+        switch (ratio) {
+        case LessOrEqual:
+            return leftHandSide < constant;
+        case MoreOrEqual:
+            return leftHandSide > constant;
+        default:
+            return false;
+        }
+    }
+    #endif
+};
 
 class QSimplex
 {
-- 
cgit v0.12


From 0536b996759ef367e784310f472089eec583213f Mon Sep 17 00:00:00 2001
From: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Date: Fri, 25 Sep 2009 19:35:25 -0300
Subject: QGraphicsAnchorLayout: Add support for expanding SizePolicy with
 simplification

Updating "refreshSizeHints" and "updateChildrenSizes" methods for standard,
parallel and sequential anchors, in order to support the expanding SizePolicy
flag.

This adds the logic required to calculate equivalent expected/nominal expanding
size (AnchorData::expSize) as well as the logic to propagate the effective
size when in the expanding state (AnchorData::sizeAtExpected).

Signed-off-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
Reviewed-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 59 ++++++++++++++----------
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   |  4 +-
 2 files changed, 36 insertions(+), 27 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index cf1429c..20ff03b 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -146,15 +146,11 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
             maxSize /= 2;
         }
 
-        // ###
-        expSize = prefSize;
-        // if (policy & QSizePolicy::ExpandFlag) {
-        //     isExpanding = 1;
-        //     expSize = maxSize;
-        // } else {
-        //     isExpanding = 0;
-        //     expSize = prefSize;
-        // }
+        if (policy & QSizePolicy::ExpandFlag) {
+            expSize = maxSize;
+        } else {
+            expSize = prefSize;
+        }
 
         // Set the anchor effective sizes to preferred.
         //
@@ -175,8 +171,6 @@ void AnchorData::refreshSizeHints(qreal effectiveSpacing)
         expSize = effectiveSpacing;
         maxSize = effectiveSpacing;
 
-        isExpanding = 0;
-
         sizeAtMinimum = prefSize;
         sizeAtPreferred = prefSize;
         sizeAtExpanding = prefSize;
@@ -188,8 +182,8 @@ void ParallelAnchorData::updateChildrenSizes()
 {
     firstEdge->sizeAtMinimum = secondEdge->sizeAtMinimum = sizeAtMinimum;
     firstEdge->sizeAtPreferred = secondEdge->sizeAtPreferred = sizeAtPreferred;
+    firstEdge->sizeAtExpanding = secondEdge->sizeAtExpanding = sizeAtExpanding;
     firstEdge->sizeAtMaximum = secondEdge->sizeAtMaximum = sizeAtMaximum;
-    firstEdge->sizeAtExpanding = secondEdge->sizeAtExpanding = sizeAtPreferred;
 
     firstEdge->updateChildrenSizes();
     secondEdge->updateChildrenSizes();
@@ -215,11 +209,11 @@ void ParallelAnchorData::refreshSizeHints_helper(qreal effectiveSpacing,
     minSize = qMax(firstEdge->minSize, secondEdge->minSize);
     maxSize = qMin(firstEdge->maxSize, secondEdge->maxSize);
 
-    prefSize = qMax(firstEdge->prefSize, secondEdge->prefSize);
-    prefSize = qMin(prefSize, maxSize);
+    expSize = qMax(firstEdge->expSize, secondEdge->expSize);
+    expSize = qMin(expSize, maxSize);
 
-    // ###
-    expSize = prefSize;
+    prefSize = qMax(firstEdge->prefSize, secondEdge->prefSize);
+    prefSize = qMin(prefSize, expSize);
 
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
@@ -260,6 +254,21 @@ static qreal getFactor(qreal value, qreal min, qreal pref, qreal max)
     }
 }
 
+static qreal getExpandingFactor(const qreal &expSize, const qreal &sizeAtPreferred,
+                                const qreal &sizeAtExpanding, const qreal &sizeAtMaximum)
+{
+    const qreal lower = qMin(sizeAtPreferred, sizeAtMaximum);
+    const qreal upper = qMax(sizeAtPreferred, sizeAtMaximum);
+    const qreal boundedExpSize = qBound(lower, expSize, upper);
+
+    const qreal bandSize = sizeAtMaximum - boundedExpSize;
+    if (bandSize == 0) {
+        return 0;
+    } else {
+        return (sizeAtExpanding - boundedExpSize) / bandSize;
+    }
+}
+
 void SequentialAnchorData::updateChildrenSizes()
 {
     // ### REMOVE ME
@@ -269,15 +278,18 @@ void SequentialAnchorData::updateChildrenSizes()
     Q_ASSERT(sizeAtMinimum < maxSize || qFuzzyCompare(sizeAtMinimum, maxSize));
     Q_ASSERT(sizeAtPreferred > minSize || qFuzzyCompare(sizeAtPreferred, minSize));
     Q_ASSERT(sizeAtPreferred < maxSize || qFuzzyCompare(sizeAtPreferred, maxSize));
+    Q_ASSERT(sizeAtExpanding > minSize || qFuzzyCompare(sizeAtExpanding, minSize));
+    Q_ASSERT(sizeAtExpanding < maxSize || qFuzzyCompare(sizeAtExpanding, maxSize));
     Q_ASSERT(sizeAtMaximum > minSize || qFuzzyCompare(sizeAtMaximum, minSize));
     Q_ASSERT(sizeAtMaximum < maxSize || qFuzzyCompare(sizeAtMaximum, maxSize));
 
     // Band here refers if the value is in the Minimum To Preferred
     // band (the lower band) or the Preferred To Maximum (the upper band).
 
-    qreal minFactor = getFactor(sizeAtMinimum, minSize, prefSize, maxSize);
-    qreal prefFactor = getFactor(sizeAtPreferred, minSize, prefSize, maxSize);
-    qreal maxFactor = getFactor(sizeAtMaximum, minSize, prefSize, maxSize);
+    const qreal minFactor = getFactor(sizeAtMinimum, minSize, prefSize, maxSize);
+    const qreal prefFactor = getFactor(sizeAtPreferred, minSize, prefSize, maxSize);
+    const qreal maxFactor = getFactor(sizeAtMaximum, minSize, prefSize, maxSize);
+    const qreal expFactor = getExpandingFactor(expSize, sizeAtPreferred, sizeAtExpanding, sizeAtMaximum);
 
     for (int i = 0; i < m_edges.count(); ++i) {
         AnchorData *e = m_edges.at(i);
@@ -291,8 +303,10 @@ void SequentialAnchorData::updateChildrenSizes()
         bandSize = maxFactor > 0 ? e->maxSize - e->prefSize : e->prefSize - e->minSize;
         e->sizeAtMaximum = e->prefSize + bandSize * maxFactor;
 
-        // ###
-        e->sizeAtExpanding = e->sizeAtPreferred;
+        const qreal lower = qMin(e->sizeAtPreferred, e->sizeAtMaximum);
+        const qreal upper = qMax(e->sizeAtPreferred, e->sizeAtMaximum);
+        const qreal edgeBoundedExpSize = qBound(lower, e->expSize, upper);
+        e->sizeAtExpanding = edgeBoundedExpSize + expFactor * (e->sizeAtMaximum - edgeBoundedExpSize);
 
         e->updateChildrenSizes();
     }
@@ -324,9 +338,6 @@ void SequentialAnchorData::refreshSizeHints_helper(qreal effectiveSpacing,
         maxSize += edge->maxSize;
     }
 
-    // ###
-    expSize = prefSize;
-
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 8f67b2c..aac4f96 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -156,8 +156,7 @@ struct AnchorData : public QSimplexVariable {
           sizeAtMinimum(0), sizeAtPreferred(0),
           sizeAtExpanding(0), sizeAtMaximum(0),
           graphicsAnchor(0), skipInPreferred(0),
-          type(Normal), hasSize(true), isLayoutAnchor(false),
-          isExpanding(false) {}
+          type(Normal), hasSize(true), isLayoutAnchor(false) {}
 
     virtual void updateChildrenSizes() {}
     virtual void refreshSizeHints(qreal effectiveSpacing);
@@ -214,7 +213,6 @@ struct AnchorData : public QSimplexVariable {
     uint type : 2;            // either Normal, Sequential or Parallel
     uint hasSize : 1;         // if false, get size from style.
     uint isLayoutAnchor : 1;  // if this anchor is connected to a layout 'edge'
-    uint isExpanding : 1;     // if true, expands before other anchors
 };
 
 #ifdef QT_DEBUG
-- 
cgit v0.12


From 89ea5d0cc0b00a1d4e8f3e700b86f168cf4437ed Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Wed, 30 Sep 2009 12:25:34 -0300
Subject: QGraphicsAnchorLayout: Fix creation of internal layout anchors

Since the AnchorData cleanup commit (c974aca8) all anchor initialization
is being done by refreshSizeHints. However that method was not able
to properly initialize the internal layout anchors.

This commit refactors that method both to add the functionality and
improve readability.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp   | 145 ++++++++++++---------
 .../tst_qgraphicsanchorlayout.cpp                  |   2 +-
 2 files changed, 84 insertions(+), 63 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 20ff03b..8139b2b 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -92,90 +92,111 @@ qreal QGraphicsAnchorPrivate::spacing() const
 }
 
 
+static void sizeHintsFromItem(QGraphicsLayoutItem *item,
+                             const QGraphicsAnchorLayoutPrivate::Orientation orient,
+                             qreal *minSize, qreal *prefSize,
+                             qreal *expSize, qreal *maxSize)
+{
+    QSizePolicy::Policy policy;
+    qreal minSizeHint;
+    qreal prefSizeHint;
+    qreal maxSizeHint;
+
+    if (orient == QGraphicsAnchorLayoutPrivate::Horizontal) {
+        policy = item->sizePolicy().horizontalPolicy();
+        minSizeHint = item->effectiveSizeHint(Qt::MinimumSize).width();
+        prefSizeHint = item->effectiveSizeHint(Qt::PreferredSize).width();
+        maxSizeHint = item->effectiveSizeHint(Qt::MaximumSize).width();
+    } else {
+        policy = item->sizePolicy().verticalPolicy();
+        minSizeHint = item->effectiveSizeHint(Qt::MinimumSize).height();
+        prefSizeHint = item->effectiveSizeHint(Qt::PreferredSize).height();
+        maxSizeHint = item->effectiveSizeHint(Qt::MaximumSize).height();
+    }
+
+    // minSize, prefSize and maxSize are initialized
+    // with item's preferred Size: this is QSizePolicy::Fixed.
+    //
+    // Then we check each flag to find the resultant QSizePolicy,
+    // according to the following table:
+    //
+    //      constant               value
+    // QSizePolicy::Fixed            0
+    // QSizePolicy::Minimum       GrowFlag
+    // QSizePolicy::Maximum       ShrinkFlag
+    // QSizePolicy::Preferred     GrowFlag | ShrinkFlag
+    // QSizePolicy::Ignored       GrowFlag | ShrinkFlag | IgnoreFlag
+
+    if (policy & QSizePolicy::ShrinkFlag)
+        *minSize = minSizeHint;
+    else
+        *minSize = prefSizeHint;
+
+    if (policy & QSizePolicy::GrowFlag)
+        *maxSize = maxSizeHint;
+    else
+        *maxSize = prefSizeHint;
+
+    // Note that these two initializations are affected by the previous flags
+    if (policy & QSizePolicy::IgnoreFlag)
+        *prefSize = *maxSize;
+    else
+        *prefSize = prefSizeHint;
+
+    if (policy & QSizePolicy::ExpandFlag)
+        *expSize = *maxSize;
+    else
+        *expSize = *prefSize;
+}
+
 void AnchorData::refreshSizeHints(qreal effectiveSpacing)
 {
-    if (!isLayoutAnchor && (from->m_item == to->m_item)) {
-        QGraphicsLayoutItem *item = from->m_item;
+    const bool isInternalAnchor = from->m_item == to->m_item;
 
-        const QGraphicsAnchorLayoutPrivate::Orientation orient = QGraphicsAnchorLayoutPrivate::edgeOrientation(from->m_edge);
-        const Qt::AnchorPoint centerEdge = QGraphicsAnchorLayoutPrivate::pickEdge(Qt::AnchorHorizontalCenter, orient);
+    if (isInternalAnchor) {
+        const QGraphicsAnchorLayoutPrivate::Orientation orient =
+            QGraphicsAnchorLayoutPrivate::edgeOrientation(from->m_edge);
 
-        QSizePolicy::Policy policy;
-        qreal minSizeHint, prefSizeHint, maxSizeHint;
-        if (orient == QGraphicsAnchorLayoutPrivate::Horizontal) {
-            policy = item->sizePolicy().horizontalPolicy();
-            minSizeHint = item->effectiveSizeHint(Qt::MinimumSize).width();
-            prefSizeHint = item->effectiveSizeHint(Qt::PreferredSize).width();
-            maxSizeHint = item->effectiveSizeHint(Qt::MaximumSize).width();
+        if (isLayoutAnchor) {
+            minSize = 0;
+            prefSize = 0;
+            expSize = 0;
+            maxSize = QWIDGETSIZE_MAX;
         } else {
-            policy = item->sizePolicy().verticalPolicy();
-            minSizeHint = item->effectiveSizeHint(Qt::MinimumSize).height();
-            prefSizeHint = item->effectiveSizeHint(Qt::PreferredSize).height();
-            maxSizeHint = item->effectiveSizeHint(Qt::MaximumSize).height();
+            QGraphicsLayoutItem *item = from->m_item;
+            sizeHintsFromItem(item, orient, &minSize, &prefSize, &expSize, &maxSize);
         }
-        // minSize, prefSize and maxSize are initialized
-        // with item's preferred Size: this is QSizePolicy::Fixed.
-        //
-        // Then we check each flag to find the resultant QSizePolicy,
-        // according to the following table:
-        //
-        //      constant               value
-        // QSizePolicy::Fixed            0
-        // QSizePolicy::Minimum       GrowFlag
-        // QSizePolicy::Maximum       ShrinkFlag
-        // QSizePolicy::Preferred     GrowFlag | ShrinkFlag
-        // QSizePolicy::Ignored       GrowFlag | ShrinkFlag | IgnoreFlag
-        prefSize = prefSizeHint;
-        minSize = prefSize;
-        maxSize = prefSize;
-
-        if (policy & QSizePolicy::GrowFlag)
-            maxSize = maxSizeHint;
-
-        if (policy & QSizePolicy::ShrinkFlag)
-            minSize = minSizeHint;
-
-        if (policy & QSizePolicy::IgnoreFlag)
-            prefSize = minSize;
 
+        const Qt::AnchorPoint centerEdge =
+            QGraphicsAnchorLayoutPrivate::pickEdge(Qt::AnchorHorizontalCenter, orient);
         bool hasCenter = (from->m_edge == centerEdge || to->m_edge == centerEdge);
 
         if (hasCenter) {
             minSize /= 2;
             prefSize /= 2;
+            expSize /= 2;
             maxSize /= 2;
         }
 
-        if (policy & QSizePolicy::ExpandFlag) {
-            expSize = maxSize;
-        } else {
-            expSize = prefSize;
-        }
-
-        // Set the anchor effective sizes to preferred.
-        //
-        // Note: The idea here is that all items should remain at their
-        // preferred size unless where that's impossible.  In cases where
-        // the item is subject to restrictions (anchored to the layout
-        // edges, for instance), the simplex solver will be run to
-        // recalculate and override the values we set here.
-        sizeAtMinimum = prefSize;
-        sizeAtPreferred = prefSize;
-        sizeAtExpanding = prefSize;
-        sizeAtMaximum = prefSize;
-
     } else if (!hasSize) {
         // Anchor has no size defined, use given default information
         minSize = effectiveSpacing;
         prefSize = effectiveSpacing;
         expSize = effectiveSpacing;
         maxSize = effectiveSpacing;
-
-        sizeAtMinimum = prefSize;
-        sizeAtPreferred = prefSize;
-        sizeAtExpanding = prefSize;
-        sizeAtMaximum = prefSize;
     }
+
+    // Set the anchor effective sizes to preferred.
+    //
+    // Note: The idea here is that all items should remain at their
+    // preferred size unless where that's impossible.  In cases where
+    // the item is subject to restrictions (anchored to the layout
+    // edges, for instance), the simplex solver will be run to
+    // recalculate and override the values we set here.
+    sizeAtMinimum = prefSize;
+    sizeAtPreferred = prefSize;
+    sizeAtExpanding = prefSize;
+    sizeAtMaximum = prefSize;
 }
 
 void ParallelAnchorData::updateChildrenSizes()
diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index 4ad48c7..91e5bb3 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -1271,7 +1271,7 @@ void tst_QGraphicsAnchorLayout::sizePolicy()
     w1->adjustSize();
 
     QCOMPARE(l->effectiveSizeHint(Qt::MinimumSize), QSizeF(0, 0));
-    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(0, 0));
+    QCOMPARE(l->effectiveSizeHint(Qt::PreferredSize), QSizeF(100, 100));
     QCOMPARE(l->effectiveSizeHint(Qt::MaximumSize), QSizeF(100, 100));
 
     delete p;
-- 
cgit v0.12


From 0d1e86fdfb7958a1affb93c7760c22fca9a0fcb2 Mon Sep 17 00:00:00 2001
From: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Date: Fri, 25 Sep 2009 18:53:15 -0300
Subject: QGraphicsAnchorLayout: Adding a Float Conflict test case

Now we don't support floating items and so we should consider
that the layout has a conflict when handling this situation.

Signed-off-by: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 .../tst_qgraphicsanchorlayout.cpp                  | 69 ++++++++++++++++++++++
 .../tst_qgraphicsanchorlayout1.cpp                 |  4 +-
 2 files changed, 72 insertions(+), 1 deletion(-)

diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index 91e5bb3..b076631 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -72,6 +72,7 @@ private slots:
     void expandingSequence();
     void expandingSequenceFairDistribution();
     void expandingParallel();
+    void floatConflict();
 };
 
 class RectWidget : public QGraphicsWidget
@@ -158,7 +159,17 @@ void tst_QGraphicsAnchorLayout::simple()
 
     QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
     l->setContentsMargins(0, 0, 0, 0);
+
+    // Horizontal
+    l->addAnchor(w1, Qt::AnchorLeft, l, Qt::AnchorLeft);
     l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);
+    l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);
+
+    // Vertical
+    l->addAnchor(w1, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(w2, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(w1, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchor(w2, Qt::AnchorBottom, l, Qt::AnchorBottom);
 
     QGraphicsWidget p;
     p.setLayout(l);
@@ -1152,12 +1163,22 @@ void tst_QGraphicsAnchorLayout::delete_anchor()
     QGraphicsAnchorLayout *l = new QGraphicsAnchorLayout;
     l->setSpacing(0);
     l->setContentsMargins(0, 0, 0, 0);
+
+    // Horizontal
     l->addAnchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);
     l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);
     l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);
     l->addAnchor(w1, Qt::AnchorRight, w3, Qt::AnchorLeft);
     l->addAnchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
 
+    // Vertical
+    l->addAnchor(w1, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(w1, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchor(w2, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(w2, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchor(w3, Qt::AnchorTop, l, Qt::AnchorTop);
+    l->addAnchor(w3, Qt::AnchorBottom, l, Qt::AnchorBottom);
+
     QGraphicsAnchor *anchor = l->anchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
     anchor->setSpacing(10);
 
@@ -1521,5 +1542,53 @@ void tst_QGraphicsAnchorLayout::expandingParallel()
     QCOMPARE(newLayoutMaximumSize.width(), qreal(300));
 }
 
+void tst_QGraphicsAnchorLayout::floatConflict()
+{
+    QGraphicsWidget *a = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "a");
+    QGraphicsWidget *b = createItem(QSizeF(80,10), QSizeF(90,10), QSizeF(100,10), "b");
+
+    QGraphicsAnchorLayout *l;
+    QGraphicsWidget *p = new QGraphicsWidget(0, Qt::Window);
+
+    l = new QGraphicsAnchorLayout;
+    l->setContentsMargins(0, 0, 0, 0);
+
+    p->setLayout(l);
+
+    // horizontal
+    // with this anchor we have two floating items
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    // Just checking if the layout is handling well the removal of floating items
+    delete l->anchor(a, Qt::AnchorRight, b, Qt::AnchorLeft);
+    QCOMPARE(l->count(), 0);
+    QCOMPARE(layoutHasConflict(l), false);
+
+    // setting back the same anchor
+    setAnchor(l, a, Qt::AnchorRight, b, Qt::AnchorLeft);
+
+    // We don't support floating items but they should be counted as if they are in the layout
+    QCOMPARE(l->count(), 2);
+    // Although, we have an invalid situation
+    QCOMPARE(layoutHasConflict(l), true);
+
+    // Semi-floats are supported
+    setAnchor(l, a, Qt::AnchorLeft, l, Qt::AnchorLeft);
+    QCOMPARE(l->count(), 2);
+
+    // Vertically the layout has floating items. Therefore, we have a conflict
+    QCOMPARE(layoutHasConflict(l), true);
+
+    // No more floating items
+    setAnchor(l, b, Qt::AnchorRight, l, Qt::AnchorRight);
+    setAnchor(l, a, Qt::AnchorTop, l, Qt::AnchorTop);
+    setAnchor(l, a, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    setAnchor(l, b, Qt::AnchorTop, l, Qt::AnchorTop);
+    setAnchor(l, b, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    QCOMPARE(layoutHasConflict(l), false);
+
+    delete p;
+}
+
 QTEST_MAIN(tst_QGraphicsAnchorLayout)
 #include "tst_qgraphicsanchorlayout.moc"
diff --git a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
index a521b78..caf078e 100644
--- a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
+++ b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
@@ -530,16 +530,18 @@ void tst_QGraphicsAnchorLayout1::testIsValid()
     TestWidget *widget1 = new TestWidget();
     TestWidget *widget2 = new TestWidget();
 
+    // Vertically the layout has floating items. Therefore, we have a conflict
     layout->setAnchor(layout, Qt::AnchorLeft, widget1, Qt::AnchorLeft, 0.1);
     layout->setAnchor(layout, Qt::AnchorRight, widget1, Qt::AnchorRight, -0.1);
 
+    // Horizontally the layout has floating items. Therefore, we have a conflict
     layout->setAnchor(layout, Qt::AnchorTop, widget2, Qt::AnchorTop, 0.1);
     layout->setAnchor(layout, Qt::AnchorBottom, widget2, Qt::AnchorBottom, -0.1);
 
     widget->setLayout(layout);
 
     widget->setGeometry(QRectF(0,0,100,100));
-    QCOMPARE(layout->isValid(), true);
+    QCOMPARE(layout->isValid(), false);
     delete widget;
     }
 }
-- 
cgit v0.12


From 18da388497b5f3cbc77298a70bc83f037f06c013 Mon Sep 17 00:00:00 2001
From: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Date: Tue, 29 Sep 2009 14:02:27 -0300
Subject: QGraphicsAnchorLayoutPrivate: Handling floating items as an invalid
 layout situation

We make use of the anchor visited on findPaths() to keep track of how many items are visited when
walking on the graph. We can use this information of how many items are reachable (non-float) in order to check
if we have floating items (not reachable from any graph vertex). If so, we have a situation not supported by now.

Signed-off-by: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 51 +++++++++++++++++++++++-
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   |  3 ++
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 8139b2b..e760642 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -1841,6 +1841,11 @@ void QGraphicsAnchorLayoutPrivate::findPaths(Orientation orientation)
             queue.enqueue(qMakePair(pair.second, v));
         }
     }
+
+    // We will walk through every reachable items (non-float) and mark them
+    // by keeping their references on m_nonFloatItems. With this we can easily
+    // identify non-float and float items.
+    identifyNonFloatItems(visited, orientation);
 }
 
 /*!
@@ -1999,6 +2004,46 @@ QGraphicsAnchorLayoutPrivate::getGraphParts(Orientation orientation)
 }
 
 /*!
+ \internal
+
+  Use all visited Anchors on findPaths() so we can identify non-float Items.
+*/
+void QGraphicsAnchorLayoutPrivate::identifyNonFloatItems(QSet<AnchorData *> visited, Orientation orientation)
+{
+    m_nonFloatItems[orientation].clear();
+
+    foreach (const AnchorData *ad, visited)
+        identifyNonFloatItems_helper(ad, orientation);
+}
+
+/*!
+ \internal
+
+  Given an anchor, if it is an internal anchor and Normal we must mark it's item as non-float.
+  If the anchor is Sequential or Parallel, we must iterate on its children recursively until we reach
+  internal anchors (items).
+*/
+void QGraphicsAnchorLayoutPrivate::identifyNonFloatItems_helper(const AnchorData *ad, Orientation orientation)
+{
+    Q_Q(QGraphicsAnchorLayout);
+
+    switch(ad->type) {
+    case AnchorData::Normal:
+        if (ad->from->m_item == ad->to->m_item && ad->to->m_item != q)
+            m_nonFloatItems[orientation].insert(ad->to->m_item);
+        break;
+    case AnchorData::Sequential:
+        foreach (const AnchorData *d, static_cast<const SequentialAnchorData *>(ad)->m_edges)
+            identifyNonFloatItems_helper(d, orientation);
+        break;
+    case AnchorData::Parallel:
+        identifyNonFloatItems_helper(static_cast<const ParallelAnchorData *>(ad)->firstEdge, orientation);
+        identifyNonFloatItems_helper(static_cast<const ParallelAnchorData *>(ad)->secondEdge, orientation);
+        break;
+    }
+}
+
+/*!
   \internal
 
   Use the current vertices distance to calculate and set the geometry of
@@ -2491,7 +2536,11 @@ bool QGraphicsAnchorLayoutPrivate::hasConflicts() const
 {
     QGraphicsAnchorLayoutPrivate *that = const_cast<QGraphicsAnchorLayoutPrivate*>(this);
     that->calculateGraphs();
-    return graphHasConflicts[0] || graphHasConflicts[1];
+
+    bool floatConflict = (m_nonFloatItems[0].size() < items.size())
+                         || (m_nonFloatItems[1].size() < items.size());
+
+    return graphHasConflicts[0] || graphHasConflicts[1] || floatConflict;
 }
 
 #ifdef QT_DEBUG
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index aac4f96..1a74d85 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -445,6 +445,8 @@ public:
     void constraintsFromPaths(Orientation orientation);
     QList<QSimplexConstraint *> constraintsFromSizeHints(const QList<AnchorData *> &anchors);
     QList<QList<QSimplexConstraint *> > getGraphParts(Orientation orientation);
+    void identifyNonFloatItems(QSet<AnchorData *> visited, Orientation orientation);
+    void identifyNonFloatItems_helper(const AnchorData *ad, Orientation orientation);
 
     inline AnchorVertex *internalVertex(const QPair<QGraphicsLayoutItem*, Qt::AnchorPoint> &itemEdge) const
     {
@@ -511,6 +513,7 @@ public:
     // ###
     bool graphSimplified[2];
     bool graphHasConflicts[2];
+    QSet<QGraphicsLayoutItem *> m_nonFloatItems[2];
 
     uint calculateGraphCacheDirty : 1;
 };
-- 
cgit v0.12


From 6367a702b13a440557d4e0a405ae6d34ef0b778f Mon Sep 17 00:00:00 2001
From: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Date: Tue, 29 Sep 2009 15:22:26 -0300
Subject: QGraphicsAnchorLayoutPrivate: Fixing initial geometry values for new
 layout items

Now every item starts with its geometry on ((0,0), preferredSize()).
By doing this we guarantee that every item will have a known initial value, which
can be specially useful on float cases for instance.

Signed-off-by: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
Reviewed-by: Caio Marcelo de Oliveira Filho <caio.oliveira@openbossa.org>
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 37 ++++++++++++++++--------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index e760642..87f5aa0 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -2068,22 +2068,35 @@ void QGraphicsAnchorLayoutPrivate::setItemsGeometries(const QRectF &geom)
     right = geom.right() - right;
 
     foreach (QGraphicsLayoutItem *item, items) {
-        firstH = internalVertex(item, Qt::AnchorLeft);
-        secondH = internalVertex(item, Qt::AnchorRight);
-        firstV = internalVertex(item, Qt::AnchorTop);
-        secondV = internalVertex(item, Qt::AnchorBottom);
-
         QRectF newGeom;
-        newGeom.setTop(top + firstV->distance);
-        newGeom.setBottom(top + secondV->distance);
+        QSizeF itemPreferredSize = item->effectiveSizeHint(Qt::PreferredSize);
+        if (m_nonFloatItems[Horizontal].contains(item)) {
+            firstH = internalVertex(item, Qt::AnchorLeft);
+            secondH = internalVertex(item, Qt::AnchorRight);
+
+            if (visualDir == Qt::LeftToRight) {
+                newGeom.setLeft(left + firstH->distance);
+                newGeom.setRight(left + secondH->distance);
+            } else {
+                newGeom.setLeft(right - secondH->distance);
+                newGeom.setRight(right - firstH->distance);
+            }
+        } else {
+            newGeom.setLeft(0);
+            newGeom.setRight(itemPreferredSize.width());
+        }
+
+        if (m_nonFloatItems[Vertical].contains(item)) {
+            firstV = internalVertex(item, Qt::AnchorTop);
+            secondV = internalVertex(item, Qt::AnchorBottom);
 
-        if (visualDir == Qt::LeftToRight) {
-            newGeom.setLeft(left + firstH->distance);
-            newGeom.setRight(left + secondH->distance);
+            newGeom.setTop(top + firstV->distance);
+            newGeom.setBottom(top + secondV->distance);
         } else {
-            newGeom.setLeft(right - secondH->distance);
-            newGeom.setRight(right - firstH->distance);
+            newGeom.setTop(0);
+            newGeom.setBottom(itemPreferredSize.height());
         }
+
         item->setGeometry(newGeom);
     }
 }
-- 
cgit v0.12


From 709cc9140407280aa5c871d4650c123002dfdd19 Mon Sep 17 00:00:00 2001
From: "Eduardo M. Fleury" <eduardo.fleury@openbossa.org>
Date: Thu, 1 Oct 2009 15:04:20 -0300
Subject: QGraphicsAnchorLayout: Enable "float" Orbit test

Now supported after float patches.

Signed-off-by: Eduardo M. Fleury <eduardo.fleury@openbossa.org>
Reviewed-by: Jesus Sanchez-Palencia <jesus.palencia@openbossa.org>
---
 tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
index caf078e..148b2c8 100644
--- a/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
+++ b/tests/auto/qgraphicsanchorlayout1/tst_qgraphicsanchorlayout1.cpp
@@ -1415,9 +1415,6 @@ void tst_QGraphicsAnchorLayout1::testMixedSpacing_data()
         QTest::newRow("One widget, unsolvable") << QSizeF(10, 10) << theData << theResult;
     }
 
-    // ### BUG. We are not handling "floating" elements properly. Ie. elements that
-    //     have no anchors in a given orientation.
-    if (0)
     // Two widgets, one has fixed size
     {
         BasicLayoutTestDataList theData;
-- 
cgit v0.12


From d6d0b2ef5223b4a40e8907104eb1d9e827507a42 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= <jan-arve.saether@nokia.com>
Date: Wed, 7 Oct 2009 10:51:26 +0200
Subject: Cosmetic fixes to the previous patches.

There is only one change in the actual code here, and it simply removes
an unnecessary initialization of hasSize in the ctors of the composite
anchors.
---
 src/gui/graphicsview/qgraphicsanchorlayout_p.cpp | 68 +++++++++++++-----------
 src/gui/graphicsview/qgraphicsanchorlayout_p.h   |  2 -
 src/gui/graphicsview/qsimplex_p.cpp              |  4 +-
 src/gui/graphicsview/qsimplex_p.h                |  4 +-
 4 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 87f5aa0..34071cc 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -2409,47 +2409,51 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(QList<QSimplexConstraint *> co
     return feasible;
 }
 
-/*! Calculate the "expanding" keyframe
+/*!
+    \internal
+    Calculate the "expanding" keyframe
 
-  This new keyframe sits between the already existing sizeAtPreferred and
-  sizeAtMaximum keyframes. Its goal is to modify the interpolation between
-  the latter as to respect the "expanding" size policy of some anchors.
+    This new keyframe sits between the already existing sizeAtPreferred and
+    sizeAtMaximum keyframes. Its goal is to modify the interpolation between
+    the latter as to respect the "expanding" size policy of some anchors.
 
-  Previously all items would be subject to a linear interpolation between
-  sizeAtPreferred and sizeAtMaximum values. This will change now, the
-  expanding anchors will change their size before the others. To calculate
-  this keyframe we use the following logic:
+    Previously all items would be subject to a linear interpolation between
+    sizeAtPreferred and sizeAtMaximum values. This will change now, the
+    expanding anchors will change their size before the others. To calculate
+    this keyframe we use the following logic:
 
-  1) Ask each anchor for their desired expanding size (ad->expSize), this
-  value depends on the anchor expanding property in the following way:
+    1) Ask each anchor for their desired expanding size (ad->expSize), this
+    value depends on the anchor expanding property in the following way:
 
-  - Expanding anchors want to grow towards their maximum size
-  - Non-expanding anchors want to remain at their preferred size.
-  - Composite anchors want to grow towards somewhere between their
-  preferred sizes. (*)
+    - Expanding normal anchors want to grow towards their maximum size
+    - Non-expanding normal anchors want to remain at their preferred size.
+    - Sequential anchors wants to grow towards a size that is calculated by:
+        summarizing it's child anchors, where it will use preferred size for non-expanding anchors
+        and maximum size for expanding anchors.
+    - Parallel anchors want to grow towards the smallest maximum size of all the expanding anchors.
 
-  2) Clamp their desired values to the value they assume in the neighbour
-  keyframes (sizeAtPreferred and sizeAtExpanding)
+    2) Clamp their desired values to the value they assume in the neighbour
+    keyframes (sizeAtPreferred and sizeAtExpanding)
 
-  3) Run simplex with a setup that ensures the following:
+    3) Run simplex with a setup that ensures the following:
 
-    a. Anchors will change their value from their sizeAtPreferred towards
-       their sizeAtMaximum as much as required to ensure that ALL anchors
-       reach their respective "desired" expanding sizes.
+      a. Anchors will change their value from their sizeAtPreferred towards
+         their sizeAtMaximum as much as required to ensure that ALL anchors
+         reach their respective "desired" expanding sizes.
 
-    b. No anchors will change their value beyond what is NEEDED to satisfy
-       the requirement above.
+      b. No anchors will change their value beyond what is NEEDED to satisfy
+         the requirement above.
 
-  The final result is that, at the "expanding" keyframe expanding anchors
-  will grow and take with them all anchors that are parallel to them.
-  However, non-expanding anchors will remain at their preferred size unless
-  they are forced to grow by a parallel expanding anchor.
+    The final result is that, at the "expanding" keyframe expanding anchors
+    will grow and take with them all anchors that are parallel to them.
+    However, non-expanding anchors will remain at their preferred size unless
+    they are forced to grow by a parallel expanding anchor.
 
-  Note: For anchors where the sizeAtPreferred is bigger than sizeAtPreferred,
-        the visual effect when the layout grows from its preferred size is
-        the following: Expanding anchors will keep their size while non
-        expanding ones will shrink. Only after non-expanding anchors have
-        shrinked all the way, the expanding anchors will start to shrink too.
+    Note: For anchors where the sizeAtPreferred is bigger than sizeAtMaximum,
+          the visual effect when the layout grows from its preferred size is
+          the following: Expanding anchors will keep their size while non
+          expanding ones will shrink. Only after non-expanding anchors have
+          shrinked all the way, the expanding anchors will start to shrink too.
 */
 void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> constraints)
 {
@@ -2495,7 +2499,7 @@ void QGraphicsAnchorLayoutPrivate::solveExpanding(QList<QSimplexConstraint *> co
             itemC->constant = qMax(boundedExpSize, ad->sizeAtMaximum);
             itemConstraints << itemC;
 
-            // Create objective to avoid the anchos from moving away from
+            // Create objective to avoid the anchors from moving away from
             // the preferred size more than the needed amount. (ensure 3.b)
             // The objective function is the distance between sizeAtPreferred
             // and sizeAtExpanding, it will be minimized.
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 1a74d85..24b25de 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -227,7 +227,6 @@ struct SequentialAnchorData : public AnchorData
     SequentialAnchorData() : AnchorData()
     {
         type = AnchorData::Sequential;
-        hasSize = true;
 #ifdef QT_DEBUG
         name = QLatin1String("SequentialAnchorData");
 #endif
@@ -256,7 +255,6 @@ struct ParallelAnchorData : public AnchorData
         : AnchorData(), firstEdge(first), secondEdge(second)
     {
         type = AnchorData::Parallel;
-        hasSize = true;
 
         // ### Those asserts force that both child anchors have the same direction,
         // but can't we simplify a pair of anchors in opposite directions?
diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp
index 95003d2..b8f8fb4 100644
--- a/src/gui/graphicsview/qsimplex_p.cpp
+++ b/src/gui/graphicsview/qsimplex_p.cpp
@@ -519,11 +519,11 @@ qreal QSimplex::solver(solverFactor factor)
     solveMaxHelper();
     collectResults();
 
-    #ifdef QT_DEBUG
+#ifdef QT_DEBUG
     for (int i = 0; i < constraints.size(); ++i) {
         Q_ASSERT(constraints[i]->isSatisfied());
     }
-    #endif
+#endif
 
     return factor * valueAt(0, columns - 1);
 }
diff --git a/src/gui/graphicsview/qsimplex_p.h b/src/gui/graphicsview/qsimplex_p.h
index b517cb9..51991a9 100644
--- a/src/gui/graphicsview/qsimplex_p.h
+++ b/src/gui/graphicsview/qsimplex_p.h
@@ -95,7 +95,7 @@ struct QSimplexConstraint
     QPair<QSimplexVariable *, qreal> helper;
     QSimplexVariable * artificial;
 
-    #ifdef QT_DEBUG
+#ifdef QT_DEBUG
     bool isSatisfied() {
         qreal leftHandSide(0);
 
@@ -118,7 +118,7 @@ struct QSimplexConstraint
             return false;
         }
     }
-    #endif
+#endif
 };
 
 class QSimplex
-- 
cgit v0.12


From dde11ce47c2d83bae685f3ff032ee9e6e372058f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan-Arve=20S=C3=A6ther?= <jan-arve.saether@nokia.com>
Date: Wed, 7 Oct 2009 11:30:30 +0200
Subject: Make some lines in the autotest more readable.

---
 .../qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
index b076631..286ea2d 100644
--- a/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
+++ b/tests/auto/qgraphicsanchorlayout/tst_qgraphicsanchorlayout.cpp
@@ -161,15 +161,13 @@ void tst_QGraphicsAnchorLayout::simple()
     l->setContentsMargins(0, 0, 0, 0);
 
     // Horizontal
-    l->addAnchor(w1, Qt::AnchorLeft, l, Qt::AnchorLeft);
+    l->addAnchor(l, Qt::AnchorLeft, w1, Qt::AnchorLeft);
     l->addAnchor(w1, Qt::AnchorRight, w2, Qt::AnchorLeft);
     l->addAnchor(w2, Qt::AnchorRight, l, Qt::AnchorRight);
 
     // Vertical
-    l->addAnchor(w1, Qt::AnchorTop, l, Qt::AnchorTop);
-    l->addAnchor(w2, Qt::AnchorTop, l, Qt::AnchorTop);
-    l->addAnchor(w1, Qt::AnchorBottom, l, Qt::AnchorBottom);
-    l->addAnchor(w2, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchors(l, w1, Qt::Vertical);
+    l->addAnchors(l, w2, Qt::Vertical);
 
     QGraphicsWidget p;
     p.setLayout(l);
@@ -1172,12 +1170,9 @@ void tst_QGraphicsAnchorLayout::delete_anchor()
     l->addAnchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
 
     // Vertical
-    l->addAnchor(w1, Qt::AnchorTop, l, Qt::AnchorTop);
-    l->addAnchor(w1, Qt::AnchorBottom, l, Qt::AnchorBottom);
-    l->addAnchor(w2, Qt::AnchorTop, l, Qt::AnchorTop);
-    l->addAnchor(w2, Qt::AnchorBottom, l, Qt::AnchorBottom);
-    l->addAnchor(w3, Qt::AnchorTop, l, Qt::AnchorTop);
-    l->addAnchor(w3, Qt::AnchorBottom, l, Qt::AnchorBottom);
+    l->addAnchors(l, w1, Qt::Vertical);
+    l->addAnchors(l, w2, Qt::Vertical);
+    l->addAnchors(l, w3, Qt::Vertical);
 
     QGraphicsAnchor *anchor = l->anchor(w3, Qt::AnchorRight, l, Qt::AnchorRight);
     anchor->setSpacing(10);
-- 
cgit v0.12

IP</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>windowBits <span class="hl opt">&lt;</span> <span class="hl num">48</span><span class="hl opt">)</span>
            windowBits <span class="hl opt">&amp;=</span> <span class="hl num">15</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* set number of window bits, free window if different */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>windowBits <span class="hl opt">&amp;&amp; (</span>windowBits <span class="hl opt">&lt;</span> <span class="hl num">8</span> <span class="hl opt">||</span> windowBits <span class="hl opt">&gt;</span> <span class="hl num">15</span><span class="hl opt">))</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>wbits <span class="hl opt">!= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>windowBits<span class="hl opt">) {</span>
        <span class="hl kwd">ZFREE</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>window<span class="hl opt">);</span>
        state<span class="hl opt">-&gt;</span>window <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* update state and reset the rest of it */</span>
    state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">=</span> wrap<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>wbits <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>windowBits<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl kwd">inflateReset</span><span class="hl opt">(</span>strm<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateInit2_</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> windowBits<span class="hl opt">,</span> version<span class="hl opt">,</span> stream_size<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">int</span> windowBits<span class="hl opt">;</span>
<span class="hl kwb">const char</span> <span class="hl opt">*</span>version<span class="hl opt">;</span>
<span class="hl kwb">int</span> stream_size<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> ret<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>version <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> version<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] !=</span> ZLIB_VERSION<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ||</span>
        stream_size <span class="hl opt">!= (</span><span class="hl kwb">int</span><span class="hl opt">)(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>z_stream<span class="hl opt">)))</span>
        <span class="hl kwa">return</span> Z_VERSION_ERROR<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>                 <span class="hl com">/* in case we return an error */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm<span class="hl opt">-&gt;</span>zalloc <span class="hl opt">== (</span>alloc_func<span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">) {</span>
<span class="hl ppc">#ifdef Z_SOLO</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
<span class="hl ppc">#else</span>
        strm<span class="hl opt">-&gt;</span>zalloc <span class="hl opt">=</span> zcalloc<span class="hl opt">;</span>
        strm<span class="hl opt">-&gt;</span>opaque <span class="hl opt">= (</span>voidpf<span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm<span class="hl opt">-&gt;</span>zfree <span class="hl opt">== (</span>free_func<span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span>
<span class="hl ppc">#ifdef Z_SOLO</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
<span class="hl ppc">#else</span>
        strm<span class="hl opt">-&gt;</span>zfree <span class="hl opt">=</span> zcfree<span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>
            <span class="hl kwd">ZALLOC</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> inflate_state<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
    <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate: allocated</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
    strm<span class="hl opt">-&gt;</span>state <span class="hl opt">= (</span><span class="hl kwb">struct</span> internal_state FAR <span class="hl opt">*)</span>state<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>window <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
    ret <span class="hl opt">=</span> <span class="hl kwd">inflateReset2</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> windowBits<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>ret <span class="hl opt">!=</span> Z_OK<span class="hl opt">) {</span>
        <span class="hl kwd">ZFREE</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> state<span class="hl opt">);</span>
        strm<span class="hl opt">-&gt;</span>state <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateInit_</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> version<span class="hl opt">,</span> stream_size<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">const char</span> <span class="hl opt">*</span>version<span class="hl opt">;</span>
<span class="hl kwb">int</span> stream_size<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">inflateInit2_</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> DEF_WBITS<span class="hl opt">,</span> version<span class="hl opt">,</span> stream_size<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflatePrime</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> bits<span class="hl opt">,</span> value<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">int</span> bits<span class="hl opt">;</span>
<span class="hl kwb">int</span> value<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>bits <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        state<span class="hl opt">-&gt;</span>hold <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>bits <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>bits <span class="hl opt">&gt;</span> <span class="hl num">16</span> <span class="hl opt">||</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">+</span> bits <span class="hl opt">&gt;</span> <span class="hl num">32</span><span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    value <span class="hl opt">&amp;= (</span><span class="hl num">1L</span> <span class="hl opt">&lt;&lt;</span> bits<span class="hl opt">) -</span> <span class="hl num">1</span><span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>hold <span class="hl opt">+=</span> value <span class="hl opt">&lt;&lt;</span> state<span class="hl opt">-&gt;</span>bits<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>bits <span class="hl opt">+=</span> bits<span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com">   Return state with length and distance decoding tables and index sizes set to</span>
<span class="hl com">   fixed code decoding.  Normally this returns fixed tables from inffixed.h.</span>
<span class="hl com">   If BUILDFIXED is defined, then instead this routine builds the tables the</span>
<span class="hl com">   first time it's called, and returns those tables the first time and</span>
<span class="hl com">   thereafter.  This reduces the size of the code by about 2K bytes, in</span>
<span class="hl com">   exchange for a little execution time.  However, BUILDFIXED should not be</span>
<span class="hl com">   used for threaded applications, since the rewriting of the tables and virgin</span>
<span class="hl com">   may not be thread-safe.</span>
<span class="hl com"> */</span>
local <span class="hl kwb">void</span> <span class="hl kwd">fixedtables</span><span class="hl opt">(</span>state<span class="hl opt">)</span>
<span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
<span class="hl opt">{</span>
<span class="hl ppc">#ifdef BUILDFIXED</span>
    <span class="hl kwb">static int</span> virgin <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwb">static</span> code <span class="hl opt">*</span>lenfix<span class="hl opt">, *</span>distfix<span class="hl opt">;</span>
    <span class="hl kwb">static</span> code fixed<span class="hl opt">[</span><span class="hl num">544</span><span class="hl opt">];</span>

    <span class="hl com">/* build fixed huffman tables if first call (may not be thread safe) */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>virgin<span class="hl opt">) {</span>
        <span class="hl kwb">unsigned</span> sym<span class="hl opt">,</span> bits<span class="hl opt">;</span>
        <span class="hl kwb">static</span> code <span class="hl opt">*</span>next<span class="hl opt">;</span>

        <span class="hl com">/* literal/length table */</span>
        sym <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>sym <span class="hl opt">&lt;</span> <span class="hl num">144</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>sym<span class="hl opt">++] =</span> <span class="hl num">8</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>sym <span class="hl opt">&lt;</span> <span class="hl num">256</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>sym<span class="hl opt">++] =</span> <span class="hl num">9</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>sym <span class="hl opt">&lt;</span> <span class="hl num">280</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>sym<span class="hl opt">++] =</span> <span class="hl num">7</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>sym <span class="hl opt">&lt;</span> <span class="hl num">288</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>sym<span class="hl opt">++] =</span> <span class="hl num">8</span><span class="hl opt">;</span>
        next <span class="hl opt">=</span> fixed<span class="hl opt">;</span>
        lenfix <span class="hl opt">=</span> next<span class="hl opt">;</span>
        bits <span class="hl opt">=</span> <span class="hl num">9</span><span class="hl opt">;</span>
        <span class="hl kwd">inflate_table</span><span class="hl opt">(</span>LENS<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">,</span> <span class="hl num">288</span><span class="hl opt">, &amp;(</span>next<span class="hl opt">), &amp;(</span>bits<span class="hl opt">),</span> state<span class="hl opt">-&gt;</span>work<span class="hl opt">);</span>

        <span class="hl com">/* distance table */</span>
        sym <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>sym <span class="hl opt">&lt;</span> <span class="hl num">32</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>sym<span class="hl opt">++] =</span> <span class="hl num">5</span><span class="hl opt">;</span>
        distfix <span class="hl opt">=</span> next<span class="hl opt">;</span>
        bits <span class="hl opt">=</span> <span class="hl num">5</span><span class="hl opt">;</span>
        <span class="hl kwd">inflate_table</span><span class="hl opt">(</span>DISTS<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">,</span> <span class="hl num">32</span><span class="hl opt">, &amp;(</span>next<span class="hl opt">), &amp;(</span>bits<span class="hl opt">),</span> state<span class="hl opt">-&gt;</span>work<span class="hl opt">);</span>

        <span class="hl com">/* do this just once */</span>
        virgin <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl ppc">#else</span> <span class="hl com">/* !BUILDFIXED */</span><span class="hl ppc"></span>
<span class="hl ppc">#   include</span> <span class="hl pps">&quot;inffixed.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#endif</span> <span class="hl com">/* BUILDFIXED */</span><span class="hl ppc"></span>
    state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">=</span> lenfix<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>lenbits <span class="hl opt">=</span> <span class="hl num">9</span><span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>distcode <span class="hl opt">=</span> distfix<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>distbits <span class="hl opt">=</span> <span class="hl num">5</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifdef MAKEFIXED</span>
<span class="hl ppc">#include &lt;stdio.h&gt;</span>

<span class="hl com">/*</span>
<span class="hl com">   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also</span>
<span class="hl com">   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes</span>
<span class="hl com">   those tables to stdout, which would be piped to inffixed.h.  A small program</span>
<span class="hl com">   can simply call makefixed to do this:</span>
<span class="hl com"></span>
<span class="hl com">    void makefixed(void);</span>
<span class="hl com"></span>
<span class="hl com">    int main(void)</span>
<span class="hl com">    {</span>
<span class="hl com">        makefixed();</span>
<span class="hl com">        return 0;</span>
<span class="hl com">    }</span>
<span class="hl com"></span>
<span class="hl com">   Then that can be linked with zlib built with MAKEFIXED defined and run:</span>
<span class="hl com"></span>
<span class="hl com">    a.out &gt; inffixed.h</span>
<span class="hl com"> */</span>
<span class="hl kwb">void</span> <span class="hl kwd">makefixed</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
    <span class="hl kwb">unsigned</span> low<span class="hl opt">,</span> size<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> inflate_state state<span class="hl opt">;</span>

    <span class="hl kwd">fixedtables</span><span class="hl opt">(&amp;</span>state<span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;    /* inffixed.h -- table for decoding fixed codes&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;     * Generated automatically by makefixed().&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;     */&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;    /* WARNING: this file should *not* be used by applications.&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;       It is part of the implementation of this library and is&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;       subject to change. Applications should only use zlib.h.&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;     */&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;&quot;</span><span class="hl opt">);</span>
    size <span class="hl opt">=</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> <span class="hl num">9</span><span class="hl opt">;</span>
    <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;    static const code lenfix[%u] = {&quot;</span><span class="hl opt">,</span> size<span class="hl opt">);</span>
    low <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">((</span>low <span class="hl opt">%</span> <span class="hl num">7</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span>        <span class="hl str">&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;{%u,%u,%d}&quot;</span><span class="hl opt">, (</span>low <span class="hl opt">&amp;</span> <span class="hl num">127</span><span class="hl opt">) ==</span> <span class="hl num">99</span> ? <span class="hl num">64</span> <span class="hl opt">:</span> state<span class="hl opt">.</span>lencode<span class="hl opt">[</span>low<span class="hl opt">].</span>op<span class="hl opt">,</span>
               state<span class="hl opt">.</span>lencode<span class="hl opt">[</span>low<span class="hl opt">].</span>bits<span class="hl opt">,</span> state<span class="hl opt">.</span>lencode<span class="hl opt">[</span>low<span class="hl opt">].</span>val<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(++</span>low <span class="hl opt">==</span> size<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwd">putchar</span><span class="hl opt">(</span><span class="hl str">','</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span>    <span class="hl str">};&quot;</span><span class="hl opt">);</span>
    size <span class="hl opt">=</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> <span class="hl num">5</span><span class="hl opt">;</span>
    <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span>    <span class="hl str">static const code distfix[%u] = {&quot;</span><span class="hl opt">,</span> size<span class="hl opt">);</span>
    low <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">((</span>low <span class="hl opt">%</span> <span class="hl num">6</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span>        <span class="hl str">&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">printf</span><span class="hl opt">(</span><span class="hl str">&quot;{%u,%u,%d}&quot;</span><span class="hl opt">,</span> state<span class="hl opt">.</span>distcode<span class="hl opt">[</span>low<span class="hl opt">].</span>op<span class="hl opt">,</span> state<span class="hl opt">.</span>distcode<span class="hl opt">[</span>low<span class="hl opt">].</span>bits<span class="hl opt">,</span>
               state<span class="hl opt">.</span>distcode<span class="hl opt">[</span>low<span class="hl opt">].</span>val<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(++</span>low <span class="hl opt">==</span> size<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwd">putchar</span><span class="hl opt">(</span><span class="hl str">','</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">puts</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span>    <span class="hl str">};&quot;</span><span class="hl opt">);</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* MAKEFIXED */</span><span class="hl ppc"></span>

<span class="hl com">/*</span>
<span class="hl com">   Update the window with the last wsize (normally 32K) bytes written before</span>
<span class="hl com">   returning.  If window does not exist yet, create it.  This is only called</span>
<span class="hl com">   when a window is already in use, or when output has been written during this</span>
<span class="hl com">   inflate call, but the end of the deflate stream has not been reached yet.</span>
<span class="hl com">   It is also called to create a window for dictionary data when a dictionary</span>
<span class="hl com">   is loaded.</span>
<span class="hl com"></span>
<span class="hl com">   Providing output buffers larger than 32K to inflate() should provide a speed</span>
<span class="hl com">   advantage, since only the last 32K of output is copied to the sliding window</span>
<span class="hl com">   upon return from inflate(), and since all distances after the first 32K of</span>
<span class="hl com">   output will fall in the output data, making match copies simpler and faster.</span>
<span class="hl com">   The advantage may be dependent on the size of the processor's data caches.</span>
<span class="hl com"> */</span>
local <span class="hl kwb">int</span> <span class="hl kwd">updatewindow</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> end<span class="hl opt">,</span> copy<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">const</span> Bytef <span class="hl opt">*</span>end<span class="hl opt">;</span>
<span class="hl kwb">unsigned</span> copy<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
    <span class="hl kwb">unsigned</span> dist<span class="hl opt">;</span>

    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>

    <span class="hl com">/* if it hasn't been done already, allocate space for the window */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">==</span> Z_NULL<span class="hl opt">) {</span>
        state<span class="hl opt">-&gt;</span>window <span class="hl opt">= (</span><span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*)</span>
                        <span class="hl kwd">ZALLOC</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> state<span class="hl opt">-&gt;</span>wbits<span class="hl opt">,</span>
                               <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">unsigned char</span><span class="hl opt">));</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* if window not in use yet, initialize */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wsize <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        state<span class="hl opt">-&gt;</span>wsize <span class="hl opt">=</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> state<span class="hl opt">-&gt;</span>wbits<span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>whave <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* copy state-&gt;wsize or less output bytes into the circular window */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;=</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">) {</span>
        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window<span class="hl opt">,</span> end <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">);</span>
        state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>whave <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        dist <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>wsize <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>dist <span class="hl opt">&gt;</span> copy<span class="hl opt">)</span> dist <span class="hl opt">=</span> copy<span class="hl opt">;</span>
        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">,</span> end <span class="hl opt">-</span> copy<span class="hl opt">,</span> dist<span class="hl opt">);</span>
        copy <span class="hl opt">-=</span> dist<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>copy<span class="hl opt">) {</span>
            <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window<span class="hl opt">,</span> end <span class="hl opt">-</span> copy<span class="hl opt">,</span> copy<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">=</span> copy<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>whave <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else</span> <span class="hl opt">{</span>
            state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">+=</span> dist<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">==</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>whave <span class="hl opt">&lt;</span> state<span class="hl opt">-&gt;</span>wsize<span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>whave <span class="hl opt">+=</span> dist<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/* Macros for inflate(): */</span>

<span class="hl com">/* check function to use adler32() for zlib or crc32() for gzip */</span>
<span class="hl ppc">#ifdef GUNZIP</span>
<span class="hl ppc">#  define UPDATE(check, buf, len) \</span>
<span class="hl ppc">    (state-&gt;flags ? crc32(check, buf, len) : adler32(check, buf, len))</span>
<span class="hl ppc">#else</span>
<span class="hl ppc">#  define UPDATE(check, buf, len) adler32(check, buf, len)</span>
<span class="hl ppc">#endif</span>

<span class="hl com">/* check macros for header crc */</span>
<span class="hl ppc">#ifdef GUNZIP</span>
<span class="hl ppc">#  define CRC2(check, word) \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        hbuf[0] = (unsigned char)(word); \</span>
<span class="hl ppc">        hbuf[1] = (unsigned char)((word) &gt;&gt; 8); \</span>
<span class="hl ppc">        check = crc32(check, hbuf, 2); \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl ppc">#  define CRC4(check, word) \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        hbuf[0] = (unsigned char)(word); \</span>
<span class="hl ppc">        hbuf[1] = (unsigned char)((word) &gt;&gt; 8); \</span>
<span class="hl ppc">        hbuf[2] = (unsigned char)((word) &gt;&gt; 16); \</span>
<span class="hl ppc">        hbuf[3] = (unsigned char)((word) &gt;&gt; 24); \</span>
<span class="hl ppc">        check = crc32(check, hbuf, 4); \</span>
<span class="hl ppc">    } while (0)</span>
<span class="hl ppc">#endif</span>

<span class="hl com">/* Load registers with state in inflate() for speed */</span>
<span class="hl ppc">#define LOAD() \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        put = strm-&gt;next_out; \</span>
<span class="hl ppc">        left = strm-&gt;avail_out; \</span>
<span class="hl ppc">        next = strm-&gt;next_in; \</span>
<span class="hl ppc">        have = strm-&gt;avail_in; \</span>
<span class="hl ppc">        hold = state-&gt;hold; \</span>
<span class="hl ppc">        bits = state-&gt;bits; \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Restore state from registers in inflate() */</span>
<span class="hl ppc">#define RESTORE() \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        strm-&gt;next_out = put; \</span>
<span class="hl ppc">        strm-&gt;avail_out = left; \</span>
<span class="hl ppc">        strm-&gt;next_in = next; \</span>
<span class="hl ppc">        strm-&gt;avail_in = have; \</span>
<span class="hl ppc">        state-&gt;hold = hold; \</span>
<span class="hl ppc">        state-&gt;bits = bits; \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Clear the input bit accumulator */</span>
<span class="hl ppc">#define INITBITS() \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        hold = 0; \</span>
<span class="hl ppc">        bits = 0; \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Get a byte of input into the bit accumulator, or return from inflate()</span>
<span class="hl com">   if there is no input available. */</span>
<span class="hl ppc">#define PULLBYTE() \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        if (have == 0) goto inf_leave; \</span>
<span class="hl ppc">        have--; \</span>
<span class="hl ppc">        hold += (unsigned long)(*next++) &lt;&lt; bits; \</span>
<span class="hl ppc">        bits += 8; \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Assure that there are at least n bits in the bit accumulator.  If there is</span>
<span class="hl com">   not enough available input to do that, then return from inflate(). */</span>
<span class="hl ppc">#define NEEDBITS(n) \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        while (bits &lt; (unsigned)(n)) \</span>
<span class="hl ppc">            PULLBYTE(); \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Return the low n bits of the bit accumulator (n &lt; 16) */</span>
<span class="hl ppc">#define BITS(n) \</span>
<span class="hl ppc">    ((unsigned)hold &amp; ((1U &lt;&lt; (n)) - 1))</span>

<span class="hl com">/* Remove n bits from the bit accumulator */</span>
<span class="hl ppc">#define DROPBITS(n) \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        hold &gt;&gt;= (n); \</span>
<span class="hl ppc">        bits -= (unsigned)(n); \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/* Remove zero to seven bits as needed to go to a byte boundary */</span>
<span class="hl ppc">#define BYTEBITS() \</span>
<span class="hl ppc">    do { \</span>
<span class="hl ppc">        hold &gt;&gt;= bits &amp; 7; \</span>
<span class="hl ppc">        bits -= bits &amp; 7; \</span>
<span class="hl ppc">    } while (0)</span>

<span class="hl com">/*</span>
<span class="hl com">   inflate() uses a state machine to process as much input data and generate as</span>
<span class="hl com">   much output data as possible before returning.  The state machine is</span>
<span class="hl com">   structured roughly as follows:</span>
<span class="hl com"></span>
<span class="hl com">    for (;;) switch (state) {</span>
<span class="hl com">    ...</span>
<span class="hl com">    case STATEn:</span>
<span class="hl com">        if (not enough input data or output space to make progress)</span>
<span class="hl com">            return;</span>
<span class="hl com">        ... make progress ...</span>
<span class="hl com">        state = STATEm;</span>
<span class="hl com">        break;</span>
<span class="hl com">    ...</span>
<span class="hl com">    }</span>
<span class="hl com"></span>
<span class="hl com">   so when inflate() is called again, the same case is attempted again, and</span>
<span class="hl com">   if the appropriate resources are provided, the machine proceeds to the</span>
<span class="hl com">   next state.  The NEEDBITS() macro is usually the way the state evaluates</span>
<span class="hl com">   whether it can proceed or should return.  NEEDBITS() does the return if</span>
<span class="hl com">   the requested bits are not available.  The typical use of the BITS macros</span>
<span class="hl com">   is:</span>
<span class="hl com"></span>
<span class="hl com">        NEEDBITS(n);</span>
<span class="hl com">        ... do something with BITS(n) ...</span>
<span class="hl com">        DROPBITS(n);</span>
<span class="hl com"></span>
<span class="hl com">   where NEEDBITS(n) either returns from inflate() if there isn't enough</span>
<span class="hl com">   input left to load n bits into the accumulator, or it continues.  BITS(n)</span>
<span class="hl com">   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops</span>
<span class="hl com">   the low n bits off the accumulator.  INITBITS() clears the accumulator</span>
<span class="hl com">   and sets the number of available bits to zero.  BYTEBITS() discards just</span>
<span class="hl com">   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()</span>
<span class="hl com">   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.</span>
<span class="hl com"></span>
<span class="hl com">   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return</span>
<span class="hl com">   if there is no input available.  The decoding of variable length codes uses</span>
<span class="hl com">   PULLBYTE() directly in order to pull just enough bytes to decode the next</span>
<span class="hl com">   code, and no more.</span>
<span class="hl com"></span>
<span class="hl com">   Some states loop until they get enough input, making sure that enough</span>
<span class="hl com">   state information is maintained to continue the loop where it left off</span>
<span class="hl com">   if NEEDBITS() returns in the loop.  For example, want, need, and keep</span>
<span class="hl com">   would all have to actually be part of the saved state in case NEEDBITS()</span>
<span class="hl com">   returns:</span>
<span class="hl com"></span>
<span class="hl com">    case STATEw:</span>
<span class="hl com">        while (want &lt; need) {</span>
<span class="hl com">            NEEDBITS(n);</span>
<span class="hl com">            keep[want++] = BITS(n);</span>
<span class="hl com">            DROPBITS(n);</span>
<span class="hl com">        }</span>
<span class="hl com">        state = STATEx;</span>
<span class="hl com">    case STATEx:</span>
<span class="hl com"></span>
<span class="hl com">   As shown above, if the next state is also the next case, then the break</span>
<span class="hl com">   is omitted.</span>
<span class="hl com"></span>
<span class="hl com">   A state may also return if there is not enough output space available to</span>
<span class="hl com">   complete that state.  Those states are copying stored data, writing a</span>
<span class="hl com">   literal byte, and copying a matching string.</span>
<span class="hl com"></span>
<span class="hl com">   When returning, a &quot;goto inf_leave&quot; is used to update the total counters,</span>
<span class="hl com">   update the check value, and determine whether any progress has been made</span>
<span class="hl com">   during that inflate() call in order to return the proper return code.</span>
<span class="hl com">   Progress is defined as a change in either strm-&gt;avail_in or strm-&gt;avail_out.</span>
<span class="hl com">   When there is a window, goto inf_leave will update the window with the last</span>
<span class="hl com">   output written.  If a goto inf_leave occurs in the middle of decompression</span>
<span class="hl com">   and there is no window currently, goto inf_leave will create one and copy</span>
<span class="hl com">   output to the window for the next call of inflate().</span>
<span class="hl com"></span>
<span class="hl com">   In this implementation, the flush parameter of inflate() only affects the</span>
<span class="hl com">   return code (per zlib.h).  inflate() always writes as much as possible to</span>
<span class="hl com">   strm-&gt;next_out, given the space available and the provided input--the effect</span>
<span class="hl com">   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers</span>
<span class="hl com">   the allocation of and copying into a sliding window until necessary, which</span>
<span class="hl com">   provides the effect documented in zlib.h for Z_FINISH when the entire input</span>
<span class="hl com">   stream available.  So the only thing the flush parameter actually does is:</span>
<span class="hl com">   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it</span>
<span class="hl com">   will return Z_BUF_ERROR if it has not reached the end of the stream.</span>
<span class="hl com"> */</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflate</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> flush<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">int</span> flush<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
    z_const <span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*</span>next<span class="hl opt">;</span>    <span class="hl com">/* next input */</span>
    <span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*</span>put<span class="hl opt">;</span>     <span class="hl com">/* next output */</span>
    <span class="hl kwb">unsigned</span> have<span class="hl opt">,</span> left<span class="hl opt">;</span>        <span class="hl com">/* available input and output */</span>
    <span class="hl kwb">unsigned long</span> hold<span class="hl opt">;</span>         <span class="hl com">/* bit buffer */</span>
    <span class="hl kwb">unsigned</span> bits<span class="hl opt">;</span>              <span class="hl com">/* bits in bit buffer */</span>
    <span class="hl kwb">unsigned</span> in<span class="hl opt">,</span> out<span class="hl opt">;</span>           <span class="hl com">/* save starting available input and output */</span>
    <span class="hl kwb">unsigned</span> copy<span class="hl opt">;</span>              <span class="hl com">/* number of stored or match bytes to copy */</span>
    <span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*</span>from<span class="hl opt">;</span>    <span class="hl com">/* where to copy match bytes from */</span>
    code here<span class="hl opt">;</span>                  <span class="hl com">/* current decoding table entry */</span>
    code last<span class="hl opt">;</span>                  <span class="hl com">/* parent table entry */</span>
    <span class="hl kwb">unsigned</span> len<span class="hl opt">;</span>               <span class="hl com">/* length to copy for repeats, bits to drop */</span>
    <span class="hl kwb">int</span> ret<span class="hl opt">;</span>                    <span class="hl com">/* return code */</span>
<span class="hl ppc">#ifdef GUNZIP</span>
    <span class="hl kwb">unsigned char</span> hbuf<span class="hl opt">[</span><span class="hl num">4</span><span class="hl opt">];</span>      <span class="hl com">/* buffer for gzip header crc calculation */</span>
<span class="hl ppc">#endif</span>
    <span class="hl kwb">static const unsigned short</span> order<span class="hl opt">[</span><span class="hl num">19</span><span class="hl opt">] =</span> <span class="hl com">/* permutation of code lengths */</span>
        <span class="hl opt">{</span><span class="hl num">16</span><span class="hl opt">,</span> <span class="hl num">17</span><span class="hl opt">,</span> <span class="hl num">18</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">8</span><span class="hl opt">,</span> <span class="hl num">7</span><span class="hl opt">,</span> <span class="hl num">9</span><span class="hl opt">,</span> <span class="hl num">6</span><span class="hl opt">,</span> <span class="hl num">10</span><span class="hl opt">,</span> <span class="hl num">5</span><span class="hl opt">,</span> <span class="hl num">11</span><span class="hl opt">,</span> <span class="hl num">4</span><span class="hl opt">,</span> <span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">,</span> <span class="hl num">13</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">14</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">15</span><span class="hl opt">};</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>next_out <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span>
        <span class="hl opt">(</span>strm<span class="hl opt">-&gt;</span>next_in <span class="hl opt">==</span> Z_NULL <span class="hl opt">&amp;&amp;</span> strm<span class="hl opt">-&gt;</span>avail_in <span class="hl opt">!=</span> <span class="hl num">0</span><span class="hl opt">))</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>

    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> TYPE<span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPEDO<span class="hl opt">;</span>      <span class="hl com">/* skip check */</span>
    <span class="hl kwd">LOAD</span><span class="hl opt">();</span>
    in <span class="hl opt">=</span> have<span class="hl opt">;</span>
    out <span class="hl opt">=</span> left<span class="hl opt">;</span>
    ret <span class="hl opt">=</span> Z_OK<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(;;)</span>
        <span class="hl kwa">switch</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode<span class="hl opt">) {</span>
        <span class="hl kwa">case</span> HEAD<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPEDO<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">);</span>
<span class="hl ppc">#ifdef GUNZIP</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">&amp;</span> <span class="hl num">2</span><span class="hl opt">) &amp;&amp;</span> hold <span class="hl opt">==</span> <span class="hl num">0x8b1f</span><span class="hl opt">) {</span>  <span class="hl com">/* gzip header */</span>
                state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">crc32</span><span class="hl opt">(</span><span class="hl num">0L</span><span class="hl opt">,</span> Z_NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
                <span class="hl kwd">CRC2</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> hold<span class="hl opt">);</span>
                <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> FLAGS<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>flags <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>           <span class="hl com">/* expect zlib header */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>done <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(!(</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">&amp;</span> <span class="hl num">1</span><span class="hl opt">) ||</span>   <span class="hl com">/* check if zlib header allowed */</span>
<span class="hl ppc">#else</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>
<span class="hl ppc">#endif</span>
                <span class="hl opt">((</span><span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">8</span><span class="hl opt">) &lt;&lt;</span> <span class="hl num">8</span><span class="hl opt">) + (</span>hold <span class="hl opt">&gt;&gt;</span> <span class="hl num">8</span><span class="hl opt">)) %</span> <span class="hl num">31</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;incorrect header check&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">) !=</span> Z_DEFLATED<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;unknown compression method&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">);</span>
            len <span class="hl opt">=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">) +</span> <span class="hl num">8</span><span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wbits <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>wbits <span class="hl opt">=</span> len<span class="hl opt">;</span>
            <span class="hl kwa">else if</span> <span class="hl opt">(</span>len <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>wbits<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid window size&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>dmax <span class="hl opt">=</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> len<span class="hl opt">;</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:   zlib header ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">adler32</span><span class="hl opt">(</span><span class="hl num">0L</span><span class="hl opt">,</span> Z_NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> hold <span class="hl opt">&amp;</span> <span class="hl num">0x200</span> ? DICTID <span class="hl opt">:</span> TYPE<span class="hl opt">;</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
<span class="hl ppc">#ifdef GUNZIP</span>
        <span class="hl kwa">case</span> FLAGS<span class="hl opt">:</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>flags <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)(</span>hold<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0xff</span><span class="hl opt">) !=</span> Z_DEFLATED<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;unknown compression method&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0xe000</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;unknown header flags set&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>text <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)((</span>hold <span class="hl opt">&gt;&gt;</span> <span class="hl num">8</span><span class="hl opt">) &amp;</span> <span class="hl num">1</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span> <span class="hl kwd">CRC2</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> hold<span class="hl opt">);</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TIME<span class="hl opt">;</span>
        <span class="hl kwa">case</span> TIME<span class="hl opt">:</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>time <span class="hl opt">=</span> hold<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span> <span class="hl kwd">CRC4</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> hold<span class="hl opt">);</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> OS<span class="hl opt">;</span>
        <span class="hl kwa">case</span> OS<span class="hl opt">:</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>xflags <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)(</span>hold <span class="hl opt">&amp;</span> <span class="hl num">0xff</span><span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>os <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)(</span>hold <span class="hl opt">&gt;&gt;</span> <span class="hl num">8</span><span class="hl opt">);</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span> <span class="hl kwd">CRC2</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> hold<span class="hl opt">);</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> EXLEN<span class="hl opt">;</span>
        <span class="hl kwa">case</span> EXLEN<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0400</span><span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>length <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>hold<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                    state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra_len <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>hold<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span> <span class="hl kwd">CRC2</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> hold<span class="hl opt">);</span>
                <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">else if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> EXTRA<span class="hl opt">;</span>
        <span class="hl kwa">case</span> EXTRA<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0400</span><span class="hl opt">) {</span>
                copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> have<span class="hl opt">)</span> copy <span class="hl opt">=</span> have<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy<span class="hl opt">) {</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span>
                        state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
                        len <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra_len <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
                        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra <span class="hl opt">+</span> len<span class="hl opt">,</span> next<span class="hl opt">,</span>
                                len <span class="hl opt">+</span> copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra_max ?
                                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>extra_max <span class="hl opt">-</span> len <span class="hl opt">:</span> copy<span class="hl opt">);</span>
                    <span class="hl opt">}</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span>
                        state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">crc32</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> next<span class="hl opt">,</span> copy<span class="hl opt">);</span>
                    have <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                    next <span class="hl opt">+=</span> copy<span class="hl opt">;</span>
                    state<span class="hl opt">-&gt;</span>length <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>length<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>length <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> NAME<span class="hl opt">;</span>
        <span class="hl kwa">case</span> NAME<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0800</span><span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>have <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
                copy <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                <span class="hl kwa">do</span> <span class="hl opt">{</span>
                    len <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>next<span class="hl opt">[</span>copy<span class="hl opt">++]);</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span>
                            state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>name <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span>
                            state<span class="hl opt">-&gt;</span>length <span class="hl opt">&lt;</span> state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>name_max<span class="hl opt">)</span>
                        state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>name<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>length<span class="hl opt">++] =</span> len<span class="hl opt">;</span>
                <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>len <span class="hl opt">&amp;&amp;</span> copy <span class="hl opt">&lt;</span> have<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span>
                    state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">crc32</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> next<span class="hl opt">,</span> copy<span class="hl opt">);</span>
                have <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                next <span class="hl opt">+=</span> copy<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>len<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">else if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>name <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>length <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> COMMENT<span class="hl opt">;</span>
        <span class="hl kwa">case</span> COMMENT<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x1000</span><span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>have <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
                copy <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                <span class="hl kwa">do</span> <span class="hl opt">{</span>
                    len <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>next<span class="hl opt">[</span>copy<span class="hl opt">++]);</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span>
                            state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>comment <span class="hl opt">!=</span> Z_NULL <span class="hl opt">&amp;&amp;</span>
                            state<span class="hl opt">-&gt;</span>length <span class="hl opt">&lt;</span> state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>comm_max<span class="hl opt">)</span>
                        state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>comment<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>length<span class="hl opt">++] =</span> len<span class="hl opt">;</span>
                <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>len <span class="hl opt">&amp;&amp;</span> copy <span class="hl opt">&lt;</span> have<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">)</span>
                    state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">crc32</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> next<span class="hl opt">,</span> copy<span class="hl opt">);</span>
                have <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                next <span class="hl opt">+=</span> copy<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>len<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">else if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>comment <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> HCRC<span class="hl opt">;</span>
        <span class="hl kwa">case</span> HCRC<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&amp;</span> <span class="hl num">0x0200</span><span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>hold <span class="hl opt">!= (</span>state<span class="hl opt">-&gt;</span>check <span class="hl opt">&amp;</span> <span class="hl num">0xffff</span><span class="hl opt">)) {</span>
                    strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;header crc mismatch&quot;</span><span class="hl opt">;</span>
                    state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                    <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>head <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>hcrc <span class="hl opt">= (</span><span class="hl kwb">int</span><span class="hl opt">)((</span>state<span class="hl opt">-&gt;</span>flags <span class="hl opt">&gt;&gt;</span> <span class="hl num">9</span><span class="hl opt">) &amp;</span> <span class="hl num">1</span><span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>head<span class="hl opt">-&gt;</span>done <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">crc32</span><span class="hl opt">(</span><span class="hl num">0L</span><span class="hl opt">,</span> Z_NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPE<span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
        <span class="hl kwa">case</span> DICTID<span class="hl opt">:</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">);</span>
            strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">ZSWAP32</span><span class="hl opt">(</span>hold<span class="hl opt">);</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> DICT<span class="hl opt">;</span>
        <span class="hl kwa">case</span> DICT<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>havedict <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                <span class="hl kwd">RESTORE</span><span class="hl opt">();</span>
                <span class="hl kwa">return</span> Z_NEED_DICT<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span> <span class="hl kwd">adler32</span><span class="hl opt">(</span><span class="hl num">0L</span><span class="hl opt">,</span> Z_NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPE<span class="hl opt">;</span>
        <span class="hl kwa">case</span> TYPE<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>flush <span class="hl opt">==</span> Z_BLOCK <span class="hl opt">||</span> flush <span class="hl opt">==</span> Z_TREES<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
        <span class="hl kwa">case</span> TYPEDO<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>last<span class="hl opt">) {</span>
                <span class="hl kwd">BYTEBITS</span><span class="hl opt">();</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> CHECK<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>last <span class="hl opt">=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">);</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">);</span>
            <span class="hl kwa">switch</span> <span class="hl opt">(</span><span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">)) {</span>
            <span class="hl kwa">case</span> <span class="hl num">0</span><span class="hl opt">:</span>                             <span class="hl com">/* stored block */</span>
                <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:     stored block%s</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                        state<span class="hl opt">-&gt;</span>last ? <span class="hl str">&quot; (last)&quot;</span> <span class="hl opt">:</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">));</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> STORED<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl kwa">case</span> <span class="hl num">1</span><span class="hl opt">:</span>                             <span class="hl com">/* fixed block */</span>
                <span class="hl kwd">fixedtables</span><span class="hl opt">(</span>state<span class="hl opt">);</span>
                <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:     fixed codes block%s</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                        state<span class="hl opt">-&gt;</span>last ? <span class="hl str">&quot; (last)&quot;</span> <span class="hl opt">:</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">));</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN_<span class="hl opt">;</span>             <span class="hl com">/* decode codes */</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>flush <span class="hl opt">==</span> Z_TREES<span class="hl opt">) {</span>
                    <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">);</span>
                    <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl kwa">case</span> <span class="hl num">2</span><span class="hl opt">:</span>                             <span class="hl com">/* dynamic block */</span>
                <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:     dynamic codes block%s</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                        state<span class="hl opt">-&gt;</span>last ? <span class="hl str">&quot; (last)&quot;</span> <span class="hl opt">:</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">));</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TABLE<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl kwa">case</span> <span class="hl num">3</span><span class="hl opt">:</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid block type&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">);</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwa">case</span> STORED<span class="hl opt">:</span>
            <span class="hl kwd">BYTEBITS</span><span class="hl opt">();</span>                         <span class="hl com">/* go to byte boundary */</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span>hold <span class="hl opt">&amp;</span> <span class="hl num">0xffff</span><span class="hl opt">) != ((</span>hold <span class="hl opt">&gt;&gt;</span> <span class="hl num">16</span><span class="hl opt">) ^</span> <span class="hl num">0xffff</span><span class="hl opt">)) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid stored block lengths&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>length <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>hold <span class="hl opt">&amp;</span> <span class="hl num">0xffff</span><span class="hl opt">;</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:       stored length %u</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                    state<span class="hl opt">-&gt;</span>length<span class="hl opt">));</span>
            <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> COPY_<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>flush <span class="hl opt">==</span> Z_TREES<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
        <span class="hl kwa">case</span> COPY_<span class="hl opt">:</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> COPY<span class="hl opt">;</span>
        <span class="hl kwa">case</span> COPY<span class="hl opt">:</span>
            copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>copy<span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> have<span class="hl opt">)</span> copy <span class="hl opt">=</span> have<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> left<span class="hl opt">)</span> copy <span class="hl opt">=</span> left<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
                <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>put<span class="hl opt">,</span> next<span class="hl opt">,</span> copy<span class="hl opt">);</span>
                have <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                next <span class="hl opt">+=</span> copy<span class="hl opt">;</span>
                left <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                put <span class="hl opt">+=</span> copy<span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>length <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:       stored end</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPE<span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwa">case</span> TABLE<span class="hl opt">:</span>
            <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">14</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>nlen <span class="hl opt">=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">5</span><span class="hl opt">) +</span> <span class="hl num">257</span><span class="hl opt">;</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">5</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>ndist <span class="hl opt">=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">5</span><span class="hl opt">) +</span> <span class="hl num">1</span><span class="hl opt">;</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">5</span><span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>ncode <span class="hl opt">=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">) +</span> <span class="hl num">4</span><span class="hl opt">;</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">4</span><span class="hl opt">);</span>
<span class="hl ppc">#ifndef PKZIP_BUG_WORKAROUND</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>nlen <span class="hl opt">&gt;</span> <span class="hl num">286</span> <span class="hl opt">||</span> state<span class="hl opt">-&gt;</span>ndist <span class="hl opt">&gt;</span> <span class="hl num">30</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;too many length or distance symbols&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:       table sizes ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>have <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LENLENS<span class="hl opt">;</span>
        <span class="hl kwa">case</span> LENLENS<span class="hl opt">:</span>
            <span class="hl kwa">while</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">&lt;</span> state<span class="hl opt">-&gt;</span>ncode<span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>order<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">++]] = (</span><span class="hl kwb">unsigned short</span><span class="hl opt">)</span><span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
                <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">while</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">&lt;</span> <span class="hl num">19</span><span class="hl opt">)</span>
                state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>order<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">++]] =</span> <span class="hl num">0</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>codes<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">= (</span><span class="hl kwb">const</span> code FAR <span class="hl opt">*)(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>lenbits <span class="hl opt">=</span> <span class="hl num">7</span><span class="hl opt">;</span>
            ret <span class="hl opt">=</span> <span class="hl kwd">inflate_table</span><span class="hl opt">(</span>CODES<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">,</span> <span class="hl num">19</span><span class="hl opt">, &amp;(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">),</span>
                                <span class="hl opt">&amp;(</span>state<span class="hl opt">-&gt;</span>lenbits<span class="hl opt">),</span> state<span class="hl opt">-&gt;</span>work<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>ret<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid code lengths set&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:       code lengths ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>have <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> CODELENS<span class="hl opt">;</span>
        <span class="hl kwa">case</span> CODELENS<span class="hl opt">:</span>
            <span class="hl kwa">while</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">&lt;</span> state<span class="hl opt">-&gt;</span>nlen <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>ndist<span class="hl opt">) {</span>
                <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
                    here <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>lencode<span class="hl opt">[</span><span class="hl kwd">BITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>lenbits<span class="hl opt">)];</span>
                    <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>bits<span class="hl opt">) &lt;=</span> bits<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
                    <span class="hl kwd">PULLBYTE</span><span class="hl opt">();</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>val <span class="hl opt">&lt;</span> <span class="hl num">16</span><span class="hl opt">) {</span>
                    <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                    state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">++] =</span> here<span class="hl opt">.</span>val<span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">else</span> <span class="hl opt">{</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>val <span class="hl opt">==</span> <span class="hl num">16</span><span class="hl opt">) {</span>
                        <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits <span class="hl opt">+</span> <span class="hl num">2</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                        <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                            strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid bit length repeat&quot;</span><span class="hl opt">;</span>
                            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                            <span class="hl kwa">break</span><span class="hl opt">;</span>
                        <span class="hl opt">}</span>
                        len <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">];</span>
                        copy <span class="hl opt">=</span> <span class="hl num">3</span> <span class="hl opt">+</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">2</span><span class="hl opt">);</span>
                    <span class="hl opt">}</span>
                    <span class="hl kwa">else if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>val <span class="hl opt">==</span> <span class="hl num">17</span><span class="hl opt">) {</span>
                        <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits <span class="hl opt">+</span> <span class="hl num">3</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                        len <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                        copy <span class="hl opt">=</span> <span class="hl num">3</span> <span class="hl opt">+</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
                    <span class="hl opt">}</span>
                    <span class="hl kwa">else</span> <span class="hl opt">{</span>
                        <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits <span class="hl opt">+</span> <span class="hl num">7</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                        len <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
                        copy <span class="hl opt">=</span> <span class="hl num">11</span> <span class="hl opt">+</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span><span class="hl num">7</span><span class="hl opt">);</span>
                        <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span><span class="hl num">7</span><span class="hl opt">);</span>
                    <span class="hl opt">}</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">+</span> copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>nlen <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>ndist<span class="hl opt">) {</span>
                        strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid bit length repeat&quot;</span><span class="hl opt">;</span>
                        state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                        <span class="hl kwa">break</span><span class="hl opt">;</span>
                    <span class="hl opt">}</span>
                    <span class="hl kwa">while</span> <span class="hl opt">(</span>copy<span class="hl opt">--)</span>
                        state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">++] = (</span><span class="hl kwb">unsigned short</span><span class="hl opt">)</span>len<span class="hl opt">;</span>
                <span class="hl opt">}</span>
            <span class="hl opt">}</span>

            <span class="hl com">/* handle error breaks in while */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> BAD<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>

            <span class="hl com">/* check for end-of-block code (better have one) */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>lens<span class="hl opt">[</span><span class="hl num">256</span><span class="hl opt">] ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid code -- missing end-of-block&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>

            <span class="hl com">/* build code tables -- note: do not change the lenbits or distbits</span>
<span class="hl com">               values here (9 and 6) without reading the comments in inftrees.h</span>
<span class="hl com">               concerning the ENOUGH constants, which depend on those values */</span>
            state<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>codes<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">= (</span><span class="hl kwb">const</span> code FAR <span class="hl opt">*)(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>lenbits <span class="hl opt">=</span> <span class="hl num">9</span><span class="hl opt">;</span>
            ret <span class="hl opt">=</span> <span class="hl kwd">inflate_table</span><span class="hl opt">(</span>LENS<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>lens<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>nlen<span class="hl opt">, &amp;(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">),</span>
                                <span class="hl opt">&amp;(</span>state<span class="hl opt">-&gt;</span>lenbits<span class="hl opt">),</span> state<span class="hl opt">-&gt;</span>work<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>ret<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid literal/lengths set&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>distcode <span class="hl opt">= (</span><span class="hl kwb">const</span> code FAR <span class="hl opt">*)(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>distbits <span class="hl opt">=</span> <span class="hl num">6</span><span class="hl opt">;</span>
            ret <span class="hl opt">=</span> <span class="hl kwd">inflate_table</span><span class="hl opt">(</span>DISTS<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>lens <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>nlen<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>ndist<span class="hl opt">,</span>
                            <span class="hl opt">&amp;(</span>state<span class="hl opt">-&gt;</span>next<span class="hl opt">), &amp;(</span>state<span class="hl opt">-&gt;</span>distbits<span class="hl opt">),</span> state<span class="hl opt">-&gt;</span>work<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>ret<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid distances set&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:       codes ok</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN_<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>flush <span class="hl opt">==</span> Z_TREES<span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
        <span class="hl kwa">case</span> LEN_<span class="hl opt">:</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN<span class="hl opt">;</span>
        <span class="hl kwa">case</span> LEN<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>have <span class="hl opt">&gt;=</span> <span class="hl num">6</span> <span class="hl opt">&amp;&amp;</span> left <span class="hl opt">&gt;=</span> <span class="hl num">258</span><span class="hl opt">) {</span>
                <span class="hl kwd">RESTORE</span><span class="hl opt">();</span>
                <span class="hl kwd">inflate_fast</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> out<span class="hl opt">);</span>
                <span class="hl kwd">LOAD</span><span class="hl opt">();</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> TYPE<span class="hl opt">)</span>
                    state<span class="hl opt">-&gt;</span>back <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>back <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
            <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
                here <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>lencode<span class="hl opt">[</span><span class="hl kwd">BITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>lenbits<span class="hl opt">)];</span>
                <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>bits<span class="hl opt">) &lt;=</span> bits<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl kwd">PULLBYTE</span><span class="hl opt">();</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;&amp; (</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;</span> <span class="hl num">0xf0</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                last <span class="hl opt">=</span> here<span class="hl opt">;</span>
                <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
                    here <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>lencode<span class="hl opt">[</span>last<span class="hl opt">.</span>val <span class="hl opt">+</span>
                            <span class="hl opt">(</span><span class="hl kwd">BITS</span><span class="hl opt">(</span>last<span class="hl opt">.</span>bits <span class="hl opt">+</span> last<span class="hl opt">.</span>op<span class="hl opt">) &gt;&gt;</span> last<span class="hl opt">.</span>bits<span class="hl opt">)];</span>
                    <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>last<span class="hl opt">.</span>bits <span class="hl opt">+</span> here<span class="hl opt">.</span>bits<span class="hl opt">) &lt;=</span> bits<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
                    <span class="hl kwd">PULLBYTE</span><span class="hl opt">();</span>
                <span class="hl opt">}</span>
                <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>last<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> last<span class="hl opt">.</span>bits<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> here<span class="hl opt">.</span>bits<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>length <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>here<span class="hl opt">.</span>val<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">int</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>op<span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                <span class="hl kwd">Tracevv</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> here<span class="hl opt">.</span>val <span class="hl opt">&gt;=</span> <span class="hl num">0x20</span> <span class="hl opt">&amp;&amp;</span> here<span class="hl opt">.</span>val <span class="hl opt">&lt;</span> <span class="hl num">0x7f</span> ?
                        <span class="hl str">&quot;inflate:         literal '%c'</span><span class="hl esc">\n</span><span class="hl str">&quot;</span> <span class="hl opt">:</span>
                        <span class="hl str">&quot;inflate:         literal 0x%02x</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> here<span class="hl opt">.</span>val<span class="hl opt">));</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LIT<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;</span> <span class="hl num">32</span><span class="hl opt">) {</span>
                <span class="hl kwd">Tracevv</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:         end of block</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
                state<span class="hl opt">-&gt;</span>back <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPE<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;</span> <span class="hl num">64</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid literal/length code&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>extra <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>op<span class="hl opt">) &amp;</span> <span class="hl num">15</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LENEXT<span class="hl opt">;</span>
        <span class="hl kwa">case</span> LENEXT<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>length <span class="hl opt">+=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> state<span class="hl opt">-&gt;</span>extra<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">Tracevv</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:         length %u</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>was <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> DIST<span class="hl opt">;</span>
        <span class="hl kwa">case</span> DIST<span class="hl opt">:</span>
            <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
                here <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>distcode<span class="hl opt">[</span><span class="hl kwd">BITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>distbits<span class="hl opt">)];</span>
                <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>bits<span class="hl opt">) &lt;=</span> bits<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl kwd">PULLBYTE</span><span class="hl opt">();</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">((</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;</span> <span class="hl num">0xf0</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                last <span class="hl opt">=</span> here<span class="hl opt">;</span>
                <span class="hl kwa">for</span> <span class="hl opt">(;;) {</span>
                    here <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>distcode<span class="hl opt">[</span>last<span class="hl opt">.</span>val <span class="hl opt">+</span>
                            <span class="hl opt">(</span><span class="hl kwd">BITS</span><span class="hl opt">(</span>last<span class="hl opt">.</span>bits <span class="hl opt">+</span> last<span class="hl opt">.</span>op<span class="hl opt">) &gt;&gt;</span> last<span class="hl opt">.</span>bits<span class="hl opt">)];</span>
                    <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>last<span class="hl opt">.</span>bits <span class="hl opt">+</span> here<span class="hl opt">.</span>bits<span class="hl opt">) &lt;=</span> bits<span class="hl opt">)</span> <span class="hl kwa">break</span><span class="hl opt">;</span>
                    <span class="hl kwd">PULLBYTE</span><span class="hl opt">();</span>
                <span class="hl opt">}</span>
                <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>last<span class="hl opt">.</span>bits<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> last<span class="hl opt">.</span>bits<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>here<span class="hl opt">.</span>bits<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> here<span class="hl opt">.</span>bits<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>here<span class="hl opt">.</span>op <span class="hl opt">&amp;</span> <span class="hl num">64</span><span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid distance code&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            state<span class="hl opt">-&gt;</span>offset <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)</span>here<span class="hl opt">.</span>val<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>extra <span class="hl opt">= (</span><span class="hl kwb">unsigned</span><span class="hl opt">)(</span>here<span class="hl opt">.</span>op<span class="hl opt">) &amp;</span> <span class="hl num">15</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> DISTEXT<span class="hl opt">;</span>
        <span class="hl kwa">case</span> DISTEXT<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>offset <span class="hl opt">+=</span> <span class="hl kwd">BITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                <span class="hl kwd">DROPBITS</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>extra<span class="hl opt">);</span>
                state<span class="hl opt">-&gt;</span>back <span class="hl opt">+=</span> state<span class="hl opt">-&gt;</span>extra<span class="hl opt">;</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#ifdef INFLATE_STRICT</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>offset <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>dmax<span class="hl opt">) {</span>
                strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid distance too far back&quot;</span><span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>
            <span class="hl kwd">Tracevv</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:         distance %u</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>offset<span class="hl opt">));</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> MATCH<span class="hl opt">;</span>
        <span class="hl kwa">case</span> MATCH<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>left <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
            copy <span class="hl opt">=</span> out <span class="hl opt">-</span> left<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>offset <span class="hl opt">&gt;</span> copy<span class="hl opt">) {</span>         <span class="hl com">/* copy from window */</span>
                copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>offset <span class="hl opt">-</span> copy<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>whave<span class="hl opt">) {</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>sane<span class="hl opt">) {</span>
                        strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;invalid distance too far back&quot;</span><span class="hl opt">;</span>
                        state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                        <span class="hl kwa">break</span><span class="hl opt">;</span>
                    <span class="hl opt">}</span>
<span class="hl ppc">#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR</span>
                    <span class="hl kwd">Trace</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate.c too far</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
                    copy <span class="hl opt">-=</span> state<span class="hl opt">-&gt;</span>whave<span class="hl opt">;</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">)</span> copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> left<span class="hl opt">)</span> copy <span class="hl opt">=</span> left<span class="hl opt">;</span>
                    left <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                    state<span class="hl opt">-&gt;</span>length <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
                    <span class="hl kwa">do</span> <span class="hl opt">{</span>
                        <span class="hl opt">*</span>put<span class="hl opt">++ =</span> <span class="hl num">0</span><span class="hl opt">;</span>
                    <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(--</span>copy<span class="hl opt">);</span>
                    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>length <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN<span class="hl opt">;</span>
                    <span class="hl kwa">break</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">) {</span>
                    copy <span class="hl opt">-=</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">;</span>
                    from <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>window <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>wsize <span class="hl opt">-</span> copy<span class="hl opt">);</span>
                <span class="hl opt">}</span>
                <span class="hl kwa">else</span>
                    from <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>window <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>wnext <span class="hl opt">-</span> copy<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">)</span> copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">else</span> <span class="hl opt">{</span>                              <span class="hl com">/* copy from output */</span>
                from <span class="hl opt">=</span> put <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>offset<span class="hl opt">;</span>
                copy <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">&gt;</span> left<span class="hl opt">)</span> copy <span class="hl opt">=</span> left<span class="hl opt">;</span>
            left <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>length <span class="hl opt">-=</span> copy<span class="hl opt">;</span>
            <span class="hl kwa">do</span> <span class="hl opt">{</span>
                <span class="hl opt">*</span>put<span class="hl opt">++ = *</span>from<span class="hl opt">++;</span>
            <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(--</span>copy<span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>length <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN<span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwa">case</span> LIT<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>left <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
            <span class="hl opt">*</span>put<span class="hl opt">++ = (</span><span class="hl kwb">unsigned char</span><span class="hl opt">)(</span>state<span class="hl opt">-&gt;</span>length<span class="hl opt">);</span>
            left<span class="hl opt">--;</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LEN<span class="hl opt">;</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwa">case</span> CHECK<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wrap<span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">);</span>
                out <span class="hl opt">-=</span> left<span class="hl opt">;</span>
                strm<span class="hl opt">-&gt;</span>total_out <span class="hl opt">+=</span> out<span class="hl opt">;</span>
                state<span class="hl opt">-&gt;</span>total <span class="hl opt">+=</span> out<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>out<span class="hl opt">)</span>
                    strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span>
                        <span class="hl kwd">UPDATE</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> put <span class="hl opt">-</span> out<span class="hl opt">,</span> out<span class="hl opt">);</span>
                out <span class="hl opt">=</span> left<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">((</span>
<span class="hl ppc">#ifdef GUNZIP</span>
                     state<span class="hl opt">-&gt;</span>flags ? hold <span class="hl opt">:</span>
<span class="hl ppc">#endif</span>
                     <span class="hl kwd">ZSWAP32</span><span class="hl opt">(</span>hold<span class="hl opt">)) !=</span> state<span class="hl opt">-&gt;</span>check<span class="hl opt">) {</span>
                    strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;incorrect data check&quot;</span><span class="hl opt">;</span>
                    state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                    <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
                <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:   check matches trailer</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#ifdef GUNZIP</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> LENGTH<span class="hl opt">;</span>
        <span class="hl kwa">case</span> LENGTH<span class="hl opt">:</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>flags<span class="hl opt">) {</span>
                <span class="hl kwd">NEEDBITS</span><span class="hl opt">(</span><span class="hl num">32</span><span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>hold <span class="hl opt">!= (</span>state<span class="hl opt">-&gt;</span>total <span class="hl opt">&amp;</span> <span class="hl num">0xffffffff</span>UL<span class="hl opt">)) {</span>
                    strm<span class="hl opt">-&gt;</span>msg <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl str">&quot;incorrect length check&quot;</span><span class="hl opt">;</span>
                    state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> BAD<span class="hl opt">;</span>
                    <span class="hl kwa">break</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>
                <span class="hl kwd">INITBITS</span><span class="hl opt">();</span>
                <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:   length matches trailer</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> DONE<span class="hl opt">;</span>
        <span class="hl kwa">case</span> DONE<span class="hl opt">:</span>
            ret <span class="hl opt">=</span> Z_STREAM_END<span class="hl opt">;</span>
            <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
        <span class="hl kwa">case</span> BAD<span class="hl opt">:</span>
            ret <span class="hl opt">=</span> Z_DATA_ERROR<span class="hl opt">;</span>
            <span class="hl kwa">goto</span> inf_leave<span class="hl opt">;</span>
        <span class="hl kwa">case</span> MEM<span class="hl opt">:</span>
            <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
        <span class="hl kwa">case</span> SYNC<span class="hl opt">:</span>
        <span class="hl kwa">default</span><span class="hl opt">:</span>
            <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
        <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">       Return from inflate(), updating the total counts and the check value.</span>
<span class="hl com">       If there was no progress during the inflate() call, return a buffer</span>
<span class="hl com">       error.  Call updatewindow() to create and/or update the window state.</span>
<span class="hl com">       Note: a memory error from inflate() is non-recoverable.</span>
<span class="hl com">     */</span>
  inf_leave<span class="hl opt">:</span>
    <span class="hl kwd">RESTORE</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wsize <span class="hl opt">|| (</span>out <span class="hl opt">!=</span> strm<span class="hl opt">-&gt;</span>avail_out <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">&lt;</span> BAD <span class="hl opt">&amp;&amp;</span>
            <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">&lt;</span> CHECK <span class="hl opt">||</span> flush <span class="hl opt">!=</span> Z_FINISH<span class="hl opt">)))</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">updatewindow</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> strm<span class="hl opt">-&gt;</span>next_out<span class="hl opt">,</span> out <span class="hl opt">-</span> strm<span class="hl opt">-&gt;</span>avail_out<span class="hl opt">)) {</span>
            state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> MEM<span class="hl opt">;</span>
            <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    in <span class="hl opt">-=</span> strm<span class="hl opt">-&gt;</span>avail_in<span class="hl opt">;</span>
    out <span class="hl opt">-=</span> strm<span class="hl opt">-&gt;</span>avail_out<span class="hl opt">;</span>
    strm<span class="hl opt">-&gt;</span>total_in <span class="hl opt">+=</span> in<span class="hl opt">;</span>
    strm<span class="hl opt">-&gt;</span>total_out <span class="hl opt">+=</span> out<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>total <span class="hl opt">+=</span> out<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">&amp;&amp;</span> out<span class="hl opt">)</span>
        strm<span class="hl opt">-&gt;</span>adler <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>check <span class="hl opt">=</span>
            <span class="hl kwd">UPDATE</span><span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>check<span class="hl opt">,</span> strm<span class="hl opt">-&gt;</span>next_out <span class="hl opt">-</span> out<span class="hl opt">,</span> out<span class="hl opt">);</span>
    strm<span class="hl opt">-&gt;</span>data_type <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>last ? <span class="hl num">64</span> <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">) +</span>
                      <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> TYPE ? <span class="hl num">128</span> <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">) +</span>
                      <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> LEN_ <span class="hl opt">||</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> COPY_ ? <span class="hl num">256</span> <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(((</span>in <span class="hl opt">==</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> out <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) ||</span> flush <span class="hl opt">==</span> Z_FINISH<span class="hl opt">) &amp;&amp;</span> ret <span class="hl opt">==</span> Z_OK<span class="hl opt">)</span>
        ret <span class="hl opt">=</span> Z_BUF_ERROR<span class="hl opt">;</span>
    <span class="hl kwa">return</span> ret<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateEnd</span><span class="hl opt">(</span>strm<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>zfree <span class="hl opt">== (</span>free_func<span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwd">ZFREE</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>window<span class="hl opt">);</span>
    <span class="hl kwd">ZFREE</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> strm<span class="hl opt">-&gt;</span>state<span class="hl opt">);</span>
    strm<span class="hl opt">-&gt;</span>state <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
    <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate: end</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateGetDictionary</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> dictionary<span class="hl opt">,</span> dictLength<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
Bytef <span class="hl opt">*</span>dictionary<span class="hl opt">;</span>
uInt <span class="hl opt">*</span>dictLength<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl com">/* check state */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>

    <span class="hl com">/* copy dictionary */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>whave <span class="hl opt">&amp;&amp;</span> dictionary <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>dictionary<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>window <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">,</span>
                state<span class="hl opt">-&gt;</span>whave <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">);</span>
        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>dictionary <span class="hl opt">+</span> state<span class="hl opt">-&gt;</span>whave <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">,</span>
                state<span class="hl opt">-&gt;</span>window<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>wnext<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>dictLength <span class="hl opt">!=</span> Z_NULL<span class="hl opt">)</span>
        <span class="hl opt">*</span>dictLength <span class="hl opt">=</span> state<span class="hl opt">-&gt;</span>whave<span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateSetDictionary</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> dictionary<span class="hl opt">,</span> dictLength<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">const</span> Bytef <span class="hl opt">*</span>dictionary<span class="hl opt">;</span>
uInt dictLength<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
    <span class="hl kwb">unsigned long</span> dictid<span class="hl opt">;</span>
    <span class="hl kwb">int</span> ret<span class="hl opt">;</span>

    <span class="hl com">/* check state */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">!=</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">!=</span> DICT<span class="hl opt">)</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>

    <span class="hl com">/* check for correct dictionary identifier */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> DICT<span class="hl opt">) {</span>
        dictid <span class="hl opt">=</span> <span class="hl kwd">adler32</span><span class="hl opt">(</span><span class="hl num">0L</span><span class="hl opt">,</span> Z_NULL<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
        dictid <span class="hl opt">=</span> <span class="hl kwd">adler32</span><span class="hl opt">(</span>dictid<span class="hl opt">,</span> dictionary<span class="hl opt">,</span> dictLength<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>dictid <span class="hl opt">!=</span> state<span class="hl opt">-&gt;</span>check<span class="hl opt">)</span>
            <span class="hl kwa">return</span> Z_DATA_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* copy dictionary to window using updatewindow(), which will amend the</span>
<span class="hl com">       existing dictionary if appropriate */</span>
    ret <span class="hl opt">=</span> <span class="hl kwd">updatewindow</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> dictionary <span class="hl opt">+</span> dictLength<span class="hl opt">,</span> dictLength<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>ret<span class="hl opt">) {</span>
        state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> MEM<span class="hl opt">;</span>
        <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    state<span class="hl opt">-&gt;</span>havedict <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwd">Tracev</span><span class="hl opt">((</span>stderr<span class="hl opt">,</span> <span class="hl str">&quot;inflate:   dictionary set</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateGetHeader</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> head<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
gz_headerp head<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl com">/* check state */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>state<span class="hl opt">-&gt;</span>wrap <span class="hl opt">&amp;</span> <span class="hl num">2</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>

    <span class="hl com">/* save header structure */</span>
    state<span class="hl opt">-&gt;</span>head <span class="hl opt">=</span> head<span class="hl opt">;</span>
    head<span class="hl opt">-&gt;</span>done <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com">   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found</span>
<span class="hl com">   or when out of input.  When called, *have is the number of pattern bytes</span>
<span class="hl com">   found in order so far, in 0..3.  On return *have is updated to the new</span>
<span class="hl com">   state.  If on return *have equals four, then the pattern was found and the</span>
<span class="hl com">   return value is how many bytes were read including the last byte of the</span>
<span class="hl com">   pattern.  If *have is less than four, then the pattern has not been found</span>
<span class="hl com">   yet and the return value is len.  In the latter case, syncsearch() can be</span>
<span class="hl com">   called again with more data and the *have state.  *have is initialized to</span>
<span class="hl com">   zero for the first call.</span>
<span class="hl com"> */</span>
local <span class="hl kwb">unsigned</span> <span class="hl kwd">syncsearch</span><span class="hl opt">(</span>have<span class="hl opt">,</span> buf<span class="hl opt">,</span> len<span class="hl opt">)</span>
<span class="hl kwb">unsigned</span> FAR <span class="hl opt">*</span>have<span class="hl opt">;</span>
<span class="hl kwb">const unsigned char</span> FAR <span class="hl opt">*</span>buf<span class="hl opt">;</span>
<span class="hl kwb">unsigned</span> len<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">unsigned</span> got<span class="hl opt">;</span>
    <span class="hl kwb">unsigned</span> next<span class="hl opt">;</span>

    got <span class="hl opt">= *</span>have<span class="hl opt">;</span>
    next <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>next <span class="hl opt">&lt;</span> len <span class="hl opt">&amp;&amp;</span> got <span class="hl opt">&lt;</span> <span class="hl num">4</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">((</span><span class="hl kwb">int</span><span class="hl opt">)(</span>buf<span class="hl opt">[</span>next<span class="hl opt">]) == (</span>got <span class="hl opt">&lt;</span> <span class="hl num">2</span> ? <span class="hl num">0</span> <span class="hl opt">:</span> <span class="hl num">0xff</span><span class="hl opt">))</span>
            got<span class="hl opt">++;</span>
        <span class="hl kwa">else if</span> <span class="hl opt">(</span>buf<span class="hl opt">[</span>next<span class="hl opt">])</span>
            got <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">else</span>
            got <span class="hl opt">=</span> <span class="hl num">4</span> <span class="hl opt">-</span> got<span class="hl opt">;</span>
        next<span class="hl opt">++;</span>
    <span class="hl opt">}</span>
    <span class="hl opt">*</span>have <span class="hl opt">=</span> got<span class="hl opt">;</span>
    <span class="hl kwa">return</span> next<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateSync</span><span class="hl opt">(</span>strm<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">unsigned</span> len<span class="hl opt">;</span>               <span class="hl com">/* number of bytes to look at or looked at */</span>
    <span class="hl kwb">unsigned long</span> in<span class="hl opt">,</span> out<span class="hl opt">;</span>      <span class="hl com">/* temporary to save total_in and total_out */</span>
    <span class="hl kwb">unsigned char</span> buf<span class="hl opt">[</span><span class="hl num">4</span><span class="hl opt">];</span>       <span class="hl com">/* to restore bit buffer to byte string */</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl com">/* check parameters */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm<span class="hl opt">-&gt;</span>avail_in <span class="hl opt">==</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">&lt;</span> <span class="hl num">8</span><span class="hl opt">)</span> <span class="hl kwa">return</span> Z_BUF_ERROR<span class="hl opt">;</span>

    <span class="hl com">/* if first time, start search in bit buffer */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">!=</span> SYNC<span class="hl opt">) {</span>
        state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> SYNC<span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>hold <span class="hl opt">&lt;&lt;=</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">&amp;</span> <span class="hl num">7</span><span class="hl opt">;</span>
        state<span class="hl opt">-&gt;</span>bits <span class="hl opt">-=</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">&amp;</span> <span class="hl num">7</span><span class="hl opt">;</span>
        len <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>bits <span class="hl opt">&gt;=</span> <span class="hl num">8</span><span class="hl opt">) {</span>
            buf<span class="hl opt">[</span>len<span class="hl opt">++] = (</span><span class="hl kwb">unsigned char</span><span class="hl opt">)(</span>state<span class="hl opt">-&gt;</span>hold<span class="hl opt">);</span>
            state<span class="hl opt">-&gt;</span>hold <span class="hl opt">&gt;&gt;=</span> <span class="hl num">8</span><span class="hl opt">;</span>
            state<span class="hl opt">-&gt;</span>bits <span class="hl opt">-=</span> <span class="hl num">8</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        state<span class="hl opt">-&gt;</span>have <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwd">syncsearch</span><span class="hl opt">(&amp;(</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">),</span> buf<span class="hl opt">,</span> len<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* search available input */</span>
    len <span class="hl opt">=</span> <span class="hl kwd">syncsearch</span><span class="hl opt">(&amp;(</span>state<span class="hl opt">-&gt;</span>have<span class="hl opt">),</span> strm<span class="hl opt">-&gt;</span>next_in<span class="hl opt">,</span> strm<span class="hl opt">-&gt;</span>avail_in<span class="hl opt">);</span>
    strm<span class="hl opt">-&gt;</span>avail_in <span class="hl opt">-=</span> len<span class="hl opt">;</span>
    strm<span class="hl opt">-&gt;</span>next_in <span class="hl opt">+=</span> len<span class="hl opt">;</span>
    strm<span class="hl opt">-&gt;</span>total_in <span class="hl opt">+=</span> len<span class="hl opt">;</span>

    <span class="hl com">/* return no joy or set up to restart inflate() on a new block */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>have <span class="hl opt">!=</span> <span class="hl num">4</span><span class="hl opt">)</span> <span class="hl kwa">return</span> Z_DATA_ERROR<span class="hl opt">;</span>
    in <span class="hl opt">=</span> strm<span class="hl opt">-&gt;</span>total_in<span class="hl opt">;</span>  out <span class="hl opt">=</span> strm<span class="hl opt">-&gt;</span>total_out<span class="hl opt">;</span>
    <span class="hl kwd">inflateReset</span><span class="hl opt">(</span>strm<span class="hl opt">);</span>
    strm<span class="hl opt">-&gt;</span>total_in <span class="hl opt">=</span> in<span class="hl opt">;</span>  strm<span class="hl opt">-&gt;</span>total_out <span class="hl opt">=</span> out<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>mode <span class="hl opt">=</span> TYPE<span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/*</span>
<span class="hl com">   Returns true if inflate is currently at the end of a block generated by</span>
<span class="hl com">   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP</span>
<span class="hl com">   implementation to provide an additional safety check. PPP uses</span>
<span class="hl com">   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored</span>
<span class="hl com">   block. When decompressing, PPP checks that at the end of input packet,</span>
<span class="hl com">   inflate is waiting for these length bytes.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateSyncPoint</span><span class="hl opt">(</span>strm<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">return</span> state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> STORED <span class="hl opt">&amp;&amp;</span> state<span class="hl opt">-&gt;</span>bits <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateCopy</span><span class="hl opt">(</span>dest<span class="hl opt">,</span> source<span class="hl opt">)</span>
z_streamp dest<span class="hl opt">;</span>
z_streamp source<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>copy<span class="hl opt">;</span>
    <span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*</span>window<span class="hl opt">;</span>
    <span class="hl kwb">unsigned</span> wsize<span class="hl opt">;</span>

    <span class="hl com">/* check input */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>dest <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> source <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> source<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span>
        source<span class="hl opt">-&gt;</span>zalloc <span class="hl opt">== (</span>alloc_func<span class="hl opt">)</span><span class="hl num">0</span> <span class="hl opt">||</span> source<span class="hl opt">-&gt;</span>zfree <span class="hl opt">== (</span>free_func<span class="hl opt">)</span><span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>source<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>

    <span class="hl com">/* allocate space */</span>
    copy <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>
           <span class="hl kwd">ZALLOC</span><span class="hl opt">(</span>source<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> inflate_state<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>copy <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
    window <span class="hl opt">=</span> Z_NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>window <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
        window <span class="hl opt">= (</span><span class="hl kwb">unsigned char</span> FAR <span class="hl opt">*)</span>
                 <span class="hl kwd">ZALLOC</span><span class="hl opt">(</span>source<span class="hl opt">,</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> state<span class="hl opt">-&gt;</span>wbits<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">unsigned char</span><span class="hl opt">));</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>window <span class="hl opt">==</span> Z_NULL<span class="hl opt">) {</span>
            <span class="hl kwd">ZFREE</span><span class="hl opt">(</span>source<span class="hl opt">,</span> copy<span class="hl opt">);</span>
            <span class="hl kwa">return</span> Z_MEM_ERROR<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* copy state */</span>
    <span class="hl kwd">zmemcpy</span><span class="hl opt">((</span>voidpf<span class="hl opt">)</span>dest<span class="hl opt">, (</span>voidpf<span class="hl opt">)</span>source<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>z_stream<span class="hl opt">));</span>
    <span class="hl kwd">zmemcpy</span><span class="hl opt">((</span>voidpf<span class="hl opt">)</span>copy<span class="hl opt">, (</span>voidpf<span class="hl opt">)</span>state<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">struct</span> inflate_state<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">&gt;=</span> state<span class="hl opt">-&gt;</span>codes <span class="hl opt">&amp;&amp;</span>
        state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">&lt;=</span> state<span class="hl opt">-&gt;</span>codes <span class="hl opt">+</span> ENOUGH <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">) {</span>
        copy<span class="hl opt">-&gt;</span>lencode <span class="hl opt">=</span> copy<span class="hl opt">-&gt;</span>codes <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>lencode <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>codes<span class="hl opt">);</span>
        copy<span class="hl opt">-&gt;</span>distcode <span class="hl opt">=</span> copy<span class="hl opt">-&gt;</span>codes <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>distcode <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>codes<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    copy<span class="hl opt">-&gt;</span>next <span class="hl opt">=</span> copy<span class="hl opt">-&gt;</span>codes <span class="hl opt">+ (</span>state<span class="hl opt">-&gt;</span>next <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>codes<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>window <span class="hl opt">!=</span> Z_NULL<span class="hl opt">) {</span>
        wsize <span class="hl opt">=</span> <span class="hl num">1U</span> <span class="hl opt">&lt;&lt;</span> state<span class="hl opt">-&gt;</span>wbits<span class="hl opt">;</span>
        <span class="hl kwd">zmemcpy</span><span class="hl opt">(</span>window<span class="hl opt">,</span> state<span class="hl opt">-&gt;</span>window<span class="hl opt">,</span> wsize<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    copy<span class="hl opt">-&gt;</span>window <span class="hl opt">=</span> window<span class="hl opt">;</span>
    dest<span class="hl opt">-&gt;</span>state <span class="hl opt">= (</span><span class="hl kwb">struct</span> internal_state FAR <span class="hl opt">*)</span>copy<span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span> ZEXPORT <span class="hl kwd">inflateUndermine</span><span class="hl opt">(</span>strm<span class="hl opt">,</span> subvert<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl kwb">int</span> subvert<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> Z_STREAM_ERROR<span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    state<span class="hl opt">-&gt;</span>sane <span class="hl opt">= !</span>subvert<span class="hl opt">;</span>
<span class="hl ppc">#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR</span>
    <span class="hl kwa">return</span> Z_OK<span class="hl opt">;</span>
<span class="hl ppc">#else</span>
    state<span class="hl opt">-&gt;</span>sane <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwa">return</span> Z_DATA_ERROR<span class="hl opt">;</span>
<span class="hl ppc">#endif</span>
<span class="hl opt">}</span>

<span class="hl kwb">long</span> ZEXPORT <span class="hl kwd">inflateMark</span><span class="hl opt">(</span>strm<span class="hl opt">)</span>
z_streamp strm<span class="hl opt">;</span>
<span class="hl opt">{</span>
    <span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*</span>state<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>strm <span class="hl opt">==</span> Z_NULL <span class="hl opt">||</span> strm<span class="hl opt">-&gt;</span>state <span class="hl opt">==</span> Z_NULL<span class="hl opt">)</span> <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1L</span> <span class="hl opt">&lt;&lt;</span> <span class="hl num">16</span><span class="hl opt">;</span>
    state <span class="hl opt">= (</span><span class="hl kwb">struct</span> inflate_state FAR <span class="hl opt">*)</span>strm<span class="hl opt">-&gt;</span>state<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl opt">((</span><span class="hl kwb">long</span><span class="hl opt">)(</span>state<span class="hl opt">-&gt;</span>back<span class="hl opt">) &lt;&lt;</span> <span class="hl num">16</span><span class="hl opt">) +</span>
        <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> COPY ? state<span class="hl opt">-&gt;</span>length <span class="hl opt">:</span>
            <span class="hl opt">(</span>state<span class="hl opt">-&gt;</span>mode <span class="hl opt">==</span> MATCH ? state<span class="hl opt">-&gt;</span>was <span class="hl opt">-</span> state<span class="hl opt">-&gt;</span>length <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">));</span>
<span class="hl opt">}</span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit v0.12</a> at 2025-12-05 11:45:37 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>