/************************************************************************

 *

 * opt_lines.cpp - definitions of line option handlers

 *

 * $Id: opt_lines.cpp 290026 2005-09-19 00:12:38Z sebor $

 *

 ************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed under the Apache License, Version 2.0 (the

 * "License");  you may  not use this file except  in compliance with the

 * License.    You    may   obtain   a   copy   of    the   License    at

 * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

 * applicable law  or agreed to  in writing,  software  distributed under

 * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

 * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

 * for the specific language governing permissions  and limitations under

 * the License.

 *

 **************************************************************************/

// expand _TEST_EXPORT macros

#define _RWSTD_TEST_SRC

#include "opt_lines.h"

#include <cmdopt.h>

#include <assert.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

enum {

    l_enabled  = 1,   // line is enabled

    l_disabled = 2,   // line is disabled

    l_expected = 4    // diagnostic on line is expected to be active

};

struct linerange_t {

    int      first;

    int      last;

    unsigned flags: 8;

    char     id [80];

};

static size_t nlineranges;

static linerange_t *lineranges;

static size_t rangebufsize;

/**************************************************************************/

static int

_rw_enable_lines (int first, int last, int flags)

{

    if (nlineranges == rangebufsize) {

        const size_t newbufsize = 2 * nlineranges + 1;

        linerange_t* const newranges =

            (linerange_t*)malloc (newbufsize * sizeof (linerange_t));

        if (0 == newranges) {

            abort ();

        }

        memcpy (newranges, lineranges, nlineranges * sizeof (linerange_t));

        free (lineranges);

        lineranges   = newranges;

        rangebufsize = newbufsize;

    }

    lineranges [nlineranges].first = first;

    lineranges [nlineranges].last  = last;

    lineranges [nlineranges].flags = flags;

    ++nlineranges;

    return 0;

}

static int

_rw_enable_line (int argc, char *argv[], int flags)

{

    char *parg = strchr (argv [0], '=');

    assert (0 != parg);

    const char* const argbeg = ++parg;

    // the lower bound of a range of lines to be enabled or disabled

    // negative values are not valid and denote an implicit lower bound

    // of 1 (such as in "-3" which is a shorthand for "1-3")

    long first = -1;

    for ( ; '\0' != *parg ; ) {

        // skip any leading whitespace

        for ( ; ' ' == *parg; ++parg);

        if ('-' == *parg) {

            if (first < 0) {

                first = 0;

                ++parg;

            }

            else {

                fprintf (stderr,

                         "invalid character '%c' at position %d: \"%s\"\n",

                         *parg, int (parg - argbeg), argv [0]);

                return 2;

            }

        }

        // parse a numeric argument

        char *end;

        long line = strtol (parg, &end, 0);

        // skip any trailing whitespace

        for ( ; ' ' == *end; ++end);

        if (end == parg || '-' != *end && ',' != *end && '\0' != *end) {

            fprintf (stderr,

                     "invalid character '%c' at position %d: \"%s\"\n",

                     *end, int (parg - argbeg), argv [0]);

            return 2;

        }

        if (0 <= first) {

            if (line < 0) {

                fprintf (stderr,

                         "invalid value %ld at position %d: \"%s\"\n",

                         line, int (parg - argbeg), argv [0]);

                return 2;

            }

            ++line;

            if ((',' == *end || '-' == *end) && end [1])

                ++end;

        }

        else if (',' == *end) {

            first = line++;

            if ('\0' == end [1]) {

                fprintf (stderr,

                         "invalid character '%c' at position %d: \"%s\"\n",

                         *end, int (parg - argbeg), argv [0]);

                return 2;

            }

            ++end;

        }

        else if ('-' == *end) {

            first = line;

            while (' ' == *++end);

            #ifdef __ARMCC__

    				#pragma diag_suppress 61

    				#endif 

            if ('\0' == *end) {

                line = _RWSTD_INT_MAX;

            }

            else if  (',' == *end) {

                line = _RWSTD_INT_MAX;

                ++end;

            }

            else

                line = -1;

        }

        else if ('\0' == *end) {

            first = line++;

        }

        else {

            fprintf (stderr,

                     "invalid character '%c' at position %d: \"%s\"\n",

                     *end, int (parg - argbeg), argv [0]);

            return 2;

        }

        parg = end;

        if (0 <= first && first < line) {

            _rw_enable_lines (first, line, flags);

            first = -1;

        }

    }

    return 0;

}

/**************************************************************************/

static int

_rw_opt_enable_line (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Enables the line or lines specified by <arg>.\n"

            "The syntax of <arg> is as follows: \n"

            "<arg>   ::= <range> [ , <range> ]\n"

            "<range> ::= [ - ] <number> | <number> - [ <number> ]\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    return _rw_enable_line (argc, argv, l_enabled);

}

/**************************************************************************/

static int

_rw_opt_no_line (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Disables the line or lines specified by <arg>.\n"

            "The syntax of <arg> is as follows: \n"

            "<arg>   ::= <range> [ , <range> ]\n"

            "<range> ::= [ - ] <number> | <number> - [ <number> ]\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    return _rw_enable_line (argc, argv, l_disabled);

}

/**************************************************************************/

static int

_rw_opt_expect_line (int argc, char *argv[])

{

    if (1 == argc && argv && 0 == argv [0]) {

        static const char helpstr[] = {

            "Marks the line or lines specified by <arg> as \"expected\".\n"

            "Inactive diagnostics on such lines will be issued as unexpected.\n"

            "The syntax of <arg> is as follows: \n"

            "<arg>   ::= <range> [ , <range> ]\n"

            "<range> ::= [ - ] <number> | <number> - [ <number> ]\n"

        };

        argv [0] = _RWSTD_CONST_CAST (char*, helpstr);

        return 0;

    }

    return _rw_enable_line (argc, argv, l_expected);

}

/************************************************************************/

/* extern */ int

_rw_setopts_lines ()

{

    const int result =

        rw_setopts ("|-enable-line="   // argument required

                    "|-expect= "       // argument required

                    "|-no-line= ",     // argument required

                    _rw_opt_enable_line,

                    _rw_opt_expect_line,

                    _rw_opt_no_line);

    return result;

}

/************************************************************************/

/* extern */ int

_rw_expected (int line)

{

    int line_expected = 0;

    for (size_t i = 0; i != nlineranges; ++i) {

        const int first = lineranges [i].first;

        const int last  = lineranges [i].last;

        if (lineranges [i].flags & (l_disabled | l_enabled)) {

            continue;

        }

        if (first <= line && line < last)

            line_expected = 0 != (lineranges [i].flags & l_expected);

    }

    return line_expected;

}

/************************************************************************/

_TEST_EXPORT int

rw_enabled (int line)

{

    int nenabled = 0;

    int ndisabled = 0;

    int line_enabled = -1;

    for (size_t i = 0; i != nlineranges; ++i) {

        const int first = lineranges [i].first;

        const int last  = lineranges [i].last;

        if (lineranges [i].flags & l_disabled) {

            ++ndisabled;

        }

        else if (lineranges [i].flags & l_enabled) {

            ++nenabled;

        }

        else {

            continue;

        }

        if (first <= line && line < last)

            line_enabled = 0 != (lineranges [i].flags & l_enabled);

    }

    if (nenabled && -1 == line_enabled)

        line_enabled = 0;

    return line_enabled;

}