/*
 *  Copyright 2006-2007 Adrian Thurston <thurston@complang.org>
 */
/*  This file is part of Ragel.
 *
 *  Ragel 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.
 * 
 *  Ragel 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 Ragel; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#include "pcheck.h"
#include "common.h"
#include "stdlib.h"
#include <string.h>
#include <assert.h>
HostType hostTypesC[] =
{
        { "char",     0,       "char",    true,   true,  false,  CHAR_MIN,  CHAR_MAX,   0, 0,              sizeof(char) },
        { "unsigned", "char",  "uchar",   false,  true,  false,  0, 0,                  0,     UCHAR_MAX,  sizeof(unsigned char) },
        { "short",    0,       "short",   true,   true,  false,  SHRT_MIN,  SHRT_MAX,   0, 0,              sizeof(short) },
        { "unsigned", "short", "ushort",  false,  true,  false,  0, 0,                  0,     USHRT_MAX,  sizeof(unsigned short) },
        { "int",      0,       "int",     true,   true,  false,  INT_MIN,   INT_MAX,    0, 0,              sizeof(int) },
        { "unsigned", "int",   "uint",    false,  true,  false,  0, 0,                  0,     UINT_MAX,   sizeof(unsigned int) },
        { "long",     0,       "long",    true,   true,  false,  LONG_MIN,  LONG_MAX,   0, 0,              sizeof(long) },
        { "unsigned", "long",  "ulong",   false,  true,  false,  0, 0,                  0,     ULONG_MAX,  sizeof(unsigned long) }
};
#define S8BIT_MIN  -128
#define S8BIT_MAX  127
#define U8BIT_MIN  0
#define U8BIT_MAX  255
#define S16BIT_MIN -32768
#define S16BIT_MAX 32767
#define U16BIT_MIN 0
#define U16BIT_MAX 65535
#define S31BIT_MIN -1073741824L
#define S31BIT_MAX 1073741823L
#define S32BIT_MIN -2147483648L
#define S32BIT_MAX 2147483647L
#define U32BIT_MIN 0
#define U32BIT_MAX 4294967295UL
#define S64BIT_MIN -9223372036854775807LL
#define S64BIT_MAX 9223372036854775807LL
#define U64BIT_MIN 0
#define U64BIT_MAX 18446744073709551615ULL
HostType hostTypesD[] =
{
        { "byte",    0,  "byte",    true,   true,  false,  CHAR_MIN,  CHAR_MAX,    0, 0,                   1 },
        { "ubyte",   0,  "ubyte",   false,  true,  false,  0, 0,                   0,         UCHAR_MAX,   1 },
        { "char",    0,  "char",    false,  true,  false,  0, 0,                   0,         UCHAR_MAX,   1 },
        { "short",   0,  "short",   true,   true,  false,  SHRT_MIN,  SHRT_MAX,    0, 0,                   2 },
        { "ushort",  0,  "ushort",  false,  true,  false,  0, 0,                   0,         USHRT_MAX,   2 },
        { "wchar",   0,  "wchar",   false,  true,  false,  0, 0,                   0,         USHRT_MAX,   2 },
        { "int",     0,  "int",     true,   true,  false,  INT_MIN,   INT_MAX,     0, 0,                   4 },
        { "uint",    0,  "uint",    false,  true,  false,  0, 0,                   0,         UINT_MAX,    4 },
        { "dchar",   0,  "dchar",   false,  true,  false,  0, 0,                   0,         UINT_MAX,    4 }
};
HostType hostTypesGo[] = 
{
        { "byte",    0,  "uint8",   false,  true,  false,  0, 0,                    U8BIT_MIN,  U8BIT_MAX,   1 },
        { "int8",    0,  "int8",    true,   true,  false,  S8BIT_MIN,  S8BIT_MAX,   0, 0,                    1 },
        { "uint8",   0,  "uint8",   false,  true,  false,  0, 0,                    U8BIT_MIN,  U8BIT_MAX,   1 },
        { "int16",   0,  "int16",   true,   true,  false,  S16BIT_MIN, S16BIT_MAX,  0, 0,                    2 },
        { "uint16",  0,  "uint16",  false,  true,  false,  0, 0,                    U16BIT_MIN, U16BIT_MAX,  2 },
        { "int32",   0,  "int32",   true,   true,  false,  S32BIT_MIN, S32BIT_MAX,  0, 0,                    4 },
        { "uint32",  0,  "uint32",  false,  true,  false,  0, 0,                    U32BIT_MIN, U32BIT_MAX,  4 },
        { "int64",   0,  "int64",   true,   true,  false,  S64BIT_MIN, S64BIT_MAX,  0, 0,                    8 },
        { "uint64",  0,  "uint64",  false,  true,  false,  0, 0,                    U64BIT_MIN, U64BIT_MAX,  8 },
        { "rune",    0,  "int32",   true,   true,  true,   S32BIT_MIN, S32BIT_MAX,  0, 0,                    4 }
};
HostType hostTypesJava[] = 
{
        { "byte",    0,  "byte",   true,   true,  false,  CHAR_MIN,  CHAR_MAX,    0, 0,                   1 },
        { "short",   0,  "short",  true,   true,  false,  SHRT_MIN,  SHRT_MAX,    0, 0,                   2 },
        { "char",    0,  "char",   false,  true,  false,  0, 0,                   0,         USHRT_MAX,   2 },
        { "int",     0,  "int",    true,   true,  false,  INT_MIN,   INT_MAX,     0, 0,                   4 },
};
/* What are the appropriate types for ruby? */
HostType hostTypesRuby[] = 
{
        { "char",    0,  "char",   true,   true,  false,  CHAR_MIN,  CHAR_MAX,    0, 0, 1 },
        { "int",     0,  "int",    true,   true,  false,  INT_MIN,   INT_MAX,     0, 0, 4 },
};
HostType hostTypesCSharp[] =
{
        { "sbyte",   0,  "sbyte",   true,   true,  false,  CHAR_MIN,  CHAR_MAX,    0, 0,                   1 },
        { "byte",    0,  "byte",    false,  true,  false,  0, 0,                   0,         UCHAR_MAX,   1 },
        { "short",   0,  "short",   true,   true,  false,  SHRT_MIN,  SHRT_MAX,    0, 0,                   2 },
        { "ushort",  0,  "ushort",  false,  true,  false,  0, 0,                   0,         USHRT_MAX,   2 },
        { "char",    0,  "char",    false,  true,  true,   0, 0,                   0,         USHRT_MAX,   2 },
        { "int",     0,  "int",     true,   true,  false,  INT_MIN,   INT_MAX,     0, 0,                   4 },
        { "uint",    0,  "uint",    false,  true,  false,  0, 0,                   0,         UINT_MAX,    4 },
        { "long",    0,  "long",    true,   true,  false,  LONG_MIN,  LONG_MAX,    0, 0,                   8 },
        { "ulong",   0,  "ulong",   false,  true,  false,  0, 0,                   0,         ULONG_MAX,   8 }
};
HostType hostTypesOCaml[] =
{
        { "int",    0,  "int",      true,   true,  false, S31BIT_MIN, S31BIT_MAX, 0, 0,                   4 },
};
HostLang hostLangC =      { HostLang::C,      hostTypesC,      8,  hostTypesC+0,       true };
HostLang hostLangD =      { HostLang::D,      hostTypesD,      9,  hostTypesD+2,       true };
HostLang hostLangD2 =     { HostLang::D2,     hostTypesD,      9,  hostTypesD+2,       true };
HostLang hostLangGo =     { HostLang::Go,     hostTypesGo,    10,  hostTypesGo+0,      false };
HostLang hostLangJava =   { HostLang::Java,   hostTypesJava,   4,  hostTypesJava+2,    false };
HostLang hostLangRuby =   { HostLang::Ruby,   hostTypesRuby,   2,  hostTypesRuby+0,    false };
HostLang hostLangCSharp = { HostLang::CSharp, hostTypesCSharp, 9,  hostTypesCSharp+4,  true };
HostLang hostLangOCaml =  { HostLang::OCaml,  hostTypesOCaml,  1,  hostTypesOCaml+0,   false };
HostLang *hostLang = &hostLangC;
HostType *findAlphType( const char *s1 )
{
        for ( int i = 0; i < hostLang->numHostTypes; i++ ) {
                if ( strcmp( s1, hostLang->hostTypes[i].data1 ) == 0 && 
                                hostLang->hostTypes[i].data2 == 0 )
                {
                        return hostLang->hostTypes + i;
                }
        }
        return 0;
}
HostType *findAlphType( const char *s1, const char *s2 )
{
        for ( int i = 0; i < hostLang->numHostTypes; i++ ) {
                if ( strcmp( s1, hostLang->hostTypes[i].data1 ) == 0 && 
                                hostLang->hostTypes[i].data2 != 0 && 
                                strcmp( s2, hostLang->hostTypes[i].data2 ) == 0 )
                {
                        return hostLang->hostTypes + i;
                }
        }
        return 0;
}
HostType *findAlphTypeInternal( const char *s1 )
{
        for ( int i = 0; i < hostLang->numHostTypes; i++ ) {
                if ( strcmp( s1, hostLang->hostTypes[i].internalName ) == 0 )
                        return hostLang->hostTypes + i;
        }
        return 0;
}
/* Construct a new parameter checker with for paramSpec. */
ParamCheck::ParamCheck( const char *paramSpec, int argc, const char **argv )
:
        state(noparam),
        argOffset(0),
        curArg(0),
        iCurArg(1),
        paramSpec(paramSpec), 
        argc(argc), 
        argv(argv)
{
}
/* Check a single option. Returns the index of the next parameter.  Sets p to
 * the arg character if valid, 0 otherwise.  Sets parg to the parameter arg if
 * there is one, NULL otherwise. */
bool ParamCheck::check()
{
        bool requiresParam;
        if ( iCurArg >= argc ) {            /* Off the end of the arg list. */
                state = noparam;
                return false;
        }
        if ( argOffset != 0 && *argOffset == 0 ) {
                /* We are at the end of an arg string. */
                iCurArg += 1;
                if ( iCurArg >= argc ) {
                        state = noparam;
                        return false;
                }
                argOffset = 0;
        }
        if ( argOffset == 0 ) {
                /* Set the current arg. */
                curArg = argv[iCurArg];
                /* We are at the beginning of an arg string. */
                if ( argv[iCurArg] == 0 ||        /* Argv[iCurArg] is null. */
                         argv[iCurArg][0] != '-' ||   /* Not a param. */
                         argv[iCurArg][1] == 0 ) {    /* Only a dash. */
                        parameter = 0;
                        paramArg = 0;
                        iCurArg += 1;
                        state = noparam;
                        return true;
                }
                argOffset = argv[iCurArg] + 1;
        }
        /* Get the arg char. */
        char argChar = *argOffset;
         
        /* Loop over all the parms and look for a match. */
        const char *pSpec = paramSpec;
        while ( *pSpec != 0 ) {
                char pSpecChar = *pSpec;
                /* If there is a ':' following the char then
                 * it requires a parm.  If a parm is required
                 * then move ahead two in the parmspec. Otherwise
                 * move ahead one in the parm spec. */
                if ( pSpec[1] == ':' ) {
                        requiresParam = true;
                        pSpec += 2;
                }
                else {
                        requiresParam = false;
                        pSpec += 1;
                }
                /* Do we have a match. */
                if ( argChar == pSpecChar ) {
                        if ( requiresParam ) {
                                if ( argOffset[1] == 0 ) {
                                        /* The param must follow. */
                                        if ( iCurArg + 1 == argc ) {
                                                /* We are the last arg so there
                                                 * cannot be a parameter to it. */
                                                parameter = argChar;
                                                paramArg = 0;
                                                iCurArg += 1;
                                                argOffset = 0;
                                                state = invalid;
                                                return true;
                                        }
                                        else {
                                                /* the parameter to the arg is the next arg. */
                                                parameter = pSpecChar;
                                                paramArg = argv[iCurArg + 1];
                                                iCurArg += 2;
                                                argOffset = 0;
                                                state = match;
                                                return true;
                                        }
                                }
                                else {
                                        /* The param for the arg is built in. */
                                        parameter = pSpecChar;
                                        paramArg = argOffset + 1;
                                        iCurArg += 1;
                                        argOffset = 0;
                                        state = match;
                                        return true;
                                }
                        }
                        else {
                                /* Good, we matched the parm and no
                                 * arg is required. */
                                parameter = pSpecChar;
                                paramArg = 0;
                                argOffset += 1;
                                state = match;
                                return true;
                        }
                }
        }
        /* We did not find a match. Bad Argument. */
        parameter = argChar;
        paramArg = 0;
        argOffset += 1;
        state = invalid;
        return true;
}
/* Counts newlines before sending sync. */
int output_filter::sync( )
{
        line += 1;
        return std::filebuf::sync();
}
/* Counts newlines before sending data out to file. */
std::streamsize output_filter::xsputn( const char *s, std::streamsize n )
{
        for ( int i = 0; i < n; i++ ) {
                if ( s[i] == '\n' )
                        line += 1;
        }
        return std::filebuf::xsputn( s, n );
}
/* Scans a string looking for the file extension. If there is a file
 * extension then pointer returned points to inside the string
 * passed in. Otherwise returns null. */
const char *findFileExtension( const char *stemFile )
{
        const char *ppos = stemFile + strlen(stemFile) - 1;
        /* Scan backwards from the end looking for the first dot.
         * If we encounter a '/' before the first dot, then stop the scan. */
        while ( 1 ) {
                /* If we found a dot or got to the beginning of the string then
                 * we are done. */
                if ( ppos == stemFile || *ppos == '.' )
                        break;
                /* If we hit a / then there is no extension. Done. */
                if ( *ppos == '/' ) {
                        ppos = stemFile;
                        break;
                }
                ppos--;
        } 
        /* If we got to the front of the string then bail we 
         * did not find an extension  */
        if ( ppos == stemFile )
                ppos = 0;
        return ppos;
}
/* Make a file name from a stem. Removes the old filename suffix and
 * replaces it with a new one. Returns a newed up string. */
const char *fileNameFromStem( const char *stemFile, const char *suffix )
{
        long len = strlen( stemFile );
        assert( len > 0 );
        /* Get the extension. */
        const char *ppos = findFileExtension( stemFile );
        /* If an extension was found, then shorten what we think the len is. */
        if ( ppos != 0 )
                len = ppos - stemFile;
        /* Make the return string from the stem and the suffix. */
        char *retVal = new char[ len + strlen( suffix ) + 1 ];
        strncpy( retVal, stemFile, len );
        strcpy( retVal + len, suffix );
        return retVal;
}
exit_object endp;
void operator<<( std::ostream &out, exit_object & )
{
    out << std::endl;
    exit(1);
}