Subversion Repositories theia_gpu

/* This program is free software. It comes without any warranty, to

 * the extent permitted by applicable law. You can redistribute it

 * and/or modify it under the terms of the Do What The Fuck You Want

 * To Public License, Version 2, as published by Sam Hocevar. See

 * http://sam.zoy.org/wtfpl/COPYING for more details. */

#pragma once

#include <fstream>

#include "Scanner.h"

#include <vector>

#include "Instruction.h"

#include <iostream>

#include <string>

#include <iterator>

        class TheiaCompiler

        {

                public:

                        std::vector<std::string> mPreprocessedFile;

                        // can instantiate with either a file name or an already open stream

                        inline explicit TheiaCompiler(std::string fileName) throw(std::string);

                        inline explicit TheiaCompiler(std::string fileName, bool aMode32) throw(std::string);

                        inline explicit TheiaCompiler(std::istream &iniStream) throw(std::string);

                        // Get a value from section and key

                        const char * getValue(const char * const section, const char * const key) const;

                        //-------------------------------------------------------------------------------------

                        void PrependCodeInitialization()

                        {

                                Instruction I;

                                I.mComment ="Make sure R0 has the appropiate values (0,1,2)";

                                I.SetCode( EOPERATION_ADD );

                                I.SetDestinationAddress( 0 );

                                I.SetImm( 0 );

                                I.SetDestZero( true );

                                I.SetWriteChannel(ECHANNEL_X);

                                mInstructions.push_back( I );

                                I.Clear();

                                I.SetCode( EOPERATION_ADD );

                                I.SetDestinationAddress( 0 );

                                I.SetImm( 1 );

                                I.SetDestZero( true );

                                I.SetWriteChannel(ECHANNEL_Y);

                                mInstructions.push_back( I );

                                I.Clear();

                                I.SetCode( EOPERATION_ADD );

                                I.SetDestinationAddress( 0 );

                                I.SetImm( 2 );

                                I.SetDestZero( true );

                                I.SetWriteChannel(ECHANNEL_Z);

                                mInstructions.push_back( I );

                                I.Clear();

                                I.mComment = "Disable multi-threading by default";

                                I.SetCode( EOPERATION_ADD );

                                I.SetDestinationAddress( SPR_CONTROL_REGISTER0 );

                                I.SetImm( 0 );

                                I.SetDestZero( true );

                                I.SetWriteChannel(ECHANNEL_Z);

                                mInstructions.push_back( I );

                                I.Clear();

                                I.mComment = "Make sure R3 (Frame Offset) is initialized to zero";

                                I.SetCode( EOPERATION_ADD );

                                I.SetDestinationAddress( SPR_CONTROL_REGISTER );

                                I.SetImm( 0 );

                                I.SetDestZero( true );

                                I.SetWriteChannel(ECHANNEL_XYZ);

                                mInstructions.push_back( I );

                                I.Clear();

                        }

                        //-------------------------------------------------------------------------------------

                        std::string GetHexCodeDump(void)

                        {

                                std::ostringstream oss;

                                //Add the header

                                oss << "//List file created by theia_compile\n";

                                for ( int i = 0; i < mInstructions.size(); i++)

                                {

                                        oss  << GetLineSymbolDefintion( i );

                                        if (mInstructions[i].mSourceLine > 0)

                                                        oss << "//" << mPreprocessedFile[ mInstructions[i].mSourceLine -1 ] << "\n";

                                        if (mInstructions[i].mComment.size())

                                                        oss << "//" << mInstructions[i].mComment<< "\n";

                                                oss << std::dec << i ;

                                                //oss << std::hex << " (0x"  <<  i << ") " ;

                                                oss << ":\t" << mInstructions[i].PrintAssembly() << "\n";

                                }

                                return oss.str();

                        }

                        //-------------------------------------------------------------------------------------

                        std::string GetLineSymbolDefintion( unsigned int aLine )

                        {

                                std::map<std::string, unsigned int>::const_iterator it;

                                for (it = mSymbolMap.begin(); it != mSymbolMap.end(); ++it)

                                {

                                        if (it->second == aLine)

                                                return "\n//" + it->first + "\n";

                                }

                                return std::string("");

                        }

                        //-------------------------------------------------------------------------------------

                        void Print(void)

                        {

                                for (int i = 0; i < mInstructions.size(); i++)

                                {

                                        //std::cout << "EA      : " << i << "\n";

                                        //std::cout << mInstructions[i].PrintHex() << "\n";

                                        //mInstructions[i].PrintFields();

                                        //std::cout << "\n";

                                }

                        }

                        //--------------------------------------------------------------------------------------------------

                        std::string PostProcess( std::string fileName )

                        {

                                std::string Result;

                                std::ifstream ifs(fileName.c_str());

                                if (!ifs.good())

                                        throw std::string("Unable to open file "+ fileName);

                                unsigned int CodeSize = 0;

                                while (!ifs.eof())

                                {

                                        char Buffer[1024];

                                        ifs.getline( Buffer,1024 );

                                        std::string Line = Buffer;

                                        //Ignore comments

                                        if (Line.find("//") != std::string::npos)

                                                Line.erase(Line.find("//"),Line.length());

                                        while (Line.find("\t") != std::string::npos)

                                                Line.replace(Line.find("\t"),1," ");

                                        //Ignore blank lines

                                        if (Line.length() == 0)

                                                continue;

                                        std::stringstream ss;

                                        ss << Line;

                                        std::string LineNumber,DestinationSymbol;

                                        unsigned int Operation,Destination,Src1,Src0;

                                        if (Line.find("@") != std::string::npos)

                                        {

                                                ss >> std::hex>> LineNumber >> Operation >> DestinationSymbol >>  Src1 >> Src0;

                                                DestinationSymbol.erase(0,1);

                                                //std::cout << "XXXX DestinationSymbol " << DestinationSymbol << "\n";

                                                std::ostringstream oss;

                                                Destination = mSymbolMap[ DestinationSymbol ];

                                                //std::cout << "XXXX Destination " << Destination << "\n";

                                        }

                                        else

                                                ss >> std::hex>> LineNumber >> Operation >> Destination >> Src1 >> Src0;

                                                //std::cout << "'" << Line << "'" << std::hex << LineNumber << "," << Operation << "," << Destination << "," << Src1 << "," << Src0 << "\n";

                                        Instruction I;

                                        I.SetFields(Operation,Destination,Src1,Src0);

                                        CodeSize++;

                                        if (m32BitMode)

                                                Result += I.PrintHex32() + "\n";

                                        else

                                                Result += I.PrintHex() + "\n";

                                }

                                std::cout << "CodeBlockSize: " << CodeSize << "\n";

                                return Result;

                        }

                        //--------------------------------------------------------------------------------------------------

                private:

                        // supress default constructor

                        TheiaCompiler();

                        // supress default copy constructor

                        TheiaCompiler(TheiaCompiler const &rhs);

                        // supress default assignment operator

                        TheiaCompiler &operator=(TheiaCompiler const &rhs);

                        std::vector< Instruction >          mInstructions;

                        std::map<std::string,unsigned int>  mSymbolMap;

                        bool                                                            mGenerateFixedPointArithmetic;

                        bool                                m32BitMode;

        };

//-------------------------------------------------------------------------------------------------------

        TheiaCompiler::TheiaCompiler(std::string fileName, bool aMode32 = false) throw(std::string)

        {

                m32BitMode = aMode32;

                mGenerateFixedPointArithmetic = false;

                std::ifstream inFile(fileName.c_str());

                if (!inFile.good())

                        throw std::string("Unable to open file "+ fileName);

                //First get me a local copy of the file into a vector

                std::string Line; //int  i = 1;

                while( std::getline(inFile, Line) )

                {

                                mPreprocessedFile.push_back( Line );

                                ////std::cout << i++ << " " << Line << "\n";

                }

                inFile.close();

                inFile.open(fileName.c_str());

                if (!inFile.good())

                        throw std::string("Unable to open file "+ fileName);

                PrependCodeInitialization();

                Theia::Scanner scanner(&inFile);

                Theia::Parser parser(scanner, mSymbolMap , mInstructions, mGenerateFixedPointArithmetic);

                std::cout << "parsing file\n";

                parser.parse();

        }

//-------------------------------------------------------------------------------------------------------

        TheiaCompiler::TheiaCompiler(std::istream &iniStream) throw(std::string)

        {

                mGenerateFixedPointArithmetic = false;

                Theia::Scanner scanner(&iniStream);

                Theia::Parser parser(scanner, mSymbolMap, mInstructions, mGenerateFixedPointArithmetic);

                parser.parse();

        }

//-------------------------------------------------------------------------------------------------------