Subversion Repositories openrisc_me

//{{{  Banner                                                   
 
//============================================================================
//
//      cdlmisc.cxx
//
//      Implementation of the various CDL utility member functions.
//
//============================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// ----------------------------------------------------------------------------
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
//
// This file is part of the eCos host tools.
//
// This program is free software; you can redistribute it and/or modify it 
// under the terms of the GNU General Public License as published by the Free 
// Software Foundation; either version 2 of the License, or (at your option) 
// any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT 
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
// more details.
// 
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// ----------------------------------------------------------------------------
//                                                                          
//####COPYRIGHTEND####
//============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):   bartv
// Contact(s):  bartv
// Date:        1998/03/04
// Version:     0.01
//
//####DESCRIPTIONEND####
//============================================================================
 
//}}}
//{{{  #include's                                               
 
// ----------------------------------------------------------------------------
#include "cdlconfig.h"
 
// Get the infrastructure types, assertions, tracing and similar
// facilities.
#include <cyg/infra/cyg_ass.h>
#include <cyg/infra/cyg_trac.h>
 
// <cdlcore.hxx> defines everything implemented in this module.
// It implicitly supplies <string>, <vector> and <map> because
// the class definitions rely on these headers.
#include <cdlcore.hxx>
 
// For access to the isdigit(), isupper(), tolower(), ... functions
#include <cctype>
 
// For access to sprintf(), specifically double to string conversions.
#include <cstdio>
 
// For access to strtod()
#include <cstdlib>
 
// strtod() involves errno...
#include <cerrno>
 
// For access to fmod()
#include <cmath>
 
// For access to DBL_DIG
#include <cfloat>
 
//}}}
 
//{{{  Cdl::is_valid_xxx()                                      
 
// ---------------------------------------------------------------------------
 
bool
Cdl::is_valid_value_flavor(CdlValueFlavor data)
{
    bool result = false;
 
    switch(data) {
      case CdlValueFlavor_None     :
      case CdlValueFlavor_Bool     :
      case CdlValueFlavor_BoolData :
      case CdlValueFlavor_Data     :
        result = true;
        break;
 
      default:
        break;
    }
 
    return result;
}
 
bool
Cdl::is_valid_value_source(CdlValueSource data)
{
    bool result = false;
 
    switch(data) {
      case CdlValueSource_Default         :
      case CdlValueSource_User            :
      case CdlValueSource_Wizard          :
      case CdlValueSource_Inferred        :
        result = true;
        break;
 
      default:
        break;
    }
 
    return result;
}
 
// ----------------------------------------------------------------------------
// For now CDL names are restricted to what is acceptable to the C
// preprocessor. This may cause problems in future, e.g. i18n.
 
bool
Cdl::is_valid_cdl_name(const std::string& name)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::is_valid_cdl_name", "result %d");
 
    bool result = is_valid_c_preprocessor_symbol(name);
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
bool
Cdl::is_valid_c_preprocessor_symbol(const std::string& symbol)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::is_valid_c_preprocessor_symbol", "result %d");
 
    bool result = true;
    if ("" == symbol) {
        result = false;
    } else {
        // A valid preprocessor symbol should begin with either an underscore
        // or a letter. It should then be followed by some number of underscores,
        // letters, or digits.
        //
        // In some locales isalpha() may succeed for characters which are not
        // legal for C preprocessor symbols. Instead ASCII is assumed here.
        if (('_' != symbol[0]) &&
            !(('a' <= symbol[0]) && (symbol[0] <= 'z')) &&
            !(('A' <= symbol[0]) && (symbol[0] <= 'Z'))) {
 
            result = false;
        } else {
            for (unsigned int i = 1; i < symbol.size(); i++) {
                if (('_' != symbol[i]) &&
                    !(('a' <= symbol[i]) && (symbol[i] <= 'z')) &&
                    !(('A' <= symbol[i]) && (symbol[i] <= 'Z')) &&
                    !(('0' <= symbol[i]) && (symbol[i] <= '9'))) {
 
                    result = false;
                    break;
                }
            }
        }
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
//{{{  Cdl::xxx_to_yyy() - strings, ints, doubles, ...          
 
// ---------------------------------------------------------------------------
// Conversion routines between strings, integers, doubles, bools, ...
//
// Conversions to/from integers are complicated somewhat because the
// data type in question is cdl_int. In the initial implementation this
// is 64 bits. In the long term it will be arbitrary precision and
// the conversion routines will need to be reimplemented.
//
// ASCII rather than EBCDIC is assumed.
//
// Some of the routines may fail, e.g. string to integer conversions.
// Others are guaranteed to succeed. 
 
//{{{  string_to_integer()                      
 
// ----------------------------------------------------------------------------
bool
Cdl::string_to_integer(std::string data, cdl_int& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::string_to_integer", "success %d");
 
    bool negative       = false;
    bool seen_plus      = false;
    bool seen_minus     = false;
 
    // Life is a bit easier if I can check for '\0'
    const char* ptr           = data.c_str();
 
    // Not essential but harmless.
    while (isspace(*ptr))
        ptr++;
 
    if ('+' == *ptr) {
        if (seen_plus) {
            target = 0;
            CYG_REPORT_RETVAL(false);
            return false;
        }
        seen_plus = true;
        ptr++;
    }
 
    if ('-' == *ptr) {
        if (seen_minus) {
            target = 0;
            CYG_REPORT_RETVAL(false);
            return false;
        }
        seen_minus = true;
        negative = true;
        ptr++;
    }
 
    cdl_int acc = 0;
    if ('0' == *ptr) {
        // This happens sufficiently often to be worth a special case.
        if ('\0' == ptr[1]) {
            target = 0;
            CYG_REPORT_RETVAL(true);
            return true;
        }
        // Hex is always worth supporting. 
        if (('x' == ptr[1]) || ('X' == ptr[1])) {
            ptr++; ptr++;
            if (!isxdigit(*ptr)) {
                CYG_REPORT_RETVAL(false);
                return false;
            }
            while (isxdigit(*ptr)) {
                cdl_int new_acc = acc * 16;
                if (isdigit(*ptr)) {
                    new_acc += (*ptr - '0');
                } else if (('a' <= *ptr) && (*ptr <= 'f')) {
                    new_acc += (*ptr + 10 - 'a');
                } else if (('A' <= *ptr) && (*ptr <= 'F')) {
                    new_acc += (*ptr + 10 - 'A');
                } else {
                    CYG_FAIL("this platform's implementation of isxdigit() is broken");
                }
                if (new_acc < acc) {
                    CYG_REPORT_RETVAL(false);
                    return false;
                }
                acc = new_acc;
                ptr++;
            }
            if ('\0' != *ptr) {
                CYG_REPORT_RETVAL(false);
                return false;
            }
            if (negative) {
                cdl_int new_acc = 0 - acc;
                if (new_acc > 0) {
                    CYG_REPORT_RETVAL(false);
                    return false;
                } else {
                    acc = new_acc;
                }
            }
            target = acc;
            CYG_REPORT_RETVAL(true);
            return true;
        }
 
        // Octal? Oh well, might as well be complete.
        if (('0' <= ptr[1]) && (ptr[1] <= '7')) {
            ptr++;
            do {
                cdl_int new_acc = 8 * acc;
                new_acc += (*ptr - '0');
                if (new_acc < acc) {
                    CYG_REPORT_RETVAL(false);
                    return false;
                }
                acc = new_acc;
                ptr++;
            } while (('0' <= *ptr) && (*ptr <= '7'));
            if ('\0' != *ptr) {
                CYG_REPORT_RETVAL(false);
                return false;
            }
            if (negative) {
                cdl_int new_acc = 0 - acc;
                if (new_acc > 0) {
                    CYG_REPORT_RETVAL(false);
                    return false;
                }
                else {
                    acc = new_acc;
                }
            }
            target = acc;
            CYG_REPORT_RETVAL(true);
            return true;
        }
 
        // Drop through for the case of a decimal.
    }
 
    while(isdigit(*ptr)) {
        cdl_int new_acc = 10 * acc;
        new_acc += (*ptr - '0');
        if (new_acc < acc) {
            CYG_REPORT_RETVAL(false);
            return false;
        }
        acc = new_acc;
        ptr++;
    }
    if ('\0' != *ptr) {
        CYG_REPORT_RETVAL(false);
        return false;
    }
    if (negative) {
        cdl_int new_acc = 0 - acc;
        if (new_acc > 0) {
            CYG_REPORT_RETVAL(false);
            return false;
        } else {
            acc = new_acc;
        }
    }
    target = acc;
    CYG_REPORT_RETVAL(true);
    return true;
}
 
//}}}
//{{{  string_to_double()                       
 
// ----------------------------------------------------------------------------
// There is no point in doing this the hard way, just use standard
// library calls.
//
// There is an obvious question as to how much precision can get lost
// doing the conversion to a string. In practice this should not matter
// too much, since the expression handling code generally keeps the
// original double precision lying around to be re-used. However it may
// be desirable to keep the libcdl behaviour in synch with Tcl's
// tcl_precision variable.
 
bool
Cdl::string_to_double(std::string value, double& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::string_to_double", "success %d");
 
    bool        result      = true;
    const char* start_ptr   = value.c_str();
    char*       end_ptr;
    int         old_errno   = errno;
 
    errno                   = 0;
    double conv             = strtod(start_ptr, &end_ptr);
    if (0 != errno) {
        CYG_ASSERT(ERANGE == errno, "standard-compliant C library");
        result = false;
    } else if ('\0' != *end_ptr) {
        result = false;
    } else {
        target = conv;
        result = true;
    }
 
    errno = old_errno;
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
//{{{  string_to_bool()                         
 
// ----------------------------------------------------------------------------
// Conversions to and from bools. The only real issue here is exactly
// what strings should be accepted as synonyms for true and false.
// It is not actually clear that these functions are useful.
bool
Cdl::string_to_bool(std::string data, bool& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::string_to_bool", "success %d");
 
    // Arguably there should be a precondition ( "" != data )
    bool result = false;
 
    // What is truth ?
    if (( data == "1"   ) || (data == "true") ||
        ( data == "True") || (data == "TRUE") ) {
        result = true;
        target = true;
    } else if ((data == "0"    ) || (data == "false") ||
               (data == "False") || (data == "FALSE") ) {
        result = true;
        target = false;
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
 
//{{{  integer_to_string()                      
 
// ----------------------------------------------------------------------------
 
std::string
Cdl::integer_to_string(cdl_int value, CdlValueFormat format)
{
    std::string result;
    Cdl::integer_to_string(value, result, format);
    return result;
}
 
void
Cdl::integer_to_string(cdl_int value, std::string& target, CdlValueFormat format)
{
    CYG_REPORT_FUNCNAME("Cdl::integer_to_string");
    CYG_REPORT_FUNCARG2XV((long) value, format);
 
    // Optimise this special case.
    if (0 == value) {
        if (CdlValueFormat_Hex == format) {
            target = "0x0";
        } else {
            target = "0";
        }
        CYG_REPORT_RETVAL(true);
        return;
    }
 
    // A local buffer to construct partial strings. This avoids
    // unnecessary std::string reallocation.
    // 64 bits and three bits at a time for octal numbers gives 21 digits,
    // plus spares for the leading '0' and the terminator.
    char local_buf[24];
    char *local_ptr = &(local_buf[23]);
    *local_ptr-- = '\0';
 
    if (CdlValueFormat_Hex == format) {
 
        // Output the data as 0x... with either 8 or 16 digits,
        // depending on the size.
        int i;
        for (i = 0; i < 8; i++) {
            int tmp = (int) (value & 0x0F);
            value   = value >> 4;
            if (tmp < 10) {
                *local_ptr-- = '0' + tmp;
            } else {
                *local_ptr-- = 'A' + (tmp - 10);
            }
        }
        // Beware of right shifts that preserve the sign bit.
        {
            int tmp1 = (value & 0x0FFFF);
            int tmp2 = ((value >> 16) & 0x0FFFF);
            value    = (tmp2 << 16) + tmp1;
        }
        if (value != 0) {
            for (i = 0; i < 8; i++) {
                int tmp = (int) (value & 0x0F);
                value   = value >> 4;
                if (tmp < 10) {
                    *local_ptr-- = '0' + tmp;
                } else {
                    *local_ptr-- = 'A' + (tmp - 10);
                }
            }
        }
        *local_ptr-- = 'x';
        *local_ptr   = '0';
        target = std::string(local_ptr);
 
    } else if (CdlValueFormat_Octal == format) {
 
        // Simply output the data three bits at a time, do not worry about any
        // particular width restrictions. However it is necessary to worry
        // about masking.
        cdl_int mask = 0x1FFFFFFF;
        mask = (mask << 16) | 0x0FFFF;
        mask = (mask << 16) | 0x0FFFF;
 
        target = "";
        while (value > 0) {
            int tmp = value & 0x07;
            value   = (value >> 3) & mask;
            *local_ptr-- = '0' + tmp;
        }
        *local_ptr = '0';
        target = std::string(local_ptr);
 
    } else {
        // A simple decimal number      
        // Switch to positive arithmetic.
        bool negative = false;
        if (value < 0) {
            negative = true;
            value    = 0 - value;
            // Only MININT cannot be converted using the above line
            if (value < 0) {
                target = "-9223372036854775808";
                CYG_REPORT_RETVAL(true);
                return;
            }
        }
 
        while (value > 0) {
            int rem = (int) (value % 10);
            value   = value / 10;
            *local_ptr-- = '0' + rem;
        }
        if (negative) {
            *local_ptr-- = '-';
        }
        local_ptr++;
        target = std::string(local_ptr);
    }
 
    CYG_REPORT_RETURN();
    return;
}
 
//}}}
//{{{  double_to_string()                       
 
// ----------------------------------------------------------------------------
 
std::string
Cdl::double_to_string(double value, CdlValueFormat format)
{
    std::string result;
    Cdl::double_to_string(value, result, format);
    return result;
}
 
void
Cdl::double_to_string(double value, std::string& result, CdlValueFormat format)
{
    CYG_REPORT_FUNCNAME("Cdl::double_to_String");
 
    char buf[256];      // This should be plenty :-)
    sprintf(buf, "%.*G", DBL_DIG, value);
    result = buf;
 
    CYG_UNUSED_PARAM(CdlValueFormat, format);
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  bool_to_string()                         
 
// ----------------------------------------------------------------------------
// Should the string results be 1/0 or true/false? Not that
// it really matters. The testcase in cdl1.cxx expects 1/0.
std::string
Cdl::bool_to_string(bool value)
{
    std::string result;
    Cdl::bool_to_string(value, result);
    return result;
}
 
void
Cdl::bool_to_string(bool value, std::string& target)
{
    CYG_REPORT_FUNCNAME("Cdl::bool_to_string");
    CYG_REPORT_FUNCARG1( "value arg %ld", (long) value);
 
    if (value)
        target = "1";
    else
        target = "0";
 
    CYG_REPORT_RETURN();
}
 
//}}}
 
//{{{  integer_to_double()                      
 
// ----------------------------------------------------------------------------
// Currently integer to double cannot fail, although there may well be loss
// of accurary. Eventually cdl_int may be an arbitrary precision integer
// in which case conversion to double is not guaranteed.
double
Cdl::integer_to_double(cdl_int value)
{
    CYG_REPORT_FUNCNAME("Cdl::integer_to_double");
 
    double result = (double) value;
 
    CYG_REPORT_RETURN();
    return result;
}
 
void
Cdl::integer_to_double(cdl_int value, double& target)
{
    CYG_REPORT_FUNCNAME("Cdl::integer_to_double");
 
    target = (double) value;
 
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  double_to_integer()                      
 
// Conversion from double to integer is only allowed if there is no loss
// of data. modf() is useful here
bool
Cdl::double_to_integer(double value, cdl_int& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::double_to_integer", "result %d");
 
    bool   result = false;
 
    double integral;
    double frac;
 
    frac = modf(value, &integral);
    if (0.0 == frac) {
        // Looking good, but integral may still be too big.
        cdl_int tmp = (cdl_int) integral;
        if (tmp == value) {
            // No fraction, no loss of data, everything looking good
            target = tmp;
            result = true;
        }
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
 
//}}}
//{{{  Cdl::xxx_to_yyy() - CDL-specific data types              
 
// ----------------------------------------------------------------------------
// Conversions between strings and flavors.
 
static struct {
    char*               name;
    CdlValueFlavor      flavor;
} valid_flavors[] = {
    { "none",           CdlValueFlavor_None     },
    { "bool",           CdlValueFlavor_Bool     },
    { "booldata",       CdlValueFlavor_BoolData },
    { "data",           CdlValueFlavor_Data     },
    { 0,                CdlValueFlavor_Invalid  }
};
 
bool
Cdl::string_to_flavor(std::string name, CdlValueFlavor& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::string_to_flavor", "success %d");
 
    bool result = false;
 
    // First convert the argument to lower case. Arguably this is incorrect,
    // Tcl is a case-sensitive language, but the conversion is unlikely ever
    // to be harmfull.
    for (std::string::iterator str_i = name.begin(); str_i != name.end(); str_i++) {
        if (isupper(*str_i)) {
            *str_i = tolower(*str_i);
        }
    }
 
    // Now look for a match in the table.
    int match           = -1;
    int i;
    const char* c_str   = name.c_str();
    int len             = strlen(c_str);
 
    for (i = 0; 0 != valid_flavors[i].name; i++) {
        if (0 == strncmp(c_str, valid_flavors[i].name, len)) {
            // Check for an ambiguous string match.
            // This cannot actually happen with the current flavor names.
            if ( -1 != match) {
                break;
            }
            match = i;
        }
 
    }
    if (-1 != match) {
        target = valid_flavors[match].flavor;
        result = true;
    }
    CYG_REPORT_RETVAL(result);
    return result;
}
 
bool
Cdl::flavor_to_string(CdlValueFlavor flavor, std::string& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::flavor_to_string", "success %d");
 
    bool result = false;
 
    for (int i = 0; 0 != valid_flavors[i].name; i++) {
        if (flavor == valid_flavors[i].flavor) {
            target = valid_flavors[i].name;
            result = true;
            break;
        }
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
// ----------------------------------------------------------------------------
// Similar support for value sources.
 
static struct {
    char*               name;
    CdlValueSource      source;
} valid_sources[] = {
    { "default",        CdlValueSource_Default  },
    { "inferred",       CdlValueSource_Inferred },
    { "wizard",         CdlValueSource_Wizard   },
    { "user",           CdlValueSource_User     },
    { 0,                CdlValueSource_Invalid  }
};
 
bool
Cdl::string_to_source(std::string name, CdlValueSource& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::string_to_source", "success %d");
 
    bool result = false;
 
    // First convert the argument to lower case. Arguably this is incorrect,
    // Tcl is a case-sensitive language, but the conversion is unlikely ever
    // to be harmfull.
    for (std::string::iterator str_i = name.begin(); str_i != name.end(); str_i++) {
        if (isupper(*str_i)) {
            *str_i = tolower(*str_i);
        }
    }
 
    // Now look for a match in the table.
    int match           = -1;
    int i;
    const char* c_str   = name.c_str();
    int len             = strlen(c_str);
 
    for (i = 0; 0 != valid_sources[i].name; i++) {
        if (0 == strncmp(c_str, valid_sources[i].name, len)) {
            // Check for an ambiguous string match.
            // This cannot actually happen with the current source names.
            if ( -1 != match) {
                break;
            }
            match = i;
        }
 
    }
    if (-1 != match) {
        target = valid_sources[match].source;
        result = true;
    }
    CYG_REPORT_RETVAL(result);
    return result;
}
 
bool
Cdl::source_to_string(CdlValueSource source, std::string& target)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::source_to_string", "success %d");
 
    bool result = false;
 
    for (int i = 0; 0 != valid_sources[i].name; i++) {
        if (source == valid_sources[i].source) {
            target = valid_sources[i].name;
            result = true;
            break;
        }
    }
 
    CYG_REPORT_RETVAL(result);
    return result;
}
 
//}}}
//{{{  Cdl::get_library_version()                               
 
// ----------------------------------------------------------------------------
// The version of the library actually lives inside configure.in. It gets
// exported into cdlconfig.h
std::string
Cdl::get_library_version(void)
{
    return std::string(CYGNUM_LIBCDL_VERSION);
}
 
//}}}
//{{{  Cdl::set_interactive()                                   
 
// ----------------------------------------------------------------------------
// Some CDL scripts and some bits of the library may want to adapt depending
// on whether or not the application is running fully interactively or in
// batch mode. The primary distinction is that a batch program should never
// attempt to obtain user input, whether via Tk widgets or by other means.
 
bool Cdl::interactive   = false;
 
void
Cdl::set_interactive(bool value)
{
    CYG_REPORT_FUNCNAME("Cdl::set_interactive");
    CYG_REPORT_FUNCARG1D(value);
 
    interactive = value;
}
 
bool
Cdl::is_interactive(void)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::is_interactive", "interactive %d");
    CYG_REPORT_RETVAL(interactive);
    return interactive;
}
 
//}}}
//{{{  version support()                                        
 
// ----------------------------------------------------------------------------
// Packages may need to impose constraints on which versions of other
// packages they can coexist with. This requires some way of achieving
// a partial ordering of version numbers. Unfortunately there are many
// different ways of specifying a version number, and we cannot impose
// a single model on all third party package developers. Instead this
// routine performs some semi-intelligent comparisons of two version
// strings which should work in the vast majority of cases.
//
// The return value is as per strcmp(), -1 if the first entry is
// smaller (i.e. the more recent and hence hopefully the first in
// a list), +1 if the second entry is smaller, 0 if the two are
// identical.
//
// There is a big ambiguity between "derived" versions and "experimental"
// versions. Something like v0.3beta is experimental, i.e. it is older
// than the full release v0.3. On the other hand v0.3.p1 is a patched
// version of v0.3 and hence newer. This code uses the presence or otherwise
// of a separator to decide between the two cases.
 
// A utility routine which checks whether or not a character counts
// as a separator. Currently the characters . - and _ are all accepted
// as field separators.
//
// Arguably - should not be accepted as a separator. Instead if it preceeds
// a digit it could be interpreted as part of a prerelease number.
 
static bool
is_separator(int ch)
{
    return ('.' == ch) || ('-' == ch) || ('_' == ch);
}
 
int
Cdl::compare_versions(std::string arg1, std::string arg2)
{
    CYG_REPORT_FUNCNAMETYPE("Cdl::compare_versions", "result %d");
 
    if (arg1 == arg2) {
        CYG_REPORT_RETVAL(0);
        return 0;
    }
 
    // The version number "current" is special, it always indicates the most
    // recent version e.g. as checked out from a CVS repository.
    if ("current" == arg1) {
        CYG_REPORT_RETVAL(-1);
        return -1;
    }
    if ("current" == arg2) {
        CYG_REPORT_RETVAL(1);
        return 1;
    }
 
    const char* ptr1 = arg1.c_str();
    const char* ptr2 = arg2.c_str();      
    int num1    = 0;
    int num2    = 0;
 
    // If both strings start with 'v' or 'V', skip this. A minor variation in
    // case at the start of a string should be ignored.
    if ((('v' == *ptr1) || ('V' == *ptr1)) &&
        (('v' == *ptr2) || ('V' == *ptr2))) {
        ptr1++;
        ptr2++;
    }
 
    // Now process the rest of the version string, one unit at a time.
    while (1) {
 
        if (('\0' == *ptr1) && ('\0' == *ptr2)) {
            // Both strings have terminated at the same time. There
            // may have been some spurious leading zeroes in numbers,
            // or irrelevant differences in the separators.
            CYG_REPORT_RETVAL(0);
            return 0;
        }
 
        if ('\0' == *ptr1) {
            // The first string has ended first. If the second string currently
            // points at a separator then arg2 is a derived version, e.g.
            // v0.3.p1, and hence newer. Otherwise arg2 is an experimental
            // version v0.3beta and hence older.
            if (is_separator(*ptr2)) {
                CYG_REPORT_RETVAL(1);
                return 1;
            } else {
                CYG_REPORT_RETVAL(-1);
                return -1;
            }
        }
 
        if ('\0' == *ptr2) {
            // As per the previous test.
            if (is_separator(*ptr1)) {
                CYG_REPORT_RETVAL(-1);
                return -1;
            } else {
                CYG_REPORT_RETVAL(1);
                return 1;
            }
        }
 
        // If both strings currently point at numerical data, do a conversion and
        // a numerical comparison.
        if (isdigit(*ptr1) && isdigit(*ptr2)) {
            num1 = 0;
            num2 = 0;
            // Strictly speaking there should be some overflow tests here, but it
            // is not worth the trouble.
            do {
                num1 = (10 * num1) + (*ptr1++ - '0');
            } while(isdigit(*ptr1));
            do {
                num2 = (10 * num2) + (*ptr2++ - '0');
            } while(isdigit(*ptr2));
            // v2.0 is newer than v1.0
            if (num1 < num2) {
                CYG_REPORT_RETVAL(1);
                return 1;
            } else if (num1 > num2) {
                CYG_REPORT_RETVAL(-1);
                return -1;
            } else {
                continue;
            }
        }
 
        // Non-numerical data. If the two characters are the same then
        // move on. Note: this has to happen after numerical conversions
        // to distinguish v10.0 and v1.0
        if (*ptr1 == *ptr2) {
            ptr1++; ptr2++;
            continue;
        }
 
        // If both strings are currently at a separator then move on. All
        // separators can be used interchangeably.
        if (is_separator(*ptr1) && is_separator(*ptr2)) {
            ptr1++; ptr2++;
            continue;
        }
 
        // If only one string is at a separator, special action
        // is needed. v1.1alpha is interpreted as earlier than
        // v1.1, but v1.1.3 is a later release.
        if (is_separator(*ptr1)) {
            return -1;
        } else if (is_separator(*ptr2)) {
            return 1;
        }
 
        // Two different characters, e.g. v1.0alpha vs. v1.0beta
        if (*ptr1 < *ptr2) {
            CYG_REPORT_RETVAL(1);
            return 1;
        } else {
            CYG_REPORT_RETVAL(-1);
            return -1;
        }
    }
 
    // Not reachable.
}
 
// ----------------------------------------------------------------------------
// Given a version string, extract major, minor and release numbers.
// Some or all of these may be absent. Basically the code just
// iterates through the string looking for sequences of numbers.
 
static void
version_extract_number(const std::string& version, unsigned int& index, std::string& result)
{
    CYG_REPORT_FUNCNAME("version_extract_number");
 
    // The calling code is expected to supply a sensible default.
    // Search for a digit
    for ( ; index < version.size(); index++) {
        if (isdigit(version[index])) {
            break;
        }
    }
    if (index != version.size()) {
        result = "";
        if ((index > 0) && ('-' == version[index-1])) {
            result = "-";
        }
        do {
            result += version[index++];
        } while ((index < version.size()) && isdigit(version[index]));
    }
 
    CYG_REPORT_RETURN();
}
 
void
Cdl::split_version_string(const std::string& version, std::string& major, std::string& minor, std::string& release)
{
    CYG_REPORT_FUNCNAME("CdlMisc::split_version_string");
 
    unsigned int index = 0;
    version_extract_number(version, index, major);
    version_extract_number(version, index, minor);
    version_extract_number(version, index, release);
 
    CYG_REPORT_RETURN();
}
 
//}}}
//{{{  Cdl::get_short_form()                                    
 
// ----------------------------------------------------------------------------
// It is occasionally useful to take a full CDL name such as CYgpkg_KERNEL
// and turn it into a short form such as "kernel". This involves discarding
// everything up to and including the first underscore, then lowercasing
// all subsequent characters.
std::string
Cdl::get_short_form(const std::string& original)
{
    CYG_REPORT_FUNCNAME("CdlMisc::get_short_form");
 
    std::string  result = "";
    unsigned int size = original.size();
    unsigned int i;
    for (i = 0; i < size; i++) {
        if ('_' == original[i]) {
            i++;
            break;
        }
    }
 
    // Either at end of string, or just past the first underscore
    for ( ; i < size; i++) {
        if (isupper(original[i])) {
            result += tolower(original[i]);
        } else {
            result += original[i];
        }
    }
 
    CYG_REPORT_RETURN();
    return result;
}
 
//}}}