예제 #1
0
파일: cscl.cpp 프로젝트: hak/criscript
//----------------------------------------------------------------------------
// ArgumentHandler::parse implementation
//----------------------------------------------------------------------------
int32_t ArgumentHandler::parse(int argc, _TCHAR* argv[] )
{
	assert( argv );

	if( !m_bInitialized )
		return 0;

	int32_t iArgsparsed = 1;	//0: executable name
	wstring* pstrArg;
	wstring strNull( L"" );
	while( iArgsparsed < argc )
	{
		pstrArg = new wstring( (const wchar_t*)argv[ iArgsparsed ], wcslen( (const wchar_t*)argv[ iArgsparsed ] ) );
		std::transform( pstrArg->begin(), pstrArg->end(), pstrArg->begin(), (int(*)(int))std::tolower );


		if( *pstrArg->begin() == '-' )
			//|| *pstrArg->begin() == '/' )	//Now only '-' is allowed as option switc
		{
			//parse options
			//*pstrArg->begin() = '-';	//Replace '/'
			map< wstring, OPTIONCALLBACK*>::iterator it;
			it =  m_mapOptions.find( *pstrArg );
			if( it != m_mapOptions.end() && it->second != NULL )
			{
				iArgsparsed += it->second( argc - iArgsparsed, argv + iArgsparsed );
			}
			else
			{
				if( m_pError )
				{
					m_pError->report( ERROR_INVALIDOPTIONSWITCH, 0, 0, strNull,
											strNull,
											*pstrArg );

				}
				iArgsparsed ++;
			}
		}
		else
		{
			delete pstrArg;
			break;
		}

		delete pstrArg;
	}
	return iArgsparsed;
}
예제 #2
0
static void test_CarlaUtils()
{
    // ----------------------------------------------------------------------------------------------------------------
    // misc functions

    {
        bool2str(false);
        bool2str(true);
        pass();

        char strBuf[2];
        nullStrBuf(strBuf);

        char* const strBuf2(strBuf+1);
        nullStrBuf(strBuf2);
    }

    // ----------------------------------------------------------------------------------------------------------------
    // string print functions

    {
        carla_debug("DEBUG");
        carla_stdout("STDOUT %s", bool2str(true));
        carla_stderr("STDERR %s", bool2str(false));
        carla_stderr2("STDERR2 " P_UINT64, 0xffffffff); // 4294967295
    }

    // ----------------------------------------------------------------------------------------------------------------
    // carla_*sleep

    {
        carla_sleep(1);
        carla_msleep(1);
    }

    // ----------------------------------------------------------------------------------------------------------------
    // carla_setenv

    {
        carla_setenv("THIS", "THAT");
        assert(std::strcmp(std::getenv("THIS"), "THAT") == 0);

        carla_unsetenv("THIS");
        assert(std::getenv("THIS") == nullptr);
    }

    // ----------------------------------------------------------------------------------------------------------------
    // carla_strdup

    {
        // with variables
        const char* const str1(carla_strdup("stringN"));
        const char* const strF(carla_strdup_free(strdup("stringF")));
        const char* const str2(carla_strdup_safe("stringS"));
        delete[] str1;
        delete[] str2;
        delete[] strF;

        // without variables
        delete[] carla_strdup("string_normal");
        delete[] carla_strdup_free(strdup("string_free"));
        delete[] carla_strdup_safe("string_safe");
    }

    {
        // common use case in Carla code
        struct TestStruct {
            const char* strNull;
            const char* strNormal;
            const char* strFree;
            const char* strSafe;

            TestStruct()
                : strNull(nullptr),
                  strNormal(carla_strdup("strNormal")),
                  strFree(carla_strdup_free(strdup("strFree"))),
                  strSafe(carla_strdup_safe("strSafe")) {}

            ~TestStruct() noexcept
            {
                if (strNull != nullptr)
                {
                    delete[] strNull;
                    strNull = nullptr;
                }

                if (strNormal != nullptr)
                {
                    delete[] strNormal;
                    strNormal = nullptr;
                }

                if (strFree != nullptr)
                {
                    delete[] strFree;
                    strFree = nullptr;
                }

                if (strSafe != nullptr)
                {
                    delete[] strSafe;
                    strSafe = nullptr;
                }
            }

            CARLA_DECLARE_NON_COPY_STRUCT(TestStruct)
        };

        TestStruct a, b, c;
    }

    // ----------------------------------------------------------------------------------------------------------------
    // memory functions

    {
        int a1[] = { 4, 3, 2, 1 };
        int a2[] = { 4, 3, 2, 1 };
        int b1[] = { 1, 2, 3, 4 };
        int b2[] = { 1, 2, 3, 4 };

        carla_add(a1, b1, 4);
        assert(a1[0] == 5);
        assert(a1[1] == 5);
        assert(a1[2] == 5);
        assert(a1[3] == 5);

        carla_add(b1, a2, 4);
        assert(b1[0] == 5);
        assert(b1[1] == 5);
        assert(b1[2] == 5);
        assert(b1[3] == 5);
        assert(a1[0] == b1[0]);
        assert(a1[1] == b1[1]);
        assert(a1[2] == b1[2]);
        assert(a1[3] == b1[3]);

        carla_copy(a1, b2, 4);
        assert(a1[0] != b1[0]);
        assert(a1[1] != b1[1]);
        assert(a1[2] != b1[2]);
        assert(a1[3] != b1[3]);
        assert(a1[0] == b2[0]);
        assert(a1[1] == b2[1]);
        assert(a1[2] == b2[2]);
        assert(a1[3] == b2[3]);

        carla_copy(a1, b1, 4);
        assert(a1[0] == b1[0]);
        assert(a1[1] == b1[1]);
        assert(a1[2] == b1[2]);
        assert(a1[3] == b1[3]);

        carla_copy(a1, b2, 2);
        assert(a1[0] != b1[0]);
        assert(a1[1] != b1[1]);
        assert(a1[2] == b1[2]);
        assert(a1[3] == b1[3]);

        carla_copy(a1+2, b2+2, 2);
        assert(a1[0] != b1[0]);
        assert(a1[1] != b1[1]);
        assert(a1[2] != b1[2]);
        assert(a1[3] != b1[3]);

        carla_copy(a1, b1, 2);
        assert(a1[0] == b1[0]);
        assert(a1[1] == b1[1]);
        assert(a1[2] != b1[2]);
        assert(a1[3] != b1[3]);

        carla_copy(a1+2, b1+2, 2);
        assert(a1[0] == b1[0]);
        assert(a1[1] == b1[1]);
        assert(a1[2] == b1[2]);
        assert(a1[3] == b1[3]);

        carla_fill(a1, 0, 4);
        assert(a1[0] == 0);
        assert(a1[1] == 0);
        assert(a1[2] == 0);
        assert(a1[3] == 0);

        carla_fill(a1, -11, 4);
        assert(a1[0] == -11);
        assert(a1[1] == -11);
        assert(a1[2] == -11);
        assert(a1[3] == -11);

        carla_fill(a1, 1791, 2);
        assert(a1[0] == 1791);
        assert(a1[1] == 1791);
        assert(a1[2] == -11);
        assert(a1[3] == -11);

        carla_fill(a1+2, 1791, 2);
        assert(a1[0] == 1791);
        assert(a1[1] == 1791);
        assert(a1[2] == 1791);
        assert(a1[3] == 1791);

        int16_t d = 1527, e = 0;

        carla_add(&d, &d, 1);
        assert(d == 1527*2);

        carla_add(&d, &d, 1);
        assert(d == 1527*4);

        carla_add(&d, &e, 1);
        assert(d == 1527*4);
        assert(e == 0);

        carla_add(&e, &d, 1);
        assert(d == e);

        carla_add(&e, &d, 1);
        assert(e == d*2);

        d = -e;
        carla_add(&d, &e, 1);
        assert(d == 0);
    }

    {
        bool x;
        const bool f = false, t = true;

        carla_copy(&x, &t, 1);
        assert(x);

        carla_copy(&x, &f, 1);
        assert(! x);

        carla_fill(&x, true, 1);
        assert(x);

        carla_fill(&x, false, 1);
        assert(! x);
    }

    {
        uint8_t a[] = { 3, 2, 1, 0 };
        carla_zeroBytes(a, 1);
        assert(a[0] == 0);
        assert(a[1] == 2);
        assert(a[2] == 1);
        assert(a[3] == 0);

        carla_zeroBytes(a+1, 2);
        assert(a[0] == 0);
        assert(a[1] == 0);
        assert(a[2] == 0);
        assert(a[3] == 0);
    }

    {
        char a[501];

        for (int i=500; --i>=0;)
            a[i] = 'a';

        carla_zeroChars(a, 501);

        for (int i=501; --i>=0;)
            assert(a[i] == '\0');

        for (int i=500; --i>=0;)
            a[i] = 'a';

        assert(std::strlen(a) == 500);

        carla_fill(a+200, '\0', 1);
        assert(std::strlen(a) == 200);
    }

    {
        void* a[33];
        carla_zeroPointers(a, 33);

        for (int i=33; --i>=0;)
            assert(a[i] == nullptr);
    }

    {
        struct Thing {
            char c;
            int i;
            int64_t h;

            bool operator==(const Thing& t) const noexcept
            {
                return (t.c == c && t.i == i && t.h == h);
            }

            bool operator!=(const Thing& t) const noexcept
            {
                return !operator==(t);
            }
        };

        Thing a, b, c;

        a.c = 0;
        a.i = 0;
        a.h = 0;

        b.c = 64;
        b.i = 64;
        b.h = 64;

        c = a;

        carla_copyStruct(a, b);
        assert(a == b);

        carla_zeroStruct(a);
        assert(a == c);

        carla_copyStruct(c, b);
        assert(a != c);

        // make it non-zero
        a.c = 1;

        Thing d[3];

        carla_zeroStructs(d, 3);
        assert(d[0] != a);
        assert(d[1] != b);
        assert(d[2] != c);

        carla_copyStructs(d, &a, 1);
        assert(d[0] == a);
        assert(d[1] != b);
        assert(d[2] != c);

        carla_copyStructs(&c, d+2, 1);
        assert(d[0] == a);
        assert(d[1] != b);
        assert(d[2] == c);
    }
}
예제 #3
0
파일: cscl.cpp 프로젝트: hak/criscript
int _tmain(int argc, _TCHAR* argv[])
#endif
{
	int32_t iRet = RETVALUE_SUCCESS;
	
#ifdef __APPLE__
	_TCHAR** argv = convertArguments( argc, argvOriginal );
#endif
	

	//Initialize argument handler
	ArgumentHandler argumenthandler( ARRAYSIZE( options ), options );

	//Initialize a parser interface
	cri::CParser* parser = new cri::CParser;

	//Initialize error handler
	cri::CErrorPool *error = new cri::CErrorPool;
	error->setErrorTable( cri::g_ErrorTable_English, sizeof( cri::g_ErrorTable_English ) 
													 / sizeof( cri::g_ErrorTable_English[ 0 ] ) );
	//parse args
	argumenthandler.setErrorHandler( error );
	int32_t iArgOffset = argumenthandler.parse( argc, argv );

	//Set error output configuration
	error->suppressErrorLine( g_bsuppressErrorLine );

	if( !g_bSuppressBanner )
	{
		CRISCRIPT_VERSIONS ver = parser->getVersions();
		cout << "CriScript compiler and linker ver.";
		cout << ver.major << ".";
		cout << ver.minor << ".";
		cout << ver.revision << ".";
		cout << ver.build << "\n";
		cout << "CRI Middleware inc. 2008" << endl;
	}
	
	if( argc <= iArgOffset )
	{
		if( error->hasError() )
			error->dumpError();
		delete( error );

		//Output help info
		cout << endl;
		cout << "cscl.exe [options] source" << endl;
		cout << "Option switch:" << endl;
		for( int32_t i = 0; i < ARRAYSIZE( options ); ++ i )
		{
			wcout << options[ i ].strOption << " : " << options[ i ].strDescription << endl; 
		}

		delete( parser );

#ifdef __APPLE__
		deleteArguments( argc, argv );	
#endif
        return RETVALUE_SUCCESS;
	}


	//Open the target file
#ifdef __APPLE__
	ifstream fin ( argvOriginal[ iArgOffset ], ios::in | ios::binary );
#else
	ifstream fin ( argv[ iArgOffset ], ios::in | ios::binary );
#endif
    if( !fin )
	{
		wstring strArg1( argv[ iArgOffset ] );
		wstring strNull( L"" );
		error->report( ERROR_FILENOTFOUND, 0, 0, strArg1,
												strNull,
												strArg1 );
		error->dumpError();
		delete( error );
		delete( parser );

#ifdef __APPLE__
		deleteArguments( argc, argv );	
#endif
        return RETVALUE_TOOL_ERROR;
    }

	//Check file endianness;
	//Note that wchar_t is 4 byte in OSX.
	uint16_t c;
	fin.read( (char*)&c, sizeof( uint16_t ) );

	bool bSourceEndiannness = false;
	switch( c )
	{
	case 0xfeff:
		//Little endian
		break;
	case 0xfffe:
		//Big endian
		bSourceEndiannness = true;
		break;
	default:
		{
		wstring strArg1( argv[ iArgOffset ] );
		wstring strNull( L"" );
		error->report( ERROR_INVALIDFILEENCODING, 0, 0, strArg1,
												strNull,
												strArg1 );
		error->dumpError();
		delete( error );
        
		}
			delete( parser );
#ifdef __APPLE__
			deleteArguments( argc, argv );	
#endif
			return RETVALUE_TOOL_ERROR;
	}

	//Initialize the lexer
	cri::CFileStreamLexer *lex = new cri::CFileStreamLexer;
	
	//test	
	lex->init();
	
	lex->setEndianness( bSourceEndiannness );

	//Initialize the codegen
	cri::CCilCodeGen *codegen = new cri::CCilCodeGen;

	//Initialize the parser engine
	parser->init( lex, codegen, error );
	
	//Set filestream to the lexer
	lex->setStream( &fin, &wstring( argv[ iArgOffset ] ) );

#ifdef DEBUG_PARSING
	//debug
	cri::yydebug = 1;
#endif
	if( !g_bPerformLinkage )
	{
		iRet = Compile( parser, fin );
		g_bPerformExecution = false;
	}
	else
	{
		iRet = CompileAndLink( parser, fin );
	}

	if( error->hasError() )
	{
		error->dumpError();
		cout << "Compile failed." << endl;
		iRet = RETVALUE_COMPILE_ERROR;
	}
	else
	{
		if( error->hasInformation() )
		{
			iRet = RETVALUE_COMPILE_WARNING;
			cout << "Compile succeeded but with some warnings" << endl;
		}
		else
		{
			iRet = RETVALUE_SUCCESS;
			cout << "Compile succeeded." << endl;
		}
		
		error->dumpError();
	}

	if( g_bPerformExecution && iRet != RETVALUE_COMPILE_ERROR )
	{
		cri::CCilVm *vm = new cri::CCilVm;
		cri::CCilDebugger *debugger = new cri::CCilDebugger;

		vm->setILPool( &*parser->getILPool().begin(), parser->getILPool().size() );
		//Note:
		//setSymbolInformation need to be invoked before SetMetaData() for now
		vm->setSymbolInformation( parser->getSymbolInformation() );
		vm->setMetaData( parser->getMetaData() );

		cout << "-----------------------------------------------------------------\n";
		cri::CCilDisasm * disasm = new cri::CCilDisasm;
		disasm->setILStream( &*parser->getILPool().begin(), parser->getILPool().size() );
		disasm->setSymbolInformation( parser->getSymbolInformation() );
		disasm->setMetaData( parser->getMetaData() );
		disasm->dumpDisasm();
		cout << "-----------------------------------------------------------------\n";

		iRet = vm->execute();
		iRet = vm->getExitCode(); 

		debugger->attach( vm );
		debugger->setSymbolInformation( parser->getSymbolInformation() );
		debugger->setMetaData( parser->getMetaData() );
		
		debugger->debugDumpStats();
		debugger->debugDumpStaticFields( 0 );	//dump all fields
		debugger->debugDumpObjects( 0 );		//dump all objects

		delete( disasm );
		delete( debugger );
		delete( vm );
	}

	delete( lex );
	delete( error );
	delete( codegen );
	delete( parser );
	
#ifdef __APPLE__
	deleteArguments( argc, argv );	
#endif
		
	return iRet;
}