udcfgtxt.c

工业组态软件modbus驱动源代码, 包括帮助文件.共享.

                            }
                            if (IsHexDigit (ch))
                            {
                                /* invalid hex value, treat as chars */
                                stat_val = 'x';     /* indicate error */
                                /* restore pointer, char = X */
                                next_ptr = scan_ptr + saved_offs;
                                ch = *next_ptr;
                                break;
                            }
                            else
                            {
                                /* valid hex value, use as char */
                                ch = (char) digit_val;
                                /* set scan pointer */
                                --next_ptr;
                            }
                            break;
                        default :
                            if (!IsOctalDigit (ch))
                                /* just use character as it is */
                                break;
                            /* a string of up to 3 octal digits for a char */
                            digit_count = 0;
                            digit_val = 0;
                            saved_offs = (unsigned long) (next_ptr - scan_ptr) - 1L;
                            while ((digit_count < 3) && (IsOctalDigit (ch)))
                            {
                                digit_count++;
                                digit_val = (digit_val << 3) + (ch - '0');
                                ch = *(++next_ptr);
                            }
                            if ((0 <= digit_val) && (digit_val <= 255))
                            {
                                /* valid octal value, use as char */
                                ch = (char) digit_val;
                                /* set scan pointer */
                                --next_ptr;
                            }
                            else
                            {
                                /* invalid octal value, treat as chars */
                                stat_val = 'x';     /* indicate error */
                                /* restore pointer, char = X */
                                next_ptr = scan_ptr + saved_offs;
                                ch = *next_ptr;     /* restore char */
                            }
                            break;
                            /* */
                    }
                    /* if valid, append to string */
                }
                /* otherwise, ordinary character, append to string */
            }

            /* append character and continue scanning, if appropriate */
            if (!done)
            {
                /* store character in token buffer, if there is room */
                if (++len < max_len)
                {
                    *(dest_ptr++) = ch;
                }
                else
                {
                    len--;
                    trunc = TRUE;
                }
                /* get next character and continue scan */
                ch = *(++next_ptr);
            }
        }

        if (len < max_len)
            *dest_ptr = 0;        /* append terminating zero */

        /* return updated pointer */
        *source_ptr = next_ptr;

        /* return string as token */
        bFound     = TRUE;
        *dest_len  = len;
        *truncated = trunc;
        *status    = stat_val;
    }

    /* check whether string was found */
    if (!bFound)
    {
        /** NULL pointer or end of string:
            indicate token not found **/
        *dest_len  = 0;
        *truncated = FALSE;
        *status    = 0;
    }

    /* indicate whether string was obtained successfully */
    return (bFound);
} /* GetDelimitedString */

/***********************************************************************
 ***********************************************************************
 * ComPort Parameter Conversion Routines                               *
 ***********************************************************************
 ***********************************************************************/

/***********************************************************************/
/* store default values in configurable COMPORT structure */

void
WINAPI
SetupDefaultComportCfgParams ( LPCOMPORT_CFG_WITHID lpCompPortCfgWithID, int port_num )
{
    /* store indicated port ID number */
    lpCompPortCfgWithID->channelID = port_num;
    /* store defaults in substructure */
    SetupDefaultPortCfgParams (&lpCompPortCfgWithID->comport);
} /* SetupDefaultComportCfgParams */

/********************************************************************/
/* convert BAUD rate index to BAUD rate */

static
unsigned long
WINAPI
BaudFromIndex (unsigned long uBaud_index)
{
    unsigned long uBaud_rate;

    switch (uBaud_index) {
        case CS_BAUD_110 :
            uBaud_rate = 110; break;
        case CS_BAUD_300 :
            uBaud_rate = 300; break;
        case CS_BAUD_600 :
            uBaud_rate = 600; break;
        case CS_BAUD_1200 :
            uBaud_rate = 1200; break;
        case CS_BAUD_2400 :
            uBaud_rate = 2400; break;
        case CS_BAUD_4800 :
            uBaud_rate = 4800; break;
        case CS_BAUD_9600 :
            uBaud_rate = 9600; break;
        case CS_BAUD_14400 :
            uBaud_rate = 14400; break;
        case CS_BAUD_19200 :
            uBaud_rate = 19200; break;
        case CS_BAUD_38400 :
            uBaud_rate = 38400; break;
        default :               /* index not defined */
            uBaud_rate = 0; break;
    } /* switch */

    return (uBaud_rate);
} /* BaudFromIndex */

/********************************************************************/
/* convert BAUD rate to BAUD rate index */

static
unsigned long
WINAPI
IndexFromBaud (unsigned long uBaud_rate)
{
    unsigned long uBaud_index;

    switch (uBaud_rate) {
        case 110 :
            uBaud_index = CS_BAUD_110; break;
        case 300 :
            uBaud_index = CS_BAUD_300; break;
        case 600 :
            uBaud_index = CS_BAUD_600; break;
        case 1200 :
            uBaud_index = CS_BAUD_1200; break;
        case 2400 :
            uBaud_index = CS_BAUD_2400; break;
        case 4800 :
            uBaud_index = CS_BAUD_4800; break;
        case 9600 :
            uBaud_index = CS_BAUD_9600; break;
        case 14400 :
            uBaud_index = CS_BAUD_14400; break;
        case 19200 :
            uBaud_index = CS_BAUD_19200; break;
        case 38400 :
            uBaud_index = CS_BAUD_38400; break;
        default :               /* index not defined */
            uBaud_index = 0; break;
    } /* switch */

    return (uBaud_index);
} /* IndexFromBaud */

/********************************************************************/
/* convert data bits index to data bits */

static
int
WINAPI
DataBitsFromIndex (unsigned long uDataBit_index)
{
    int DataBits;

    switch (uDataBit_index) {
        case CS_DATABITS_7 :
            DataBits = 7; break;
        case CS_DATABITS_8 :
            DataBits = 8; break;
        default :               /* index not defined */
            DataBits = 0; break;
    } /* switch */

    return (DataBits);
} /* DataBitsFromIndex */

/********************************************************************/
/* convert data bits to data bits index */

static
unsigned long
WINAPI
IndexFromDataBits (int DataBits)
{
    unsigned long uDataBit_index;

    switch (DataBits) {
        case 7 :
            uDataBit_index = CS_DATABITS_7; break;
        case 8 :
            uDataBit_index = CS_DATABITS_8; break;
        default :               /* index not defined */
            uDataBit_index = 0; break;
    } /* switch */

    return (uDataBit_index);
} /* IndexFromDataBits */

/********************************************************************/
/* convert stop bits index to stop bits */

static
int
WINAPI
StopBitsFromIndex (unsigned long uStopBit_index)
{
    int StopBits;

    switch (uStopBit_index) {
        case CS_STOP_BITS_1 :
            StopBits = 1; break;
        case CS_STOP_BITS_2 :
            StopBits = 2; break;
        default :               /* index not defined */
            StopBits = 0; break;
    } /* switch */

    return (StopBits);
} /* StopBitsFromIndex */

/********************************************************************/
/* convert stop bits string to stop bits index */

static
unsigned long
WINAPI
IndexFromStopBits (int StopBits)
{
    unsigned long uStopBit_index;

    /* initialize return value to undefined */
    uStopBit_index = 0;

    switch (StopBits) {
        case 1 :
            uStopBit_index = CS_STOP_BITS_1; break;
        case 2 :
            uStopBit_index = CS_STOP_BITS_2; break;
        default :               /* index not defined */
            uStopBit_index = 0; break;
    } /* switch */

    return (uStopBit_index);
} /* IndexFromStopBits */

/********************************************************************/
/* convert parity index to parity as string */

static
void
WINAPI
ParityFromIndex (unsigned long uParity_index, LPSTR Parity)
{
    switch (uParity_index) {
        case CS_PARITY_ODD :
            lstrcpy (Parity, "ODD"); break;
        case CS_PARITY_EVEN :
            lstrcpy (Parity, "EVEN"); break;
        case CS_PARITY_NONE :
            lstrcpy (Parity, "NONE"); break;
        case CS_PARITY_MARK :
            lstrcpy (Parity, "MARK"); break;
        case CS_PARITY_SPACE :
            lstrcpy (Parity, "SPACE"); break;
        default :               /* index not defined */
            lstrcpy (Parity, "UNDEFINED"); break;
    } /* switch */
} /* ParityFromIndex */

/********************************************************************/
/* convert parity string to parity index */

static
unsigned long
WINAPI
IndexFromParity (LPSTR Parity)
{
    unsigned long uParity_index;

    /* initialize return value to undefined */
    uParity_index = 0;

    if (lstrcmpi (Parity, "ODD") == 0)
        uParity_index = CS_PARITY_ODD;
    else
    if (lstrcmpi (Parity, "EVEN") == 0)
        uParity_index = CS_PARITY_EVEN;
    else
    if (lstrcmpi (Parity, "NONE") == 0)
        uParity_index = CS_PARITY_NONE;
    else
    if (lstrcmpi (Parity, "MARK") == 0)
        uParity_index = CS_PARITY_MARK;
    else
    if (lstrcmpi (Parity, "SPACE") == 0)
        uParity_index = CS_PARITY_SPACE;

    return (uParity_index);
} /* IndexFromParity */