/* Coroutine mechanics for the sillier bits of the code */
#define crBegin1    static int crLine = 0;
#define crBegin2    switch(crLine) { case 0:;
#define crBegin        crBegin1; crBegin2;
#define crFinish(z)    } crLine = 0; return (z)
#define crFinishV    } crLine = 0; return
#define crReturn(z)    \
    do {\
        crLine=__LINE__; return (z); case __LINE__:;\
    } while (0)
#define crReturnV    \
    do {\
        crLine=__LINE__; return; case __LINE__:;\
    } while (0)
#define crStop(z)    do{ crLine = 0; return (z); }while(0)
#define crStopV        do{ crLine = 0; return; }while(0)
#define crWaitUntil(c)    do { crReturn(0); } while (!(c))
#define crWaitUntilV(c)    do { crReturnV; } while (!(c))

static int ssh1_rdpkt(unsigned char **data, int *datalen)
{
    struct rdpkt1_state_tag *st = &rdpkt1_state;

    crBegin;

  next_packet:

    pktin.type = 0;
    pktin.length = 0;

    for (st->i = st->len = 0; st->i < 4; st->i++) {
    while ((*datalen) == 0)
        crReturn(4 - st->i);
    st->len = (st->len << 8) + **data;
    (*data)++, (*datalen)--;
    }
    ...

           case 40:
             compatibility_level &= TM_VTXXX;
             break;
           case 41:
             compatibility_level = TM_PUTTY;
             break;
           case 42:
             compatibility_level = TM_SCOANSI;
             break;

               case 14:
            get_window_pixels(&x, &y);
            len = sprintf(buf, "\033[4;%d;%dt", x, y);
            ldisc_send(buf, len, 0);
            break;
               case 18:
            len = sprintf(buf, "\033[8;%d;%dt",
                     rows, cols);
            ldisc_send(buf, len, 0);

Simon Tatham (born May 3, 1977) is an English programmer known primarily for creating and maintaining PuTTY,

Implementations for C

Several attempts have been made, with varying degrees of success, to implement coroutines in C with combinations of subroutines and macros. Simon Tatham's contribution[8] is a good example of the genre, and his own comments provide a good evaluation of the limitations of this approach. The use of such a device truly can improve the writability, readability and maintainability of a piece of code, but is likely to prove controversial. In Tatham's words: "Of course, this trick violates every coding standard in the book... [but] any coding standard which insists on syntactic clarity at the expense of algorithmic clarity should be rewritten. If your employer fires you for using this trick, tell them that repeatedly as the security staff drag you out of the building."

class Pod
{
public:
    Pod(int fuelTank, int cargoBay, int maxMineralIndex, double costFactor):
        F(fuelTank), B(cargoBay), N(maxMineralIndex), q(costFactor),
        depth(0), f(fuelTank), b(0)
    {
    }

    char move(std::vector<std::string> const& zone)
    {
        char const c = play(zone);

        здесь обновляются всякие внутренние переменые

        return c;
    }

private:
    int depth;
    int f;
    int b;

    char delve(std::vector<std::string> const& zone)
    {
        static int seen0 = 0;
        static int seeng = 0;

        static double p0, pg, eta;

        static int aditDepth;
        static int shaftDepth;

        static int b0;
        static int bv;

        static int f0;

        static int dx = 0;

        COROUTINE
        {
            assert(depth == 0);

            while(depth < exploreDepth)
            {
                {
                    int const c0 = std::count(zone[4].begin(), zone[4].end(), CAVE);
                    int const cg = std::count(zone[4].begin(), zone[4].end(), GOB);

                    seen0 += c0;
                    seeng += cg;
                }

                YIELD('D');
            }
        
            p0 = double(seen0) / exploreDepth / zone[0].size();
            pg = double(seeng) / exploreDepth / zone[0].size();

            eta = 1. - p0 - pg;

            std::clog << "p0 = " << p0 << ", pg = " << pg << ", eta = " << eta << std::endl;

            {
                double const targetDepth = 0.25 * F - 0.5 * B/eta * (1. + 3. * p0)/(1. + p0);
                double const vertDelta = 0.5 * p0 * B / eta;
                double const aditEst = 0.5 * B / eta / (1. + p0);

                aditDepth  = (int)(targetDepth - vertDelta - horzSafetyFactor * aditEst - vertSafetyFactor * vertDelta);
                shaftDepth = (int)(targetDepth + vertDelta - horzSafetyFactor * aditEst);

                std::clog << "t = " << targetDepth << ", hs = " << horzSafetyFactor * aditEst << ", vs = " << vertSafetyFactor * vertDelta << std::endl;
            }

            std::clog << "adit = " << aditDepth << ", shaft = " << shaftDepth << std::endl;

            std::clog << "Digging...";

            while(depth < aditDepth)
            {
                if(depth % 50 == 0)
                {
                    std::clog << " " << depth << "..." << std::flush;
                }

                YIELD('D');
            }

            std::clog << std::endl;

            while(cellToBottom(zone) == CAVE && cellToRight(zone) != CAVE)
            {
                ++aditDepth;
                ++shaftDepth;
                YIELD('D');
            }

            std::clog << "depth = " << depth << ": adit" << std::endl;

            if(cellToRight(zone) != CAVE)
            {
                YIELD('R');
                YIELD('L');
            }

            b0 = b;
            std::clog << "Garbage mined: " << b0 << std::endl;

            while(depth < shaftDepth)
            {
                YIELD('D');
            }

            std::clog << "depth = " << depth << ": shaft" << std::endl;

            bv = b - b0;

            std::clog << "Mined in shaft: " << bv << std::endl;

            while(depth > aditDepth)
            {
                YIELD('U');
            }

            std::clog << "depth = " << depth << ": adit again" << std::endl;

            f0 = f;

            std::clog << "Fuel left: " << f << std::endl;

            std::clog << "Mining...";
            while(b - b0 - bv < (B - bv) / 2 && f0 - f < fuelAllowanceFactor * (f0 - 2 * shaftDepth))
            {
                if(cellToBottom(zone) != CAVE || cellToRight(zone) == CAVE)
                {
                    ++dx;

                    YIELD('R');

                    if((b - b0) % 10 == 0)
                    {
                        std::clog << " " << (b - b0) << "..." << std::flush;
                    }
                }
                else
                {
                    YIELD('D');
                }
            }
            std::clog << std::endl;

            std::clog << "depth = " << depth << ", dx = " << dx << ": time to turn back. "
                "Mined so far: " << (b - b0) << " (" << bv << " + " << (b - b0 - bv) << ")" << std::endl;

            std::clog << "Fuel left: " << f << std::endl;

            YIELD('D');

            std::clog << "Mining...";
            while(dx > 0)
            {
                if(cellToBottom(zone) != CAVE || cellToLeft(zone) == CAVE)
                {
                    --dx;

                    YIELD('L');

                    if((b - b0) % 10 == 0)
                    {
                        std::clog << " " << (b - b0) << "..." << std::flush;
                    }
                }
                else
                {
                    YIELD('D');
                }
            }
            std::clog << std::endl;

            std::clog << "Total mined: " << (b - b0) << " + " << b0 << " garbage" << std::endl;

            std::clog << "depth = " << depth << ": LIFTOFF!" << std::endl;

            while(depth > 0)
            {
                YIELD('U');
            }

            std::clog << "Fuel left: " << f << std::endl;

            while(1)
            {
                YIELD(glide(zone));
            }
        }

        return 'X';
    }

    char glide(std::vector<std::string> const& zone)
    {
        COROUTINE
        {
            while(1)
            {
                assert(depth == 0);

                while(false
                    || zone[5][4] == CAVE // v› impossible or ineffective
                    || cellToBottom(zone) == GOB && (zone[4][5] != CAVE || zone[5][5] == CAVE) // v› ineffective
                    || zone[5][5] == CAVE && zone[4][6] != CAVE // v›› impossible, have to v›^ -- ineffective
                    || zone[4][5] == GOB && zone[4][6] == GOB // M..M: v››› = f8c2, ›››v = f5c1
                )
                {
                    YIELD('R');
                }

                YIELD('D');

                while(1)
                {
                    if(false
                        || b >= B
                        || f < 4
                        || cellToBottom(zone) == CAVE && cellToRight(zone) != CAVE
                        || zone[3][5] == GOB && zone[3][6] == GOB && zone[3][7] == GOB && zone[3][8] == GOB
                    )
                    {
                        YIELD('U');
                        break;
                    }

                    YIELD('R');
                }
            }
        }

        return 'X';
    }

    char play(std::vector<std::string> const& zone)
    {
        COROUTINE
        {
            static bool isVertBetter;

            {
                std::string const tmp = zone[4] + zone[5] + zone[6];
                double const p0Est = std::count(tmp.begin(), tmp.end(), CAVE) / double(tmp.size());
                double const pgEst = std::count(tmp.begin(), tmp.end(), GOB)  / double(tmp.size());

                double const etaEst = 1. - p0Est - pgEst;

                std::clog << "etaEst: " << etaEst << std::endl;

                double const vertEst = B * std::pow(q, N * (1. - (B * vertCoefEst) / (F /* * etaEst*/)));
                double const horzEst = 0.5 * F * etaEst;

                std::clog << "vertEst: " << vertEst << " horzEst: " << horzEst << std::endl;

                isVertBetter = vertEst > horzEst;
            }

            while(1)
            {
                YIELD(isVertBetter ? delve(zone) : glide(zone));
            }
        }
    }

    int const B;
    int const N;
    int const F;
    double const q;
};

        if (state_ == 1) {
            // Return to the surface.
            if (position_.X <= 1) {
                state_ = 5;
                continue;
            }
            return strategy_return(vs);
        } else if (state_ == 2) {
            // Find new spot to harvest.
            strategy_best_depth();
            state_ = 3;
            continue;
        } else if (state_ == 3) {
            if (harvest_depth_ < 2) {
                state_ = 5;
                continue;
            }
            // Descent.
            if (position_.X == harvest_depth_) {
                state_ = 4;
                harvest_dir_ = 0;
                continue;
            }
            return strategy_descent(vs);
        } else if (state_ == 4) {
            bool no_dir = (harvest_dir_ == 0);
            if (no_dir) harvest_dir_ = 3;
            if (!no_dir && harvest_dir_ == 3 && strategy_surface_go_down(fuel_left_ - rough_sourface_distance_ - 5, position_, 2, true)) {
                harvest_dir_ = 2;
                return pop_plan(vs);
            }
            if (no_dir) harvest_dir_ = 2;
            if (strategy_surface_go_down(fuel_left_ - rough_sourface_distance_ - 5, position_, 3, true)) {
                harvest_dir_ = 3;
                return pop_plan(vs);
            }
            if (no_dir) harvest_dir_ = 3;
            if (strategy_surface_go_down(fuel_left_ - rough_sourface_distance_ - 5, position_, 2, true)) {
                harvest_dir_ = 2;
                return pop_plan(vs);
            }
            if (no_dir) harvest_dir_ = 0;
            if (can_dig(vs, 1)) {
                do_make_move(vs, 1, MOVE_DIG);
                return dc[1];
            } else {
                do_make_move(vs, 1, MOVE_FLY);
                return dc[1];
            }
        } else if (state_ == 5) {
            if (position_.X > 1) {
                if (5 - harvest_dir_ != last_used_dir_ && strategy_surface_go_down(fuel_left_ - 5, position_, 5 - harvest_dir_)) {
                    return pop_plan(vs);
                }
                if (strategy_surface_go_down(fuel_left_ - 5, position_, harvest_dir_)) {
                    return pop_plan(vs);
                }
                if (strategy_surface_go_down(fuel_left_ - 5, position_, 5 - harvest_dir_)) {
                    return pop_plan(vs);
                }
                state_ = 6;
                continue;
            }
            last_used_dir_ = 0;
            return strategy_surface_explorer(vs);
        } else if (state_ == 6) {
            if (position_ == surface_pos_.back()) {
                surface_pos_.pop_back();
                continue;
            }
            if (surface_pos_.empty()) {
                state_ = 5;
                continue;
            }
            return strategy_shortest_path(vs, surface_pos_.back());
        } else {
            // Whatever.
            return strategy_random(vs);
        }

LD>/* Coroutine mechanics for the sillier bits of the code */
LD>#define crBegin1    static int crLine = 0;
LD>#define crBegin2    switch(crLine) { case 0:;
LD>#define crBegin        crBegin1; crBegin2;
LD>#define crFinish(z)    } crLine = 0; return (z)
LD>#define crFinishV    } crLine = 0; return
LD>#define crReturn(z)    \
LD>    do {\
LD>        crLine=__LINE__; return (z); case __LINE__:;\
LD>    } while (0)
LD>#define crReturnV    \
LD>    do {\
LD>        crLine=__LINE__; return; case __LINE__:;\
LD>    } while (0)
LD>#define crStop(z)    do{ crLine = 0; return (z); }while(0)
LD>#define crStopV        do{ crLine = 0; return; }while(0)
LD>#define crWaitUntil(c)    do { crReturn(0); } while (!(c))
LD>#define crWaitUntilV(c)    do { crReturnV; } while (!(c))
LD>

#define COROUTINE static int _coroutineState = 0; switch(_coroutineState) case 0:
#define YIELD(_expr_) do { _coroutineState = __LINE__; return (_expr_); case __LINE__:; } while(0)

char nextMove() // this was from a TCMM
{
    COROUTINE
    {
        while(1)
        {
            assert(depth == 0);
 
            while(condition1)
            {
                YIELD('R');
            }
 
            YIELD('D');
 
            while(condition2)
            {
                YIELD('R');
            }
 
            YIELD('U');
        }
    }
}

for(i = 0; i < 42; ++i)
{
    YIELD('D');
}

Открытость содержания (идеи, технологии) ныне подменяется открытостью
формы (исходный текст). И это подается чуть ли не как идеал.

И вот уже известный специалист в области программирования, Диомидис
Спинеллис, пишет обстоятельную книгу “Анализ программного кода на
примере проектов Open Source” (2004), где раскрывает подходы к тому, как
извлекать технические решения и используемые методы, ковыряясь в чужом
исходном тексте. Потрясающе! Получается, что исходные тексты — это
одолжение, которое делают его разработчики, не удосужившиеся подготовить
детальную проектную документацию (некогда, лень, жалко) и при этом не
чурающиеся получать деньги за передачу формы, утаив содержание.

Как вы думаете, когда реально разобраться в чужом исходном тексте при
полном отсутствии проектной документации? Правильно, когда
наукоемкость такого продукта близка к нулю и когда вы хорошо
знаете язык, на котором написан продукт.

Всегда хорошо иметь исходники, но проблема состоит в том, что
зачастую их недостаточно. Чтобы понять некоторую нетривиальную
программу, обычно требуется дополнительная документация. Эта потребность
растёт экспоненциально с ростом объема кода. Анализ текстов программ,
направленный на восстановление первоначальных проектных решений,
принятых разработчиками, и понимание программ являются двумя важными
ветвями технологии программирования, существование которых неразрывно
связано с недостаточностью исходных текстов для понимания программ. В
качестве примера попробуйте понять структуру нетривиального компилятора
при условии, что вы не располагаете определением того языка, который им
компилируется”.

queue<char> m_vNextMoves;
char GetCharFromNextMoves()
{
    char chRet = -1;
    if (m_vNextMoves.size())
    {
        chRet = m_vNextMoves.front();
        m_vNextMoves.pop();
    }
    return chRet;
}
public:
char move(int iField)
{
    if (m_vNextMoves.size())
         return GetCharFromNextMoves();
..........
    for (int i = 0; i < 42; i++)
    {
        m_vNextMoves.push('D');
    }
    return (GetCharFromNextMoves());
............
}

s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];

if (uc == 0x17) goto endhdr_2;

#define GET_BITS(lll,vvv,nnn)                     \
   case lll: s->state = lll;                      \
   while (True) {                                 \
      if (s->bsLive >= nnn) {                     \
         UInt32 v;                                \
         v = (s->bsBuff >>                        \
             (s->bsLive-nnn)) & ((1 << nnn)-1);   \
         s->bsLive -= nnn;                        \
         vvv = v;                                 \
         break;                                   \
      }                                           \
      if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
      s->bsBuff                                   \
         = (s->bsBuff << 8) |                     \
           ((UInt32)                              \
              (*((UChar*)(s->strm->next_in))));   \
      s->bsLive += 8;                             \
      s->strm->next_in++;                         \
      s->strm->avail_in--;                        \
      s->strm->total_in_lo32++;                   \
      if (s->strm->total_in_lo32 == 0)            \
         s->strm->total_in_hi32++;                \
   }

#define GET_UCHAR(lll,uuu)                        \
   GET_BITS(lll,uuu,8)

#define GET_BIT(lll,uuu)                          \
   GET_BITS(lll,uuu,1)

/*---------------------------------------------------*/
#define GET_MTF_VAL(label1,label2,lval)           \
{                                                 \
   if (groupPos == 0) {                           \
      groupNo++;                                  \
      if (groupNo >= nSelectors)                  \
         RETURN(BZ_DATA_ERROR);                   \
      groupPos = BZ_G_SIZE;                       \
      gSel = s->selector[groupNo];                \
      gMinlen = s->minLens[gSel];                 \
      gLimit = &(s->limit[gSel][0]);              \
      gPerm = &(s->perm[gSel][0]);                \
      gBase = &(s->base[gSel][0]);                \
   }                                              \
   groupPos--;                                    \
   zn = gMinlen;                                  \
   GET_BITS(label1, zvec, zn);                    \
   while (1) {                                    \
      if (zn > 20 /* the longest code */)         \
         RETURN(BZ_DATA_ERROR);                   \
      if (zvec <= gLimit[zn]) break;              \
      zn++;                                       \
      GET_BIT(label2, zj);                        \
      zvec = (zvec << 1) | zj;                    \
   };                                             \
   if (zvec - gBase[zn] < 0                       \
       || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
      RETURN(BZ_DATA_ERROR);                      \
   lval = gPerm[zvec - gBase[zn]];                \


Int32 BZ2_decompress ( DState* s )
{
   UChar      uc;
   Int32      retVal;
   Int32      minLen, maxLen;
   bz_stream* strm = s->strm;

   /* stuff that needs to be saved/restored */
   Int32  i;
   Int32  j;
   Int32  t;
   Int32  alphaSize;
   Int32  nGroups;
   Int32  nSelectors;
   Int32  EOB;
   Int32  groupNo;
   Int32  groupPos;
   Int32  nextSym;
   Int32  nblockMAX;
   Int32  nblock;
   Int32  es;
   Int32  N;
   Int32  curr;
   Int32  zt;
   Int32  zn; 
   Int32  zvec;
   Int32  zj;
   Int32  gSel;
   Int32  gMinlen;
   Int32* gLimit;
   Int32* gBase;
   Int32* gPerm;

   if (s->state == BZ_X_MAGIC_1) {
      /*initialise the save area*/
      s->save_i           = 0;
      s->save_j           = 0;
      s->save_t           = 0;
      s->save_alphaSize   = 0;
      s->save_nGroups     = 0;
      s->save_nSelectors  = 0;
      s->save_EOB         = 0;
      s->save_groupNo     = 0;
      s->save_groupPos    = 0;
      s->save_nextSym     = 0;
      s->save_nblockMAX   = 0;
      s->save_nblock      = 0;
      s->save_es          = 0;
      s->save_N           = 0;
      s->save_curr        = 0;
      s->save_zt          = 0;
      s->save_zn          = 0;
      s->save_zvec        = 0;
      s->save_zj          = 0;
      s->save_gSel        = 0;
      s->save_gMinlen     = 0;
      s->save_gLimit      = NULL;
      s->save_gBase       = NULL;
      s->save_gPerm       = NULL;
   }

   /*restore from the save area*/
   i           = s->save_i;
   j           = s->save_j;
   t           = s->save_t;
   alphaSize   = s->save_alphaSize;
   nGroups     = s->save_nGroups;
   nSelectors  = s->save_nSelectors;
   EOB         = s->save_EOB;
   groupNo     = s->save_groupNo;
   groupPos    = s->save_groupPos;
   nextSym     = s->save_nextSym;
   nblockMAX   = s->save_nblockMAX;
   nblock      = s->save_nblock;
   es          = s->save_es;
   N           = s->save_N;
   curr        = s->save_curr;
   zt          = s->save_zt;
   zn          = s->save_zn; 
   zvec        = s->save_zvec;
   zj          = s->save_zj;
   gSel        = s->save_gSel;
   gMinlen     = s->save_gMinlen;
   gLimit      = s->save_gLimit;
   gBase       = s->save_gBase;
   gPerm       = s->save_gPerm;

   retVal = BZ_OK;

   switch (s->state) {

      GET_UCHAR(BZ_X_MAGIC_1, uc);
      if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_UCHAR(BZ_X_MAGIC_2, uc);
      if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_UCHAR(BZ_X_MAGIC_3, uc)
      if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);

      GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
      if (s->blockSize100k < (BZ_HDR_0 + 1) || 
          s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
      s->blockSize100k -= BZ_HDR_0;

      if (s->smallDecompress) {
         s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
         s->ll4  = BZALLOC( 
                      ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) 
                   );
         if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
      } else {
         s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
         if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
      }

      GET_UCHAR(BZ_X_BLKHDR_1, uc);

      if (uc == 0x17) goto endhdr_2;
      if (uc != 0x31) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_2, uc);
      if (uc != 0x41) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_3, uc);
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_4, uc);
      if (uc != 0x26) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_5, uc);
      if (uc != 0x53) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_BLKHDR_6, uc);
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);

      s->currBlockNo++;
      if (s->verbosity >= 2)
         VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
 
      s->storedBlockCRC = 0;
      GET_UCHAR(BZ_X_BCRC_1, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_2, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_3, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_BCRC_4, uc);
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);

      GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);

      s->origPtr = 0;
      GET_UCHAR(BZ_X_ORIGPTR_1, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
      GET_UCHAR(BZ_X_ORIGPTR_2, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
      GET_UCHAR(BZ_X_ORIGPTR_3, uc);
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);

      if (s->origPtr < 0)
         RETURN(BZ_DATA_ERROR);
      if (s->origPtr > 10 + 100000*s->blockSize100k) 
         RETURN(BZ_DATA_ERROR);

      /*--- Receive the mapping table ---*/
      for (i = 0; i < 16; i++) {
         GET_BIT(BZ_X_MAPPING_1, uc);
         if (uc == 1) 
            s->inUse16[i] = True; else 
            s->inUse16[i] = False;
      }

      for (i = 0; i < 256; i++) s->inUse[i] = False;

      for (i = 0; i < 16; i++)
         if (s->inUse16[i])
            for (j = 0; j < 16; j++) {
               GET_BIT(BZ_X_MAPPING_2, uc);
               if (uc == 1) s->inUse[i * 16 + j] = True;
            }
      makeMaps_d ( s );
      if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
      alphaSize = s->nInUse+2;

      /*--- Now the selectors ---*/
      GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
      if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
      GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
      if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
      for (i = 0; i < nSelectors; i++) {
         j = 0;
         while (True) {
            GET_BIT(BZ_X_SELECTOR_3, uc);
            if (uc == 0) break;
            j++;
            if (j >= nGroups) RETURN(BZ_DATA_ERROR);
         }
         s->selectorMtf[i] = j;
      }

      /*--- Undo the MTF values for the selectors. ---*/
      {
         UChar pos[BZ_N_GROUPS], tmp, v;
         for (v = 0; v < nGroups; v++) pos[v] = v;
   
         for (i = 0; i < nSelectors; i++) {
            v = s->selectorMtf[i];
            tmp = pos[v];
            while (v > 0) { pos[v] = pos[v-1]; v--; }
            pos[0] = tmp;
            s->selector[i] = tmp;
         }
      }

      /*--- Now the coding tables ---*/
      for (t = 0; t < nGroups; t++) {
         GET_BITS(BZ_X_CODING_1, curr, 5);
         for (i = 0; i < alphaSize; i++) {
            while (True) {
               if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
               GET_BIT(BZ_X_CODING_2, uc);
               if (uc == 0) break;
               GET_BIT(BZ_X_CODING_3, uc);
               if (uc == 0) curr++; else curr--;
            }
            s->len[t][i] = curr;
         }
      }

      /*--- Create the Huffman decoding tables ---*/
      for (t = 0; t < nGroups; t++) {
         minLen = 32;
         maxLen = 0;
         for (i = 0; i < alphaSize; i++) {
            if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
            if (s->len[t][i] < minLen) minLen = s->len[t][i];
         }
         BZ2_hbCreateDecodeTables ( 
            &(s->limit[t][0]), 
            &(s->base[t][0]), 
            &(s->perm[t][0]), 
            &(s->len[t][0]),
            minLen, maxLen, alphaSize
         );
         s->minLens[t] = minLen;
      }

      /*--- Now the MTF values ---*/

      EOB      = s->nInUse+1;
      nblockMAX = 100000 * s->blockSize100k;
      groupNo  = -1;
      groupPos = 0;

      for (i = 0; i <= 255; i++) s->unzftab[i] = 0;

      /*-- MTF init --*/
      {
         Int32 ii, jj, kk;
         kk = MTFA_SIZE-1;
         for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
            for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
               s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
               kk--;
            }
            s->mtfbase[ii] = kk + 1;
         }
      }
      /*-- end MTF init --*/

      nblock = 0;
      GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);

      while (True) {

         if (nextSym == EOB) break;

         if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {

            es = -1;
            N = 1;
            do {
               if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
               if (nextSym == BZ_RUNB) es = es + (1+1) * N;
               N = N * 2;
               GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
            }
               while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);

            es++;
            uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
            s->unzftab[uc] += es;

            if (s->smallDecompress)
               while (es > 0) {
                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
                  s->ll16[nblock] = (UInt16)uc;
                  nblock++;
                  es--;
               }
            else
               while (es > 0) {
                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
                  s->tt[nblock] = (UInt32)uc;
                  nblock++;
                  es--;
               };

            continue;

         } else {

            if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);

            /*-- uc = MTF ( nextSym-1 ) --*/
            {
               Int32 ii, jj, kk, pp, lno, off;
               UInt32 nn;
               nn = (UInt32)(nextSym - 1);

               if (nn < MTFL_SIZE) {
                  /* avoid general-case expense */
                  pp = s->mtfbase[0];
                  uc = s->mtfa[pp+nn];
                  while (nn > 3) {
                     Int32 z = pp+nn;
                     s->mtfa[(z)  ] = s->mtfa[(z)-1];
                     s->mtfa[(z)-1] = s->mtfa[(z)-2];
                     s->mtfa[(z)-2] = s->mtfa[(z)-3];
                     s->mtfa[(z)-3] = s->mtfa[(z)-4];
                     nn -= 4;
                  }
                  while (nn > 0) { 
                     s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; 
                  };
                  s->mtfa[pp] = uc;
               } else { 
                  /* general case */
                  lno = nn / MTFL_SIZE;
                  off = nn % MTFL_SIZE;
                  pp = s->mtfbase[lno] + off;
                  uc = s->mtfa[pp];
                  while (pp > s->mtfbase[lno]) { 
                     s->mtfa[pp] = s->mtfa[pp-1]; pp--; 
                  };
                  s->mtfbase[lno]++;
                  while (lno > 0) {
                     s->mtfbase[lno]--;
                     s->mtfa[s->mtfbase[lno]] 
                        = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
                     lno--;
                  }
                  s->mtfbase[0]--;
                  s->mtfa[s->mtfbase[0]] = uc;
                  if (s->mtfbase[0] == 0) {
                     kk = MTFA_SIZE-1;
                     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
                        for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
                           s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
                           kk--;
                        }
                        s->mtfbase[ii] = kk + 1;
                     }
                  }
               }
            }
            /*-- end uc = MTF ( nextSym-1 ) --*/

            s->unzftab[s->seqToUnseq[uc]]++;
            if (s->smallDecompress)
               s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
               s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
            nblock++;

            GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
            continue;
         }
      }

      /* Now we know what nblock is, we can do a better sanity
         check on s->origPtr.
      */
      if (s->origPtr < 0 || s->origPtr >= nblock)
         RETURN(BZ_DATA_ERROR);

      /*-- Set up cftab to facilitate generation of T^(-1) --*/
      s->cftab[0] = 0;
      for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
      for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
      for (i = 0; i <= 256; i++) {
         if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
            /* s->cftab[i] can legitimately be == nblock */
            RETURN(BZ_DATA_ERROR);
         }
      }

      s->state_out_len = 0;
      s->state_out_ch  = 0;
      BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
      s->state = BZ_X_OUTPUT;
      if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );

      if (s->smallDecompress) {

         /*-- Make a copy of cftab, used in generation of T --*/
         for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];

         /*-- compute the T vector --*/
         for (i = 0; i < nblock; i++) {
            uc = (UChar)(s->ll16[i]);
            SET_LL(i, s->cftabCopy[uc]);
            s->cftabCopy[uc]++;
         }

         /*-- Compute T^(-1) by pointer reversal on T --*/
         i = s->origPtr;
         j = GET_LL(i);
         do {
            Int32 tmp = GET_LL(j);
            SET_LL(j, i);
            i = j;
            j = tmp;
         }
            while (i != s->origPtr);

         s->tPos = s->origPtr;
         s->nblock_used = 0;
         if (s->blockRandomised) {
            BZ_RAND_INIT_MASK;
            BZ_GET_SMALL(s->k0); s->nblock_used++;
            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
         } else {
            BZ_GET_SMALL(s->k0); s->nblock_used++;
         }

      } else {

         /*-- compute the T^(-1) vector --*/
         for (i = 0; i < nblock; i++) {
            uc = (UChar)(s->tt[i] & 0xff);
            s->tt[s->cftab[uc]] |= (i << 8);
            s->cftab[uc]++;
         }

         s->tPos = s->tt[s->origPtr] >> 8;
         s->nblock_used = 0;
         if (s->blockRandomised) {
            BZ_RAND_INIT_MASK;
            BZ_GET_FAST(s->k0); s->nblock_used++;
            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
         } else {
            BZ_GET_FAST(s->k0); s->nblock_used++;
         }

      }

      RETURN(BZ_OK);



    endhdr_2:

      GET_UCHAR(BZ_X_ENDHDR_2, uc);
      if (uc != 0x72) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_3, uc);
      if (uc != 0x45) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_4, uc);
      if (uc != 0x38) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_5, uc);
      if (uc != 0x50) RETURN(BZ_DATA_ERROR);
      GET_UCHAR(BZ_X_ENDHDR_6, uc);
      if (uc != 0x90) RETURN(BZ_DATA_ERROR);

      s->storedCombinedCRC = 0;
      GET_UCHAR(BZ_X_CCRC_1, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_2, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_3, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
      GET_UCHAR(BZ_X_CCRC_4, uc);
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);

      s->state = BZ_X_IDLE;
      RETURN(BZ_STREAM_END);

      default: AssertH ( False, 4001 );
   }

   AssertH ( False, 4002 );

   save_state_and_return:

   s->save_i           = i;
   s->save_j           = j;
   s->save_t           = t;
   s->save_alphaSize   = alphaSize;
   s->save_nGroups     = nGroups;
   s->save_nSelectors  = nSelectors;
   s->save_EOB         = EOB;
   s->save_groupNo     = groupNo;
   s->save_groupPos    = groupPos;
   s->save_nextSym     = nextSym;
   s->save_nblockMAX   = nblockMAX;
   s->save_nblock      = nblock;
   s->save_es          = es;
   s->save_N           = N;
   s->save_curr        = curr;
   s->save_zt          = zt;
   s->save_zn          = zn;
   s->save_zvec        = zvec;
   s->save_zj          = zj;
   s->save_gSel        = gSel;
   s->save_gMinlen     = gMinlen;
   s->save_gLimit      = gLimit;
   s->save_gBase       = gBase;
   s->save_gPerm       = gPerm;

   return retVal;   
}

С>>Ты знаком со всем open-source кодом?

/* Currently all meta surfaces do have a size which should be passed
 * in as the maximum size of any target surface against which the
 * meta-surface will ever be replayed.
 *
 * XXX: The naming of "pixels" in the size here is a misnomer. It's
 * actually a size in whatever device-space units are desired (again,
 * according to the intended replay target). This should likely also
 * be changed to use doubles not ints.
 */
cairo_surface_t *
_cairo_meta_surface_create (cairo_content_t    content,
                int            width_pixels,
                int            height_pixels)
{
    cairo_meta_surface_t *meta;

    meta = malloc (sizeof (cairo_meta_surface_t));
    if (meta == NULL)
    return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));

    _cairo_surface_init (&meta->base, &cairo_meta_surface_backend,
             content);

    meta->content = content;
    meta->width_pixels = width_pixels;
    meta->height_pixels = height_pixels;

    _cairo_array_init (&meta->commands, sizeof (cairo_command_t *));
    meta->commands_owner = NULL;

    meta->is_clipped = FALSE;
    meta->replay_start_idx = 0;

    return &meta->base;
}

as_value
AsBroadcaster::removeListener_method(const fn_call& fn)
{
    boost::intrusive_ptr<as_object> obj = fn.this_ptr;

    as_value listenersValue;

    // TODO: test if we're supposed to crawl the target object's 
    //       inheritance chain in case it's own property _listeners 
    //       has been deleted while another one is found in any base
    //       class.
    if (!obj->get_member(NSV::PROP_uLISTENERS, &listenersValue) )
    {
        IF_VERBOSE_ASCODING_ERRORS(
        log_aserror(_("%p.addListener(%s): this object has no _listeners member"),
            (void*)fn.this_ptr.get(),
            fn.dump_args().c_str());
        );
        return as_value(false); // TODO: check this
    }

    // assuming no automatic primitive-to-object cast will return an array...
    if ( ! listenersValue.is_object() )
    {
        IF_VERBOSE_ASCODING_ERRORS(
        log_aserror(_("%p.addListener(%s): this object's _listener isn't an object: %s"),
            (void*)fn.this_ptr.get(),
            fn.dump_args().c_str(), listenersValue.to_debug_string().c_str());
        );
        return as_value(false); // TODO: check this
    }

    boost::intrusive_ptr<as_object> listenersObj = listenersValue.to_object();
    assert(listenersObj);

    as_value listenerToRemove; assert(listenerToRemove.is_undefined());
    if ( fn.nargs ) listenerToRemove = fn.arg(0);

    boost::intrusive_ptr<as_array_object> listeners = boost::dynamic_pointer_cast<as_array_object>(listenersObj);
    if ( ! listeners )
    {
        IF_VERBOSE_ASCODING_ERRORS(
        log_aserror(_("%p.addListener(%s): this object's _listener isn't an array: %s"),
            (void*)fn.this_ptr.get(),
            fn.dump_args().c_str(), listenersValue.to_debug_string().c_str());
        );

        // TODO: implement brute force scan of pseudo-array
        unsigned int length = listenersObj->getMember(NSV::PROP_LENGTH).to_int();
        for (unsigned int i=0; i<length; ++i)
        {
            as_value iVal(i);
            std::string n = iVal.to_string();
            as_value v = listenersObj->getMember(VM::get().getStringTable().find(n));
            if ( v.equals(listenerToRemove) )
            {
                listenersObj->callMethod(NSV::PROP_SPLICE, iVal, as_value(1));
                return as_value(true); 
            }
        }

        return as_value(false); // TODO: check this
    }
    else
    {
        // Remove the first listener matching the new value
        // See http://www.senocular.com/flash/tutorials/listenersasbroadcaster/?page=2
        // TODO: make this call as a normal (don't want to rely on _listeners type at all)
        bool removed = listeners->removeFirst(listenerToRemove);
        return as_value(removed);
    }

}

/**
 * job_unblock:
 * @job: job that is blocking,
 * @failed: mark events as failed.
 *
 * This function unblocks any events blocking on @job; it is called when the
 * job reaches a rest state (waiting for all, running for services), when a
 * new command is received or when the job fails.
 *
 * If @failed is TRUE then the events that are blocking will be marked as
 * failed.
 **/
void
job_unblock (Job *job,
         int  failed)
{
    nih_assert (job != NULL);

    if (job->blocking) {
        NIH_LIST_FOREACH (job->blocking, iter) {
            NihListEntry *entry = (NihListEntry *)iter;
            Event        *event = (Event *)entry->data;

            nih_assert (event != NULL);

            if (failed)
                event->failed = TRUE;

            event_unblock (event);
        }

        nih_free (job->blocking);
        job->blocking = NULL;
    }
}

#define PP_STR(x) PP_STR_(x)
#define PP_STR_(x) #x

int main()
{
  printf("here we are: file " __FILE__ ", line " PP_STR(__LINE__) "\n");
}

unsigned long dtls1_output_cert_chain(SSL *s, X509 *x)
    {
    unsigned char *p;
    int n,i;
    unsigned long l= 3 + DTLS1_HM_HEADER_LENGTH;
    BUF_MEM *buf;