/* 
 *   Copyright (c) 2002 by Michael J. Roberts.  All Rights Reserved.
 *   
 *   Please see the accompanying license file, LICENSE.TXT, for information
 *   on using and copying this software.  
 */
/*
Name
  tccmdutl.cpp - TADS 3 Compiler command-line parsing utilities
Function
  Defines some utility functions for command-line parsing.
Notes
  
Modified
  04/03/02 MJRoberts  - Creation
*/

#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include "os.h"
#include "t3std.h"
#include "tccmdutl.h"

/* ------------------------------------------------------------------------ */
/* 
 *   Get an option argument.  We take a argument vector, the index of the
 *   vector entry containing the option whose argument we're to fetch, and
 *   the length of the option string.  We'll return a pointer to the option
 *   string, or null if no argument is present.
 *   
 *   We'll look for the argument's option first in the same vector entry
 *   containing the option, appended directly to the option string; if
 *   there's nothing there, we'll look for the argument in the next vector
 *   entry.  This lets us find option arguments that use syntax like
 *   "-Itest" or "-I test".  
 */
char *CTcCommandUtil::get_opt_arg(int argc, char **argv,
                                  int *curarg, int optlen)
{
    /* 
     *   if it's jammed up against the option letter, get it from the
     *   current array entry; otherwise, get it from the next array entry 
     */
    if (argv[*curarg][optlen + 1] != '\0')
    {
        /* it's attached to the same option entry */
        return argv[*curarg] + optlen + 1;
    }
    else if (*curarg + 1 < argc)
    {
        /* it's by itself as the next option entry */
        ++(*curarg);
        return argv[*curarg];
    }
    else
    {
        /* it's not present at all */
        return 0;
    }
}

/* ------------------------------------------------------------------------ */
/*
 *   Simple option helper implementation for counting arguments.  Some
 *   callers will want to let us scan an option file to get an argument count
 *   before they allocate space for the arguments.  On these count-only
 *   passes, the caller doesn't usually care about the contents of the file,
 *   so they don't want to bother performing the full set of operations that
 *   the helper normally defines.  For these cases, callers can pass us a
 *   null helper, in which case we'll use this simple helper by default. 
 */
class CTcOptFileHelperDefault: public CTcOptFileHelper
{
public:
    /* allocate an option string */
    virtual char *alloc_opt_file_str(size_t len)
    {
        return (char *)t3malloc(len + 1);
    }

    /* free a string allocated with alloc_opt_file_str() */
    virtual void free_opt_file_str(char *str)
    {
        t3free(str);
    }

    /* process a comment line */
    virtual void process_comment_line(const char *) { }

    /* process a non-comment line */
    virtual void process_non_comment_line(const char *) { }

    /* process a configuration line */
    virtual void process_config_line(const char *, const char *, int) { }
};


/* ------------------------------------------------------------------------ */
/*
 *   Parse an options file.  If argv is null, we'll simply count the
 *   arguments and return the count.  If argv is non-null, it must be
 *   allocated with the proper number of slots for the number of arguments
 *   in the file (as obtained from a call to this function with argv = null).
 *   
 *   Each string returned in argv[] is separately allocated with a call to
 *   helper->alloc_opt_file_str().  
 */
int CTcCommandUtil::parse_opt_file(osfildef *fp, char **argv,
                                   CTcOptFileHelper *helper)
{
    char *buf;
    char config_id[128];
    size_t buflen;
    int argc;
    CTcOptFileHelperDefault default_helper;

    /* if they didn't give us a helper object, use our default */
    if (helper == 0)
        helper = &default_helper;

    /* allocate our initial buffer */
    buflen = 512;
    buf = helper->alloc_opt_file_str(buflen);

    /* we're not in a configuration section yet */
    config_id[0] = '\0';

    /* keep going until we run out of text in the file */
    for (argc = 0 ; ; )
    {
        size_t len;
        char *p;

        /* read the next line - stop if we're done */
        if (osfgets(buf, buflen, fp) == 0)
            break;

        /* check for proper termination */
        for (;;)
        {
            /* get the buffer length */
            len = strlen(buf);

            /* check for a newline of some kind at the end */
            if (len != 0 && (buf[len - 1] == '\n' || buf[len - 1] == '\r'))
            {
                /* 
                 *   remove consecutive newline/return characters - in case
                 *   we are using a file moved from another system with
                 *   incompatible newline conventions, simply remove all of
                 *   the newlines we find 
                 */
                while (len != 0
                       && (buf[len-1] == '\n' || buf[len - 1] == '\r'))
                    --len;

                /* null-terminate the line */
                buf[len] = '\0';

                /* we now have our line */
                break;
            }
            else if (len == buflen - 1)
            {
                char *new_buf;
                size_t new_buf_len;
                
                /* 
                 *   The buffer was completely filled, and wasn't
                 *   null-terminated - the line must be too long for the
                 *   buffer.  Expand the buffer and go back for more.  
                 */
                new_buf_len = buflen + 512;
                new_buf = helper->alloc_opt_file_str(new_buf_len);

                /* copy the old buffer into the new buffer */
                memcpy(new_buf, buf, buflen);

                /* discard the old buffer */
                helper->free_opt_file_str(buf);

                /* switch to the new buffer */
                buf = new_buf;
                buflen = new_buf_len;

                /* append more data into the line buffer and try again */
                if (osfgets(buf + len, buflen - len, fp) == 0)
                    break;
            }
            else
            {
                /* 
                 *   The buffer wasn't completely full, and we didn't find a
                 *   newline.  This must mean that we've reached the end of
                 *   the file, so we've read as much as we can for this
                 *   line.  
                 */
                break;
            }
        }

        /* skip leading spaces */
        for (p = buf ; isspace(*p) ; ++p) ;

        /*
         *   Check to see if we're entering a new configuration section.  If
         *   the line matches the pattern "[Config:xxx]", then we're starting
         *   a new configuration section with identifier "xxx". 
         */
        if (strlen(p) > 8 && memicmp(p, "[config:", 8) == 0)
        {
            char *start;
            size_t copy_len;
            
            /* 
             *   note the part after the colon and up to the closing bracket
             *   - it's the ID of this configuration section 
             */
            for (p += 8, start = p ; *p != ']' && *p != '\0' ; ++p) ;

            /* limit the ID size to our buffer maximum */
            copy_len = p - start;
            if (copy_len > sizeof(config_id) - 1)
                copy_len = sizeof(config_id) - 1;

            /* copy and null-terminate the ID string */
            memcpy(config_id, start, copy_len);
            config_id[copy_len] = '\0';

            /* process the configuration ID line itself as a config line */
            helper->process_config_line(config_id, buf, TRUE);

            /* we're done processing this line */
            continue;
        }

        /* 
         *   if we're in a configuration section, simply process the line
         *   through the helper as a configuration line - this doesn't
         *   contain any options we can parse, since configuration sections
         *   are private to their respective definers 
         */
        if (config_id[0] != '\0')
        {
            /* process the configuration line through the helper */
            helper->process_config_line(config_id, buf, FALSE);

            /* we're done with this line */
            continue;
        }
        
        /* 
         *   If we've reached the end of the line or a command character
         *   ('#'), we're done with this line.  Note that we check for
         *   comments AFTER checking to see if we're in a config section,
         *   because we want to send any comment lines within a config
         *   section to the helper for processing as part of the config -
         *   even comments are opaque to us within a config section.  
         */
        if (*p == '\0' || *p == '#')
        {
            /* tell the helper about the comment */
            helper->process_comment_line(buf);

            /* we're done with the line - go back for the next one */
            continue;
        }

        /* tell the helper about the non-comment line */
        helper->process_non_comment_line(buf);

        /* parse the options on this line */
        for (p = buf ; *p != '\0' ; )
        {
            char *start;
            size_t arg_len;

            /* skip leading spaces */
            for ( ; isspace(*p) ; ++p) ;

            /* 
             *   if the argument is quoted, find the matching quote;
             *   otherwise, look for the next space 
             */
            if (*p == '"')
            {
                char *dst;

                /* find the matching quote */
                for (++p, start = dst = p ; *p != '\0' ; ++p)
                {
                    /* 
                     *   if this is a quote, check for stuttering - if it's
                     *   stuttered, treat it as a single quote (and convert
                     *   it to same), otherwise we've reached the end of the
                     *   argument 
                     */
                    if (*p == '"')
                    {
                        /* check for stuttering */
                        if (*(p+1) == '"')
                        {
                            /* 
                             *   it's stuttered - skip the extra quote, so
                             *   that we copy only a single quote 
                             */
                            ++p;
                        }
                        else
                        {
                            /* this is our closing quote - skip it */
                            ++p;

                            /* we're done with the argument */
                            break;
                        }
                    }

                    /* copy this character to the output */
                    *dst++ = *p;
                }

                /* note the length of the argument */
                arg_len = dst - start;
            }
            else
            {
                /* find the next space */
                for (start = p ; *p != '\0' && !isspace(*p) ; ++p) ;

                /* note the length of the argument */
                arg_len = p - start;
            }

            /* store the argument if we have an output vector */
            if (argv != 0)
            {
                /* allocate the argument */
                argv[argc] = helper->alloc_opt_file_str(arg_len + 1);

                /* copy it into the result */
                memcpy(argv[argc], start, arg_len);
                argv[argc][arg_len] = '\0';
            }

            /* count the argument */
            ++argc;
        }
    }

    /* done with our line buffer - delete it */
    helper->free_opt_file_str(buf);

    /* return the argument count */
    return argc;
}

