#ifdef WIN32
#pragma warning(disable: 4786)  // Stop warnings about truncated identifiers in debug info
#endif

#include <errno.h>
#include <stdio.h>

#include <fstream>
#include <iostream>
#include <memory>
#include <sstream>
#include <stdexcept>

#include "parser.h"
#include "cmm.h"

#include "../utils/exceptionstream.h"
#include "../utils/debug.h"
#include "../utils/profil.h"



using namespace parser;

namespace
{
    // Windows-specific error handling
    void    System( const char* command)
    {
        if ( command[0]==0) return;
        if ( int e = system( command))
        {
            std::stringstream   msg;
            if ( e<0)   msg << "system( `" << command << "') failed to run the command: errno=" << errno << ", `" << strerror( errno) << "'";
            else        msg << "system( `" << command << "') failed: command returned error number " << e;
            // This follows the Win32 documents for system();  may not be portable.

            throw std::runtime_error( msg.str());
        }
    }

    void    OutputHelp( std::ostream& out)
    {
        out <<
            "\n"
            "cmm 0.28, 28 September 2003.\n"
            "\n"
            "Main parameters:\n"
            "\n"
            "    -s <cmm infile> <c++ outfile>\n"
            "\n"
            "        Input cmm file should be preprocessed. Requires\n"
            "        that the dispatch.cpp file (included in the cmm\n"
            "        distribution) is linked into the final\n"
            "        executable.\n"
            "\n"
            "\n"
            "Other parameters:\n"
            "\n"
            "    -! <command>        Run <command> using system().\n"
            "    -autoblocks         Insert `{' and `}' to match\n"
            "                        indentation.\n"
            "    -block <text>       Inserts <text> at start of all\n"
            "                        blocks\n"
            "    -caller-dispatch    enable caller dispatch\n"
            "    -checkindent        Checks indentation of lines\n"
            "                        containing '{' and '}'.\n"
            "    -detailedparse      Parse class/function bodies.\n"
            "    -embeddedfns        Support embedded functions, and\n"
            "                        convert to legal C++.\n"
            "    -errorlevel xyz     Sets how verbose error messages\n"
            "                        are after a parse failure\n"
            "                        x, y and z are each `0' or `1':\n"
            "                            x: showstartpos\n"
            "                            y: show all positions\n"
            "                            z: show failed terminals\n"
            "                        Default is 001\n"
            "    -exceptions-exit    Converts try..catch to exit(1).\n"
            "    -exceptions-fudge   Converts try..throw.. catch,\n"
            "                        to use Throw(), catch_t() and\n"
            "                        Catch2() functions\n"
            "    -h|-help|--h|--help Show this help.\n"
            "    -k                  Wait for keypress before exiting.\n"
            "    -lexer-verbose      Verbose lexer output\n"
            "    -newdeclsyntax      Support new declaration syntax,\n"
            "                        such as:\n"
            "                            foo: ( argv: []->char) int;\n"
            "    -no-exceptions      Generated code never throws\n"
            "                        exceptions. Calls exit(1) instead.\n"
            "    -no-hash-line       Ommit #line directives in\n"
            "                        generated source.\n"
            "    -parse <text>       Parses <text>, outputs parse-\n"
            "                        -tree if verbose.\n"
            "    -parsefile <file>   Parses <file>, outputs parse-\n"
            "                        -tree if verbose.\n"
            "    -pre <text>         Inserts <text> at start of output\n"
            "    -profile <header> <type>    Generates profiling code.\n"
            "                                (Not for general useage)\n"
            "    -profil <outfile>   Generates profiling stats using\n"
            "                        profil(1)\n"
            "    -shownumnodes       Prints out nuber of parser nodes\n"
            "                        created so far - e.g. you will\n"
            "                        probably want to put this flag\n"
            "                        after -s <in> <out>.\n"
            "    -small-ints         Add virtual function to every\n"
            "                        polymorphic class, which returns\n"
            "                        a unique int for that class\n"
            "    -v|verbose          Verbose.\n"
            "    -no-c++             lexer_t ignores C++ keywords\n"
            "\n"
            "    -serialise          Generate serialisation code\n"
            "                        (experimental)\n"
            "\n"
            "Special names\n"
            "    Declaring the following names in cmm code gives\n"
            "    control of cmm parser's as it parses the code:\n"
            "\n"
            "    cmm_pragma_autoblocks_on\n"
            "    cmm_pragma_autoblocks_off\n"
            "    cmm_pragma_detailedparse_on\n"
            "    cmm_pragma_detailedparse_off\n"
            "    cmm_pragma_newdeclsyntax_on\n"
            "    cmm_pragma_newdeclsyntax_off\n"
            "    cmm_pragma_embeddedfns_on\n"
            "    cmm_pragma_embeddedfns_off\n"
            "    cmm_pragma_lexer_verbose_on\n"
            "    cmm_pragma_lexer_verbose_off\n"
            "\n"
            "    E.g.  int cmm_pragma_embeddedfns_on()\n"
            "\n"
            "\n"
            "Old usage:\n"
            "\n"
            "    -c <cmm infile> <c++ outfile> <cmminfo outfile>\n"
            "\n"
            "        Reads in cmm source, and translates into c++\n"
            "        source.\n"
            "        Also generates a cmminfo file for use by `cmm -l'.\n"
            "        This contain information about all multimethod\n"
            "        implementations that were found in <cmm infile>,\n"
            "        and also the filename <c++ outfilename>.\n"
            "        if_t <cmminfo outfile> is empty (i.e. \"\"), no\n"
            "        cmminfo file is generated.\n"
            "\n"
            "\n"
            "    -l {<cmminfo infile>}\n"
            "\n"
            "        Reads in cmminfo file(s) created previously by\n"
            "        `cmm -c ...' command(s). Appends C++ source code\n"
            "        to some of the c++ files generated by these\n"
            "        command(s).\n"
            "\n"
            "    Dispatch code customisation:\n"
            "\n"
            "    In the following, <header> means a complete\n"
            "    #include line. For example, to make the dispatch code\n"
            "    use a custom replacement for std::map, called MyMap,\n"
            "    defined in the header file \"MyMap.h\", do:\n"
            "    cmm -map \"#include \\\"MyMap.h\\\"\" MyMap -l ...\n"
            "\n"
            "    -array <header> <type>  Override use of <vector>\n"
            "                            and std::vector in code\n"
            "                            generated by cmm -l.\n"
            "                            Replacement should match\n"
            "                            template< class T, int N>,\n"
            "                            where N is fixed size.\n"
            "    -map <header> <type>    Override use of <map> and\n"
            "                            std::map in code generated\n"
            "                            by cmm -l.\n"
            "\n"
            "For more information, see: http://www.op59.net/cmm/\n"
            "\n"
            "\n"
            ;
        // 60 characters width:
        //   012345678901234567890123456789012345678901234567890123456789
    }

    void    IncrementParam( int argc, int& i, int increment)
    {
        i+=increment;
        if ( i>argc)    throw std::runtime_error( "Not enough parameters. Run with `-h' to show help");
    }

    bool    GetBoolFromChar( char c)
    {
        if ( c=='1')    return true;
        if ( c=='0')    return false;
        throw exception_stream() << "Expecting `0' or `1', not `" << c << "'";
    }
}

int main( int argc, char** argv0)
{
    debug_TRACE_PRETTY;
    bool                            wait_for_keypress_before_exit = false;
    
    int                             retvalue        = 1;
    std::string                     verboseprefix   = std::string( argv0[0]) + ": ";
    bool                            checkindent     = false;
    bool                            detailedparse   = false;
    cmm::ThirdPassInfo::Extra       thirdpassextra;
    bool                            lexerverbose    = false;
    bool                            autoblocks      = false;
    bool                            err_showfailed  = true;
    bool                            err_showallpos  = false;
    bool                            err_showstartpos= false;
    bool                            support_embedded_functions_in_expressions = false;
    bool                            support_new_declsyntax = false;
    parser::exceptions_translation  exceptiontranslation    = exceptionstranslation_PRESERVE;
    bool                            no_cplusplus    = false;
    bool                            small_ints      = false;
    bool                            caller_dispatch = false;
    std::string                     block_text;
    std::string                     pre_text;
    
    try
    {
        #if 0
        {
            // test stlport'd iterator checking.
            std::vector< int>   v;
            v.push_back( 1);
            v.push_back( 2);
            std::vector<int>::iterator it=v.end();
            int x = *it;
        }
        #endif
        
        std::auto_ptr< op59_net::scoped_profil>
            prof;
        std::string prof_outfile;
        
        bool        verbose         = false;
        bool        no_hash_line    = false;

        const char** argv = (const char**) argv0;
        if ( argc==1)
        {   // invent default parameter list.
            static const char*  argv1[] =
                { "", "-h", NULL};
            argv = argv1;
            argc = sizeof( argv1)/sizeof( char*) - 1;
        }

        for ( int i=1; i<argc; /* incremented in loop*/)
        {
            int i0 = i;

            //if ( verbose)
            //  std::cerr << verboseprefix << "Looking at arg: `" << argv[i] << "'\n";

            if ( 0)
            {}

            else if (
                   0==strcmp( argv[i], "-h")
                || 0==strcmp( argv[i], "-help")
                || 0==strcmp( argv[i], "--h")
                || 0==strcmp( argv[i], "--help")
                )
            {
                IncrementParam( argc, i, 1);
                OutputHelp( std::cout);
            }

            else if ( 0==strcmp( argv[i], "-k"))
            {
                IncrementParam( argc, i, 1);
                wait_for_keypress_before_exit = true;
            }
            
            else if ( 0==strcmp( argv[i], "-profil"))
            {
                IncrementParam( argc, i, 2);
                
                int profil_min          = 0;
                int profil_max          = 0x00100000;
                int profil_scale_log2   = 13;
                // bin size is 2^(17-profil_scale_log2).
                
                int profil_binsize  = 1 << (17-profil_scale_log2);
                int profil_n        = (profil_max-profil_min) / profil_binsize;
                int profil_scale    = 1 << profil_scale_log2;
                
                //int profil_scale = 65536*profil_n*2/(profil_max-profil_min));
                
                prof.reset(
                    new op59_net::scoped_profil(
                        2*profil_n,
                        profil_min,
                        profil_scale));
                        
                prof_outfile = argv[ i-1];
            }

            else if ( 0==strcmp( argv[i], "-block"))
            {
                IncrementParam( argc, i, 2);
                block_text = argv[i-1];
            }

            else if ( 0==strcmp( argv[i], "-pre"))
            {
                IncrementParam( argc, i, 2);
                pre_text = argv[i-1];
            }

            else if ( 0==strcmp( argv[i], "-caller-dispatch"))
            {
                IncrementParam( argc, i, 1);
                caller_dispatch  = true;
            }

            else if ( 0==strcmp( argv[i], "-checkindent"))
            {
                IncrementParam( argc, i, 1);
                checkindent = true;
            }

            else if ( 0==strcmp( argv[i], "-detailedparse"))
            {
                IncrementParam( argc, i, 1);
                detailedparse = true;
            }
            
            else if ( 0==strcmp( argv[i], "-small-ints"))
            {
                IncrementParam( argc, i, 1);
                small_ints = true;
            }

            else if ( 0==strcmp( argv[i], "-embeddedfns"))
            {
                IncrementParam( argc, i, 1);
                support_embedded_functions_in_expressions = true;
                if ( !detailedparse)
                    std::cerr << "Warning: -embeddedfns only works if -detailedparse is set\n";
            }

            else if ( 0==strcmp( argv[i], "-autoblocks"))
            {
                IncrementParam( argc, i, 1);
                autoblocks = true;
            }
            
            else if ( 0==strcmp( argv[i], "-newdeclsyntax"))
            {
                IncrementParam( argc, i, 1);
                support_new_declsyntax = true;
            }
            else if ( 0==strcmp( argv[i], "-no-exceptions"))
            {
                IncrementParam( argc, i, 1);
                thirdpassextra.no_exceptions_in_generated_code = true;
            }
            else if ( 0==strcmp( argv[i], "-exceptions-exit"))
            {
                IncrementParam( argc, i, 1);
                exceptiontranslation = exceptionstranslation_EXIT;
            }
            else if ( 0==strcmp( argv[i], "-exceptions-fudge"))
            {
                IncrementParam( argc, i, 1);
                exceptiontranslation = exceptionstranslation_FUDGE;
            }
            else if ( 0==strcmp( argv[i], "-parse"))
            {
                IncrementParam( argc, i, 2);
                lexer_t lexer(
                    "command line parameter", 
                        argv[i-1], 
                        autoblocks, 
                        lexerverbose, 
                        err_showfailed, 
                        err_showallpos, 
                        err_showstartpos,
                        no_cplusplus);
                compilation_unit_t& compunit =
                    get_compilation_unit( 
                        lexer, 
                        detailedparse, 
                        support_embedded_functions_in_expressions, 
                        support_new_declsyntax, 
                        caller_dispatch,
                        verbose);
                
                if ( verbose)
                {
                    //compunit.output_tech( std::cerr);
                    //std::cerr << "\n";
                    std::cerr << compunit;
                    std::cerr << "\n";
                }
            }
            
            else if ( 0==strcmp( argv[i], "-parsefile"))
            {
                IncrementParam( argc, i, 2);
                std::string c = parser::LoadFile( argv[i-1]);
                lexer_t lexer(
                    argv[i-1], 
                    c.c_str(), 
                    autoblocks, 
                    lexerverbose, 
                    err_showfailed, 
                    err_showallpos, 
                    err_showstartpos,
                    no_cplusplus);
                compilation_unit_t& compunit =
                    get_compilation_unit( 
                        lexer, 
                        detailedparse, 
                        support_embedded_functions_in_expressions, 
                        support_new_declsyntax, 
                        caller_dispatch,
                        verbose);
                if ( verbose)
                {
                    (void)  compunit;
                    //compunit.output_tech( std::cerr);
                    //std::cerr << "\n";
                    std::cerr << compunit;
                    std::cerr << "\n";
                }
            }

            else if ( 0==strcmp( argv[i], "-!"))
            {
                IncrementParam( argc, i, 2);
                System( argv[i-1]);
            }

            else if ( 0==strcmp( argv[i], "-v") || 0==strcmp( argv[i], "-verbose"))
            {
                IncrementParam( argc, i, 1);
                verbose = true;
            }

            else if ( 0==strcmp( argv[i], "-lexer-verbose"))
            {
                IncrementParam( argc, i, 1);
                lexerverbose = true;
            }
            
            else if ( 0==strcmp( argv[i], "-shownumnodes"))
            {
                IncrementParam( argc, i, 1);
                std::cout << "number_t of nodes created: " << node_t::number_of_nodes << "\n";
            }
            
            else if ( 0==strcmp( argv[i], "-errorlevel"))
            {
                IncrementParam( argc, i, 2);
                const char* xyz = argv[i-1];
                err_showstartpos    = GetBoolFromChar( xyz[0]);
                err_showallpos      = GetBoolFromChar( xyz[1]);
                err_showfailed      = GetBoolFromChar( xyz[2]);
                if ( xyz[3]!=0) throw exception_stream() << "Expecting only three digits after -errorlevel, not " << xyz;
            }
            
            else if ( 0==strcmp( argv[i], "-no-hash-line"))
            {
                IncrementParam( argc, i, 1);
                no_hash_line = true;
            }

            else if ( 0==strcmp( argv[i], "-map"))
            {
                IncrementParam( argc, i, 3);
                thirdpassextra.mapinclude   = argv[i-2];
                thirdpassextra.maptype      = argv[i-1];
            }

            else if ( 0==strcmp( argv[i], "-array"))
            {
                IncrementParam( argc, i, 3);
                thirdpassextra.arrayinclude = argv[i-2];
                thirdpassextra.arraytype    = argv[i-1];
            }

            else if ( 0==strcmp( argv[i], "-profile"))
            {
                IncrementParam( argc, i, 3);
                thirdpassextra.profileinclude   = argv[i-2];
                thirdpassextra.profiletype      = argv[i-1];
            }

            else if ( 0==strcmp( argv[i], "-testlexer"))
            {
                IncrementParam( argc, i, 2);
                const char* filename_cmm    = argv[i-1];

                std::string in3 = parser::LoadFile( filename_cmm);
                lexer_t lexer(
                    filename_cmm, in3.c_str(), 
                        autoblocks, 
                        lexerverbose, 
                        err_showfailed, 
                        err_showallpos, 
                        err_showstartpos,
                        no_cplusplus);
                lexer.check_indentation = checkindent;

                for ( node_t* n=lexer.GetNext(); typeid( *n)!=typeid( parser::endoffile_t); n=lexer.GetNext())
                {
                    std::cerr << *n;
                }
            }
            
            else if ( 0==strcmp( argv[i], "-no-c++"))
            {
                IncrementParam( argc, i, 1);
                no_cplusplus = true;
            }
            
            else if ( 0==strcmp( argv[i], "-s"))
            {
                IncrementParam( argc, i, 3);
                const char* filename_cmm    = argv[i-2];
                const char* filename_cpp    = argv[i-1];
                std::string in = parser::LoadFile( filename_cmm);
                lexer_t lexer( 
                            filename_cmm, 
                            in.c_str(), 
                            autoblocks, 
                            lexerverbose, 
                            err_showfailed, 
                            err_showallpos, 
                            err_showstartpos,
                            no_cplusplus);
                lexer.check_indentation = checkindent;
                
                compilation_unit_t& compunit =
                    get_compilation_unit(
                        lexer, 
                        detailedparse, 
                        support_embedded_functions_in_expressions, 
                        support_new_declsyntax, 
                        caller_dispatch,
                        verbose);
                
                //debug << "creating secondpass\n";
                cmm::secondpass_info
                    secondpass(
                        compunit, 
                        filename_cpp, 
                        small_ints);
                
                secondpass.OutputTranslatedSource(
                    no_hash_line, 
                    exceptiontranslation, 
                    true, 
                    caller_dispatch,
                    block_text,
                    pre_text);
            }

            else if ( 0==strcmp( argv[i], "-c"))
            {
                IncrementParam( argc, i, 4);

                const char* filename_cmm    = argv[i-3];
                const char* filename_cpp    = argv[i-2];
                const char* filename_cmmi   = argv[i-1];

                std::string in3 = parser::LoadFile( filename_cmm);
                lexer_t lexer( 
                    filename_cmm, 
                        in3.c_str(), 
                        autoblocks, 
                        lexerverbose, 
                        err_showfailed, 
                        err_showallpos, 
                        err_showstartpos,
                        no_cplusplus);
                lexer.check_indentation = checkindent;
                
                compilation_unit_t& compunit =
                    get_compilation_unit(
                        lexer, 
                        detailedparse, 
                        support_embedded_functions_in_expressions, 
                        support_new_declsyntax, 
                        caller_dispatch,
                        verbose);
                
                cmm::secondpass_info    secondpass( compunit, filename_cpp, false);
                
                secondpass.OutputTranslatedSource(
                    no_hash_line, 
                    exceptiontranslation, 
                    false,
                    caller_dispatch,
                    block_text,
                    pre_text);
                
                if ( filename_cmmi[0] == 0)
                {
                    //std::cerr << "Warning: no .cmmi file specified.\n";
                    // should warn if cmmi info has been created.
                }
                else
                {
                    std::ofstream   infoout( filename_cmmi);
                    if ( !infoout)  throw exception_stream() << "Can't open `" << filename_cmmi << "' for writing";
                    secondpass.OutputImplDetails( infoout);
                }
            }

            else if ( 0==strcmp( argv[i], "-l"))
            {
                cmm::ThirdPassInfo  third( thirdpassextra);
                
                for ( i+=1; i<argc; ++i)
                {
                    std::ifstream   in( argv[i]);
                    if ( !in)   throw exception_stream() << "Can't open `" << argv[i] << "' for reading";
                    third.AddFns( in);
                }
                if ( verbose)
                {
                    std::cerr << verboseprefix 
                        << "Appending " << third.virtfns.size() 
                        << " dispatch functions:\n";
                }
                for ( unsigned int i=0; i<third.virtfns.size(); ++i)
                {
                    declarator_names_t* lookup = cmm::MakeLookupFn( third.virtfns[i], third);
                    declarator_names_t* dispatcher = cmm::MakeDispatchFn( third.virtfns[i], third);
                    string_t*   filename0 = third.virtfns[i]->filename;
                    std::string filename1 = filename0->output_compact_tostring();
                    
                    // filename1 is in quotes, so we need to extract the text:
                    std::string filename2 = filename1.substr( 1, filename1.length()-2);
                    const char* filename = filename2.c_str();
                    if ( verbose)
                    {
                        std::cerr << verboseprefix 
                            << *dispatcher->items.back()->declarator->is_name()->name << " >> " << filename << "\n";
                    }
                    std::ofstream   out( filename, std::ios::app);
                    if ( !out)
                    {
                        exception_stream e;
                        e << "Couldn't open `" << filename << "' for appending";
                        throw e;
                    }
                    out << "\n";
                    cmm::OutputPreDispatchCode( out, *third.virtfns[i], third);
                    outstream_t outstream( out);
                    outstream.remove_virtual_from_functionparams = true;
                    //debug << "3. lookupfn is " << *lookup << "\n";
                    lookup->output( outstream);
                    dispatcher->output( outstream);
                    //debug << "4. end of lookup fn\n";
                }
            }

            else throw exception_stream() << "Unrecognised param `" << argv[i] << "'.";

            if ( i<=i0)     throw std::logic_error( "internal_t error - parameter count not incremented in main()");
            if ( i> argc)   throw std::logic_error( "internal_t error - parameter count incremented beyond end of params");
        }
        
        if ( prof.get())
        {
            prof->output( argv[0], prof_outfile);
        }
        
        retvalue = 0;
    }
    catch( std::exception& e)
    {
        std::cerr << verboseprefix << e.what() << "\n";
    }
    catch(...)
    {
        std::cerr << verboseprefix << "Unrecognised exception\n";
    }

    if ( wait_for_keypress_before_exit)
    {
        std::cerr << verboseprefix << "Press <return_t> to finish...\n";
        std::cin.get();
    }
    
    return retvalue;
}



#ifdef __GNUC__
    std::stringstream*  MakeStringStream()
    {
        return new std::stringstream;
    }
#endif