/* 
 *   Copyright (c) 2002, 2002 Michael J Roberts.  All Rights Reserved.
 *   
 *   Please see the accompanying license file, LICENSE.TXT, for information
 *   on using and copying this software.  
 */
/*
Name
  tclibprs.cpp - tads compiler: library parser
Function
  Parses .tl files, which are text files that reference source files
  for inclusion in a compilation.  A .tl file can be used in a compilation
  as though it were a source file, and stands for the set of source files
  it references.  A .tl file can reference other .tl files.
Notes
  
Modified
  01/08/02 MJRoberts  - Creation
*/

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

#include "os.h"
#include "t3std.h"
#include "tclibprs.h"
#include "tcsrc.h"


/*
 *   Instantiate.  We'll note the name of the library, but we don't attempt
 *   to open it at this point - we won't open the file until parse_lib() is
 *   called.  
 */
CTcLibParser::CTcLibParser(const char *lib_name)
{
    char lib_path[OSFNMAX];

    /* 
     *   Extract the library's directory path.  Since files within a library
     *   are always relative to the directory containing the library itself,
     *   we use the full path to the library as the starting point for each
     *   file found within the library.  
     */
    os_get_path_name(lib_path, sizeof(lib_path), lib_name);

    /* remember the library path */
    lib_path_ = lib_copy_str(lib_path);

    /* remember the name of the library */
    lib_name_ = lib_copy_str(lib_name);

    /* no errors yet */
    err_cnt_ = 0;

    /* no lines read yet */
    linenum_ = 0;
}

CTcLibParser::~CTcLibParser()
{
    /* delete our library filename and path */
    lib_free_str(lib_name_);
    lib_free_str(lib_path_);
}

/*
 *   Parse a library file. 
 */
void CTcLibParser::parse_lib()
{
    CTcSrcFile *fp;

    /* open our file - we only accept plain ASCII here */
    fp = CTcSrcFile::open_ascii(lib_name_);

    /* if that failed, abort */
    if (fp == 0)
    {
        err_open_file();
        ++err_cnt_;
        return;
    }

    /* keep going until we run out of file */
    for (;;)
    {
        char buf[1024];
        char expbuf[1024];
        size_t len;
        char *p;
        char *dst;
        char *sep;
        char *var_name;
        char *var_val;

        /* read the next line of text */
        if ((len = fp->read_line(buf, sizeof(buf))) == 0)
            break;

        /* count the line */
        ++linenum_;

        /* un-count the terminating null byte in the length */
        --len;

        /* check for a terminating newline sequence */
        while (len != 0 && (buf[len-1] == '\n' || buf[len-1] == '\r'))
            --len;

        /* if we didn't find a newline, the line is too long */
        if (buf[len] == '\0')
        {
            char buf2[128];
            size_t len2;
            
            /* 
             *   If we can read anything more from the file, this indicates
             *   that the line was simply too long to read into our buffer;
             *   skip the rest of the line and log an error in this case.
             *   If we can't read any more text, it means we've reached the
             *   end of the file. 
             */
            if ((len2 = fp->read_line(buf2, sizeof(buf2))) != 0)
            {
                /* there's more, so the line is too long - flag an error */
                err_line_too_long();
                ++err_cnt_;

                /* skip text until we find a newline */
                for (;;)
                {
                    /* un-count the null terminator */
                    --len2;

                    /* if we've found our newline, we're done skipping */
                    if (len2 != 0
                        && (buf2[len2-1] == '\n' || buf2[len2-1] == '\r'))
                        break;
                    
                    /* read another chunk */
                    if ((len2 = fp->read_line(buf2, sizeof(buf2))) == 0)
                        break;
                }

                /* we've skipped the line, so go back for the next */
                continue;
            }
        }

        /* remove the newline from the buffer */
        buf[len] = '\0';

        /* scan for and expand preprocessor symbols */
        for (p = buf, dst = expbuf ; *p != '\0' ; ++p)
        {
            /* check for the start of a preprocessor symbol */
            if (*p == '$')
            {
                /* 
                 *   We have a dollar sign, so this *could* be a preprocessor
                 *   symbol.  If the next character is '(', then find the
                 *   matching ')', and take the part between the parentheses
                 *   as a symbol to expand.  If the next character is '$',
                 *   replace the pair with a single dollar sign.  If the next
                 *   character is anything else, the '$' is not significant,
                 *   so leave it as it is.  
                 */
                if (*(p+1) == '(')
                {
                    char *closep;

                    /* find the close paren */
                    for (closep = p + 2 ; *closep != '\0' && *closep != ')' ;
                         ++closep) ;

                    /* 
                     *   if we found the close paren, process it; if not,
                     *   just ignore the whole thing and treat the '$(' as a
                     *   pair of ordinary characters 
                     */
                    if (*closep == ')')
                    {
                        int vallen;
                        size_t symlen;
                        size_t rem;

                        /* skip to the start of the symbol name */
                        p += 2;

                        /* get the length of the symbol */
                        symlen = closep - p;

                        /* figure out how much space we have left */
                        rem = sizeof(expbuf) - (dst - expbuf);

                        /* look up the symbol's value */
                        vallen = get_pp_symbol(dst, rem, p, symlen);

                        /* note overflow or undefined symbol errors */
                        if (vallen < 0)
                        {
                            /* it's undefined - note it */
                            err_undef_sym(p, symlen);
                        }
                        else if ((size_t)vallen > rem)
                        {
                            /* it's too long - note it and give up now */
                            err_expanded_line_too_long();
                            break;
                        }
                        else
                        {
                            /* success - advance past the value */
                            dst += vallen;
                        }

                        /* 
                         *   Skip to the close paren and continue with the
                         *   main loop.  We don't need to copy any input for
                         *   the symbol, because we've already copied the
                         *   expansion instead; so just go back to the start
                         *   of the input loop.  
                         */
                        p = closep;
                        continue;
                    }
                    else
                    {
                        /* ill-formed macro substitution expression */
                        err_invalid_dollar();
                    }
                }
                else if (*(p+1) == '$')
                {
                    /* 
                     *   we have a double dollar sign, so turn it into a
                     *   single dollar sign - simply skip the first of the
                     *   pair so we only keep one 
                     */
                    ++p;
                }
                else
                {
                    /* invalid '$' sequence - warn about it */
                    err_invalid_dollar();
                }
            }

            /* make sure we have room for this character plus a null byte */
            if ((dst - expbuf) + 2 > sizeof(expbuf))
            {
                err_expanded_line_too_long();
                break;
            }

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

        /* null-terminate the expanded buffer */
        *dst = '\0';

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

        /* if the line is empty or starts with '#', skip it */
        if (*p == '\0' || *p == '#')
            continue;

        /* the variable name starts here */
        var_name = p;

        /* the variable name ends at the next space or colon */
        for ( ; *p != '\0' && *p != ':' && !isspace(*p) ; ++p) ;

        /* note where the variable name ends */
        sep = p;

        /* skip spaces after the end of the variable name */
        for ( ; isspace(*p) ; ++p) ;

        /* 
         *   if we didn't find a colon after the variable name, it's an
         *   error; flag the error and skip the line 
         */
        if (*p != ':')
        {
            /* check for stand-alone flags */
            if (stricmp(var_name, "nodef") == 0)
            {
                /* scan the "nodef" flag */
                scan_nodef();
            }
            else
            {
                /* 
                 *   it's not a valid stand-alone flag; the definition must
                 *   be missing the value portion 
                 */
                err_missing_colon();
                ++err_cnt_;
            }

            /* we're done with this line now */
            continue;
        }

        /* put a null terminator at the end of the variable name */
        *sep = '\0';

        /* skip any spaces after the colon */
        for (++p ; isspace(*p) ; ++p) ;

        /* the value starts here */
        var_val = p;

        /* scan the value */
        scan_var(var_name, var_val);
    }

    /* we're done - close the file */
    delete fp;
}

/*
 *   Scan a variable 
 */
void CTcLibParser::scan_var(const char *name, const char *val)
{
    /* call the appropriate routine based on the variable name */
    if (stricmp(name, "name") == 0)
        scan_name(val);
    else if (stricmp(name, "source") == 0)
        scan_source(val);
    else if (stricmp(name, "library") == 0)
        scan_library(val);
    else if (stricmp(name, "resource") == 0)
        scan_resource(val);
    else if (stricmp(name, "needmacro") == 0)
        scan_needmacro(val);
    else
        err_unknown_var(name, val);
}

/*
 *   Scan a source filename.  We build the full filename by combining the
 *   library path and the given filename, then we call scan_full_source().  
 */
void CTcLibParser::scan_source(const char *val)
{
    char rel_path[OSFNMAX];
    char full_name[OSFNMAX];

    /* convert the value from a URL-style path to a local path */
    os_cvt_url_dir(rel_path, sizeof(rel_path), val, FALSE);

    /* build the full name */
    os_build_full_path(full_name, sizeof(full_name), lib_path_, rel_path);

    /* call the full filename scanner */
    scan_full_source(val, full_name);
}

/*
 *   Scan a library filename.  We build the full filename by combining the
 *   enclosing library path and the given filename, then we call
 *   scan_full_library().  
 */
void CTcLibParser::scan_library(const char *val)
{
    char rel_path[OSFNMAX];
    char full_name[OSFNMAX];

    /* convert the value from a URL-style path to a local path */
    os_cvt_url_dir(rel_path, sizeof(rel_path), val, FALSE);

    /* build the full name */
    os_build_full_path(full_name, sizeof(full_name), lib_path_, rel_path);

    /* call the full library filename scanner */
    scan_full_library(val, full_name);
}

/*
 *   Scan a resource filename.  We build the full filename by combining the
 *   enclosing library path and the given filename, then we call
 *   scan_full_resource().  
 */
void CTcLibParser::scan_resource(const char *val)
{
    char rel_path[OSFNMAX];
    char full_name[OSFNMAX];

    /* convert the value from a URL-style path to a local path */
    os_cvt_url_dir(rel_path, sizeof(rel_path), val, FALSE);

    /* build the full name */
    os_build_full_path(full_name, sizeof(full_name), lib_path_, rel_path);

    /* call the full resource filename scanner */
    scan_full_resource(val, full_name);
}

/*
 *   scan a "needmacro" definition 
 */
void CTcLibParser::scan_needmacro(const char *val)
{
    const char *p;
    const char *macro_name;
    size_t macro_len;

    /* skip leading whitespace */
    for (p = val ; isspace(*p) ; ++p) ;

    /* the macro starts here */
    macro_name = p;

    /* find the next whitspace, which separates the token */
    for ( ; *p != '\0' && !isspace(*p) ; ++p) ;

    /* note the length of the macro name */
    macro_len = p - macro_name;

    /* skip the whitspace */
    for ( ; isspace(*p) ; ++p) ;

    /* process the parsed needmacro definition */
    scan_parsed_needmacro(macro_name, macro_len, p);
}

/*
 *   Scan a parsed "needmacro" definition.  This default implementation shows
 *   an error and the library-defined warning text.  
 */
void CTcLibParser::scan_parsed_needmacro(const char *macro_name,
                                         size_t macro_len,
                                         const char *warning_text)
{
    char buf[100+128+128];

    /* look up the symbol; if it's not defined, show a warning */
    if (get_pp_symbol(buf, sizeof(buf), macro_name, macro_len) < 0)
    {
        /* limit the symbol length to avoid overflowing the error buffer */
        if (macro_len > 128)
            macro_len = 128;

        /* show a suitable warning */
        src_err_msg("library requires preprocessor symbol \"%.*s\" to be "
                    "defined; use -D %.*s=value to define it (%s)",
                    (int)macro_len, macro_name, (int)macro_len, macro_name,
                    warning_text);
    }
}

/* 
 *   log an error in a source line 
 */
void CTcLibParser::src_err_msg(const char *msg, ...)
{
    char buf[1024];
    va_list args;

    /* format the caller's message and its arguments */
    va_start(args, msg);
    t3vsprintf(buf, sizeof(buf), msg, args);
    va_end(args);

    /* display the message with the source name and line number */
    err_msg("%s (%lu): %s", lib_name_, linenum_, buf);
}