E>#define HEXC2INT(c) ((c >= 'A' ? ( c - 'A' ) : ( c - '0' )))
E>

inline uint8_t hex2bin(unsigned char h, unsigned char l)
{
    h |= 0x20;
    h -= 0x30;
    h -= -(h > 9) & 0x27;
    l |= 0x20;
    l -= 0x30;
    l -= -(l > 9) & 0x27;
    return h << 4 | l;
}

std::ofstream counter_file( "counter.dat", std::ios::out | std::ios::binary );
counter_file.write( &counter, sizeof counter ); // Ага, записали на MIPS-ах, прочитали на x86 :)

std::ofstream counter_file( "counter.dat" );
counter_file << counter; // A уже пофигу MIPS-ы, SPARC-и, x86 и прочая дребедень.

Кё>Я думаю о регулярных выражениях, а также водке и бабах

Q: what's the first thing that comes to mind when you hear each of these chord types?

A: When I hear major chords, I think about titties, but when I hear minor or dominant chords, I think about titties, but when I see titties, I don't think about chords.

E>// Выделить из запроса все пары <name=value>.
E>static void
E>extract_all_pairs(
E>    const char * query_string,
E>    param_map_t & result )
E>{
E>    size_t start = 0, cur = 0;

E>    // Извлекаем имя параметра.
E>    while( query_string[ cur ] ) {
E>        std::string param_name;
E>        std::string param_value;

E>        if( '=' == query_string[ cur ] ) {
E>            // Имя параметра закончилось.
E>            // Имя параметра должно содержать хотя бы один символ.
E>            if( start != cur ) {
E>                param_name.assign( &query_string[ start ],
E>                    cur - start );
E>                // Пропускаем '='
E>                ++cur;
E>                start = cur;
E>                // Извлекаем значение параметра.
E>                while( query_string[ cur ] ) {
E>                    if( '&' == query_string[ cur ] )
E>                        break;
E>                    ++cur;
E>                }
E>                // Значение параметра закончилось.
E>                // Значение может быть пустым.
E>                if( start != cur ) {
E>                    param_value.assign( &query_string[ start ],
E>                        cur - start );
E>                }

E>                // Для пропуска '&'
E>                if( '&' == query_string[ cur ] )
E>                    start = cur + 1;

E>                // Извлекли и имя, и значение параметра.
E>                // Изменим кодировку.
E>                url_decode( param_name );
E>                url_decode( param_value );

E>                result.insert( param_map_t::value_type(
E>                    param_name, param_value ) );
E>            }
E>        }
E>        ++cur;
E>    }

E>}

E>

E>Может и здесь какие-нибудь баги найдут.

//выделяет из запроса все пары <name=value>
static void extractAllPairs(const char* query_string, param_map_t* result)
{
    std::istringstream is(query_string);
    std::string paramName;//имя параметра
    std::string paramValue;//имя значения
    while(!is.eof())
    {
        std::getline(is, paramName,'=');
        std::getline(is, paramValue,'&');
        if( !paramName.empty() )
        {
            url_decode( paramName );
            url_decode( paramValue );
            result->insert( param_map_t::value_type(
                paramName, paramValue ) );
        }
    }
}

void CGIParamsBase::Parse(const char *cstr, int iLen)
{
    //-----------------------------------------
    char* pNameBegin = const_cast<char*>(cstr);
    char* pNameEnd   = NULL;

    if (*pNameBegin == '&') pNameBegin++;

    pNameEnd = strtok(pNameBegin, "=&");

    if(pNameEnd == NULL) return;

    //-----------------------------------------
    char* pValueBegin = pNameEnd + 1;
    char* pValueEnd   = NULL;
    
    switch(*pNameEnd)
    {
    case '=':
        pValueEnd = strtok(pValueBegin, "&");
        if (pNameEnd - pNameBegin > 2)
                {
                    //.......................
                    ProcessParam(pNameBegin, pNameEnd - pNameBegin, pConverted, iNewLen);
        }
        
        if(pValueEnd == NULL) break;

    case '&':
        Parse(pNameEnd, strlen(pNameEnd));
    }
    
    return;
}

Tom>void CGIParamsBase::Parse(const char *cstr, int iLen)
Tom>{
Tom>    char *str = const_cast<char*>(cstr);
Tom>    char *pNameBegin = str, *pNameEnd, *pValueBegin, *pValueEnd;
Tom>    while (pNameBegin - str < iLen)
Tom>    {
Tom>        if (*pNameBegin == '&')
Tom>            pNameBegin++;
Tom>        pNameEnd = pNameBegin;
Tom>        while (pNameEnd - str < iLen && *pNameEnd != '=' && *pNameEnd != '&')
Tom>            pNameEnd++;
Tom>        if (pNameEnd - str == iLen)
Tom>            break;
Tom>        if (*pNameEnd == '&')
Tom>        {
Tom>            pNameBegin = pNameEnd + 1;
Tom>            continue;
Tom>        }

Tom>        pValueEnd = pValueBegin = pNameEnd + 1;
Tom>        while (pValueEnd - str < iLen && *pValueEnd != '&')
Tom>            pValueEnd++;

Tom>        if (pNameEnd - pNameBegin > 2)
Tom>        {
Tom>            int iSrcLen = pValueEnd - pValueBegin;
Tom>            int iNewLen = 0;
Tom>            const char *pSrc = pValueBegin;
Tom>            char *pConverted = (char *)_alloca(iSrcLen);
Tom>            char *pDest = pConverted;
Tom>            for (; iSrcLen-- > 0; iNewLen++, pDest++, pSrc++)
Tom>            {
Tom>                if ((BYTE)*pSrc <= 0x1f || (BYTE)*pSrc >= 0x7f)
Tom>                    goto Cont;
Tom>                if (*pSrc == '+')
Tom>                    *pDest = ' ';
Tom>                else
Tom>                    if (*pSrc == '%')
Tom>                    {
Tom>                        *pDest = (char)(C2D(pSrc[1]) * 16 + C2D(pSrc[2]));
Tom>                        pSrc += 2;
Tom>                        iSrcLen -= 2;
Tom>                    }
Tom>                    else
Tom>                        *pDest = *pSrc;
Tom>            }
Tom>            ProcessParam(pNameBegin, pNameEnd - pNameBegin, pConverted, iNewLen);
Tom>        }
Tom>Cont:
Tom>        pNameBegin = pValueEnd;
Tom>    }
Tom>}
Tom>

> ME>inline uint8_t hex2bin(unsigned char h, unsigned char l)
> ME>{
> ME>    h |= 0x20;
> ME>    h -= 0x30;
> ME>    h -= -(h > 9) & 0x27;
> ME>    l |= 0x20;
> ME>    l -= 0x30;
> ME>    l -= -(l > 9) & 0x27;
> ME>    return h << 4 | l;
> ME>}
> ME>

> Интересно.

inline char* bin2hex(uint8_t b, char* p)
{
     unsigned char h = b >> 4;
     *p++ = '0' + h + (-(h > 9) & ('a' - '9' - 1));
     unsigned char l = b & 0xf;
     *p++ = '0' + l + (-(l > 9) & ('a' - '9' - 1));
     return p;
}

void CGIParamsBase::Parse(const char *cstr, int iLen)
{
    char *str = const_cast<char*>(cstr);
    char *pNameBegin = str, *pNameEnd, *pValueBegin, *pValueEnd;
    while (pNameBegin - str < iLen)
    {
        if (*pNameBegin == '&')
            pNameBegin++;
        pNameEnd = pNameBegin;
        while (pNameEnd - str < iLen && *pNameEnd != '=' && *pNameEnd != '&')
            pNameEnd++;
        if (pNameEnd - str == iLen)
            break;
        if (*pNameEnd == '&')
        {
            pNameBegin = pNameEnd + 1;
            continue;
        }

        pValueEnd = pValueBegin = pNameEnd + 1;
        while (pValueEnd - str < iLen && *pValueEnd != '&')
            pValueEnd++;

        if (pNameEnd - pNameBegin > 2)
        {
            int iSrcLen = pValueEnd - pValueBegin;
            int iNewLen = 0;
            const char *pSrc = pValueBegin;
            char *pConverted = (char *)_alloca(iSrcLen);
            char *pDest = pConverted;
            for (; iSrcLen-- > 0; iNewLen++, pDest++, pSrc++)
            {
                if ((BYTE)*pSrc <= 0x1f || (BYTE)*pSrc >= 0x7f)
                    goto Cont;
                if (*pSrc == '+')
                    *pDest = ' ';
                else
                    if (*pSrc == '%')
                    {
                        *pDest = (char)(C2D(pSrc[1]) * 16 + C2D(pSrc[2]));
                        pSrc += 2;
                        iSrcLen -= 2;
                    }
                    else
                        *pDest = *pSrc;
            }
            ProcessParam(pNameBegin, pNameEnd - pNameBegin, pConverted, iNewLen);
        }
Cont:
        pNameBegin = pValueEnd;
    }
}

S>>Ещё подумалось: возможно yacc/bizon справился бы лучше

//
// param_map_t
//

//! Словарь значений CGI-параметров.
typedef std::map< std::string, std::string >
    param_map_t;

#define HEXC2INT(c) ((c >= 'A' ? ( c - 'A' ) : ( c - '0' )))

// Преобразовать URL-кодировку в ASCII.
static void
url_decode( std::string & what )
{
    std::string::size_type i = 0;
    while( i != what.length() ) {
        char c = what[ i ];
        if( '+' == c )
            what.replace( i, 1, 1, ' ' );
        else if( '%' == c ) {
            // Расшифровать HEX представление.
            if( i + 2 < what.length() ) {
                char h1 = toupper( what[ i + 1 ] );
                char h2 = toupper( what[ i + 2 ] );
                if( isxdigit( h1 ) && isxdigit( h2 ) ) {
                    // Можно создавать ASCII представление.
                    char r = ( HEXC2INT( h1 ) << 4 ) |
                        HEXC2INT( h2 );
                    what.replace( i, 3, 1, r );
                    // Переменную i не изменяем, т.к. она
                    // указывает на замененный символ.
                }
            }
        }
        ++i;
    }
}

// Выделить из запроса все пары <name=value>.
static void
extract_all_pairs(
    const char * query_string,
    param_map_t & result )
{
    size_t start = 0, cur = 0;

    // Извлекаем имя параметра.
    while( query_string[ cur ] ) {
        std::string param_name;
        std::string param_value;

        if( '=' == query_string[ cur ] ) {
            // Имя параметра закончилось.
            // Имя параметра должно содержать хотя бы один символ.
            if( start != cur ) {
                param_name.assign( &query_string[ start ],
                    cur - start );
                // Пропускаем '='
                ++cur;
                start = cur;
                // Извлекаем значение параметра.
                while( query_string[ cur ] ) {
                    if( '&' == query_string[ cur ] )
                        break;
                    ++cur;
                }
                // Значение параметра закончилось.
                // Значение может быть пустым.
                if( start != cur ) {
                    param_value.assign( &query_string[ start ],
                        cur - start );
                }

                // Для пропуска '&'
                if( '&' == query_string[ cur ] )
                    start = cur + 1;

                // Извлекли и имя, и значение параметра.
                // Изменим кодировку.
                url_decode( param_name );
                url_decode( param_value );

                result.insert( param_map_t::value_type(
                    param_name, param_value ) );
            }
        }
        ++cur;
    }

}

//
// parse_query_string
//

/*
    Процедура разбора значения переменной среды QUERY_STRING
    на множество пар <имя параметра, значение параметра>.
*/
void
parse_query_string( param_map_t & result )
{
    const char * env_value = getenv( "QUERY_STRING" );
    if( env_value ) {
        // Можно осуществлять разбор.

        // Выделяем все пары значений.
        extract_all_pairs( env_value, result );
    }
}

void CGIParamsBase::Parse(const char *cstr, int iLen)
{
    //-----------------------------------------
    char* pNameBegin = const_cast<char*>(cstr);
    char* pNameEnd   = NULL;

    if (*pNameBegin == '&') pNameBegin++;

    pNameEnd = strtok(pNameBegin, "=&");

    if(pNameEnd == NULL) return;

    //-----------------------------------------
    char* pValueBegin = pNameEnd + 1;
    char* pValueEnd   = NULL;
    
    switch(*pNameEnd)
    {
    case '=':
        pValueEnd = strtok(pValueBegin, "&");
        if (pNameEnd - pNameBegin > 2)
                {
                    //.......................
                    ProcessParam(pNameBegin, pNameEnd - pNameBegin, pConverted, iNewLen);
        }
        
        if(pValueEnd == NULL) break; pNameEnd = pValueEnd + 1;

    case '&':
        Parse(pNameEnd, strlen(pNameEnd));
    }
    
    return;
}

        using namеspace boost::spirit;
        X = range_p('A', 'F') | range_p('0', '9');
        Char = ('%' >> (X >> X)[BIND(OnHexChar)] | (range_p((char)31, (char)127) - '=' - '&')[BIND(OnChar)]);
        NVPair =  ch_p('+')[BIN(OnPlusSpace)] | ((+Char)[BIND(OnValue)] >> '=' >>(+Char)[BIND(OnValue)])[BIND(OnNVPair)];
        CGI_Request = NVPair >> *( '&' >> NVPair );

//писал в браузере, подглядывая в MSDN, могут быть опечатки/баги.
BITMAPFILEHEADER bmp_file_header;
BITMAPINFOHEADER bmp_header;
fread(&bmp_file_header, 1, sizeof(bmp_file_header));
fread(&bmp_header, 1, sizeof(bmp_header));

assert(bmp_header.biBitCount == 24);
assert(bmp_header.biCompression == BI_RGB);
assert(bmp_header.biPlanes == 1);

std::vector<byte> image_data(bmp_header.biWidth*bmp_header.biHeight*3);
fread(&image_data[0], 1, image.size(), bmp_file);
//работаю с картинкой.

#pragma option push -a1 
struct FmtBlock
{
  uint16 compress_code; //1
  uint16 channel_num;
  int32 discr;
  int32 byte_per_sec;
  uint16 align;
  uint16 kvant_bits;
  //short extra;
};


struct WaveHead
{
  Label riff;
  int rifflen;
  Label wave;
  Label fmt;
  int fmtlen; //16
  FmtBlock fmtblock;
  int soundlen;
};

#pragma option pop

class Wave
{
  private:
    ....
  public:
    std::valarray<short> data;
    int len;
    int n_channels;
    //int bperkvant;
    int discr;
    ....
    void Save(char *filename);
};

void Wave::Save(char *filename)
{
  File wfile(filename, "wb");
  int bpr= 16; //bits per record
  FmtBlock fmt=
  {
    1,
    n_channels,
    discr,
    (bpr/8)*n_channels*discr,
    (bpr/8)*n_channels,
    bpr
  };
  uint32 data_size=len*n_channels*(bpr/8);
  uint32 riff_size=
    +data_size
    +4 //RIFF
    +4
    +4 //WAVE
    +4 //ftm
    +4
    +sizeof(fmt) //16
    +4 //data
    +4;
  wfile.Write("RIFF",4);
  wfile.Write(riff_size);
  wfile.Write("WAVE",4);
  wfile.Write("fmt ",4);
  uint32 fmt_size=sizeof(fmt);
  wfile.Write(fmt_size);
  wfile.Write(fmt);
  wfile.Write("data", 4);
  wfile.Write(data_size);
  wfile.Write(&data[0], len*n_channels);
}