Subversion Repositories theia_gpu

/**********************************************************************************

Theia, Ray Cast Programable graphic Processing Unit.

Copyright (C) 2012  Diego Valverde (diego.valverde.g@gmail.com)

This program 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.

This program 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 this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***********************************************************************************/

%require "2.4.1"

%skeleton "lalr1.cc"

%defines

%error-verbose

%locations

%define namespace "Theia"

%define parser_class_name "Parser"

%parse-param { Theia::Scanner &scanner }

%parse-param { std::map  & mSymbolMap }

%parse-param { std::vector< Instruction > &mInstructions }

%parse-param { bool &mGenerateFixedPointArithmetic }

%lex-param   { Theia::Scanner &scanner }

%code requires {

        #include 

        #include 

        #include 

        #include 

        #include 

        #include "Instruction.h"

        #include 

        // We want to return a string

        #define YYSTYPE std::string

                namespace Theia

                {

                        // Forward-declare the Scanner class; the Parser needs to be assigned a

                        // Scanner, but the Scanner can't be declared without the Parser

                        class Scanner;

                        // We use a map to store the INI data

                        typedef std::map > mapData;

                }

}

%code

{

        #include "Instruction.h"

        #include 

        Instruction I,tmpI;

        std::vector< unsigned int > gBranchStack;

        static int gInsertedInstructions = 0;

        static int gWhileLoopAddress = 0;

#define FUNCTION_PARAM_START_REGION 4

#define FUNCTION_PARAM_LAST_REGION  10

        std::map gFunctionParameters;

        std::map gAutoVarMap;

        std::map gThreadMap; //Key: Symbol, value: start code addr

        bool gThreadScope = false;

#define AUTOVAR_START_REGION 9

#define THREAD_OFFSET 128

unsigned int gExtraDestModifications = 0;

unsigned int gAutoVarIndex = AUTOVAR_START_REGION;

unsigned int gThreadAutoVarIndex = THREAD_OFFSET;

unsigned int gFunctionParameterIndex = FUNCTION_PARAM_START_REGION;

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

unsigned int GetNextFunctionParamRegister()

{

        unsigned Ret = gFunctionParameterIndex++;

        return Ret;

}

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

void AddFunctionParameter( std::string aVar, Theia::Parser::location_type  yylloc)

{

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

        if (gFunctionParameterIndex+1 > FUNCTION_PARAM_LAST_REGION)

        {

                        std::ostringstream ret;

                        ret << "Cannot allocate more parameters '" << aVar << "' at line " << yylloc << " \n";

                        throw ret.str();

        }

        if (gFunctionParameters.find(aVar) != gFunctionParameters.end())

        {

                        std::ostringstream ret;

                        ret << "Parameter '" << aVar << "' at line " << yylloc << " is already defined\n";

                        throw ret.str();

        }

        gFunctionParameters[ aVar ] = gFunctionParameterIndex++;

}

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

std::string  GetRegisterFromFunctionParameter( std::string aVar )

{

        ////std::cout << "Looking for " << aVar << "\n";

        if (gFunctionParameters.find(aVar) == gFunctionParameters.end())

                return "NULL";

        std::ostringstream ss;

        ss << gFunctionParameters[ aVar ];

        return  ("R" + ss.str());

}

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

unsigned int GetCurretAutoVarFrameSize()

{

        return gAutoVarMap.size();

}

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

std::string GetRegisterFromAutoVar( std::string aVar, Theia::Parser::location_type  yylloc )

{

        if (gAutoVarMap.find(aVar) == gAutoVarMap.end())

        {

                        std::ostringstream ret;

                        ret << "Undefined variable '" << aVar << "' at line " << yylloc << " \n";

                        throw ret.str();

        }

                std::ostringstream ss;

                ss << gAutoVarMap[ aVar ];

                return  ("R" + ss.str());

}

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

int GetCurrentLineNumber( const Theia::Parser::location_type &loc )

{

                int ret = -1;

                std::stringstream ss2;

                std::string where;

                ss2 << loc;

                ss2 >> where;

                where.erase(where.find_first_of("."));

                std::stringstream ss3;

                ss3 << where;

                ss3 >> ret;

                return ret;

}

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

unsigned int AllocAutoVar( unsigned int aSize = 1)

{

        if (!gThreadScope)

        {

                gAutoVarIndex += aSize;

                return gAutoVarIndex - (aSize-1);

        }else{

                gThreadAutoVarIndex += aSize;

                return (gThreadAutoVarIndex - (aSize-1));

        }

}

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

void ClearFunctionParameterMap()

{

        gFunctionParameters.clear();

        gFunctionParameterIndex = FUNCTION_PARAM_START_REGION;

}

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

void ClearAutoVarMap()

{

        gAutoVarMap.clear();

        gAutoVarIndex = AUTOVAR_START_REGION;

}

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

unsigned int gTempRegisterIndex = 1;

unsigned int GetFreeTempRegister( )

{

        if (!gThreadScope)

                return gAutoVarIndex + (gTempRegisterIndex++);

        else

                return gThreadAutoVarIndex + (gTempRegisterIndex++);

}

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

void ResetTempRegisterIndex( void )

{

        gTempRegisterIndex = 1;

}

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

bool IsSwizzled( std::string aSource)

{

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

                return true;

        else

                return false;

}

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

void SetSwizzleAndSign( unsigned int aSourceIndex, std::string aSwizzle, Instruction & I )

{

        std::string Reg,X,Y,Z, junk;

        std::stringstream ss( aSwizzle );

        ss >> Reg >> junk >> X >> Y >> Z;

        if (aSourceIndex == 1)

        {

                if (X == "X") { I.SetSrc1SwizzleX(SWX_X);       }

                if (X == "Y") { I.SetSrc1SwizzleX(SWX_Y);       }

                if (X == "Z") { I.SetSrc1SwizzleX(SWX_Z);       }

                if (X == "-X") { I.SetSrc1SignX( true ); I.SetSrc1SwizzleX(SWX_X);      }

                if (X == "-Y") { I.SetSrc1SignX( true ); I.SetSrc1SwizzleX(SWX_Y);      }

                if (X == "-Z") { I.SetSrc1SignX( true ); I.SetSrc1SwizzleX(SWX_Z);      }

                if (Y == "X") { I.SetSrc1SwizzleY(SWY_X);       }

                if (Y == "Y") { I.SetSrc1SwizzleY(SWY_Y);       }

                if (Y == "Z") { I.SetSrc1SwizzleY(SWY_Z);       }

                if (Y == "-X") { I.SetSrc1SignY( true ); I.SetSrc1SwizzleY(SWY_X);      }

                if (Y == "-Y") { I.SetSrc1SignY( true ); I.SetSrc1SwizzleY(SWY_Y);      }

                if (Y == "-Z") { I.SetSrc1SignY( true ); I.SetSrc1SwizzleY(SWY_Z);      }

                if (Z == "X") { I.SetSrc1SwizzleZ(SWZ_X);       }

                if (Z == "Y") { I.SetSrc1SwizzleZ(SWZ_Y);       }

                if (Z == "Z") { I.SetSrc1SwizzleZ(SWZ_Z);       }

                if (Z == "-X") { I.SetSrc1SignZ( true ); I.SetSrc1SwizzleZ(SWZ_X);      }

                if (Z == "-Y") { I.SetSrc1SignZ( true ); I.SetSrc1SwizzleZ(SWZ_Y);      }

                if (Z == "-Z") { I.SetSrc1SignZ( true ); I.SetSrc1SwizzleZ(SWZ_Z);      }

        } else {

                if (X == "X") { I.SetSrc0SwizzleX(SWX_X);       }

                if (X == "Y") { I.SetSrc0SwizzleX(SWX_Y);       }

                if (X == "Z") { I.SetSrc0SwizzleX(SWX_Z);       }

                if (X == "-X") { I.SetSrc0SignX( true ); I.SetSrc0SwizzleX(SWX_X);      }

                if (X == "-Y") { I.SetSrc0SignX( true ); I.SetSrc0SwizzleX(SWX_Y);      }

                if (X == "-Z") { I.SetSrc0SignX( true ); I.SetSrc0SwizzleX(SWX_Z);      }

                if (Y == "X") { I.SetSrc0SwizzleY(SWY_X);       }

                if (Y == "Y") { I.SetSrc0SwizzleY(SWY_Y);       }

                if (Y == "Z") { I.SetSrc0SwizzleY(SWY_Z);       }

                if (Y == "-X") { I.SetSrc0SignY( true ); I.SetSrc0SwizzleY(SWY_X);      }

                if (Y == "-Y") { I.SetSrc0SignY( true ); I.SetSrc0SwizzleY(SWY_Y);      }

                if (Y == "-Z") { I.SetSrc0SignY( true ); I.SetSrc0SwizzleY(SWY_Z);      }

                if (Z == "X") { I.SetSrc0SwizzleZ(SWZ_X);       }

                if (Z == "Y") { I.SetSrc0SwizzleZ(SWZ_Y);       }

                if (Z == "Z") { I.SetSrc0SwizzleZ(SWZ_Z);       }

                if (Z == "-X") { I.SetSrc0SignZ( true ); I.SetSrc0SwizzleZ(SWZ_X);      }

                if (Z == "-Y") { I.SetSrc0SignZ( true ); I.SetSrc0SwizzleZ(SWZ_Y);      }

                if (Z == "-Z") { I.SetSrc0SignZ( true ); I.SetSrc0SwizzleZ(SWZ_Z);      }

        }

}

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

void StoreReturnAddress( std::vector & aInstructions, Theia::Parser::location_type & yylloc )

{

                I.SetCode( EOPERATION_ADD );

                I.mComment = "store return address**";

                I.SetImm( aInstructions.size()+4 );

                I.SetWriteChannel(ECHANNEL_X);

                I.SetDestinationAddress( RETURN_ADDRESS_REGISTER );

                I.SetDestZero( true );

                I.mSourceLine = GetCurrentLineNumber( yylloc );

                aInstructions.push_back( I );

                I.Clear();

}

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

void SavePreviousFramePointer( std::vector & aInstructions )

{

                I.SetCode( EOPERATION_ADD );

                I.mComment = "store current frame offset";

                I.SetWriteChannel(ECHANNEL_Y);

                I.SetDestinationAddress( SPR_CONTROL_REGISTER );

                I.SetSrc1Address(SPR_CONTROL_REGISTER);

                I.SetSrc1SwizzleX(SWX_X);

                I.SetSrc1SwizzleY(SWY_X);

                I.SetSrc1SwizzleZ(SWZ_X);

                I.SetSrc0Address(0);

                I.SetSrc0SwizzleX(SWX_X);

                I.SetSrc0SwizzleY(SWY_X);

                I.SetSrc0SwizzleZ(SWZ_X);

                aInstructions.push_back( I );

                I.Clear();

}

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

void SetIndexRegister( unsigned int aIndex, std::vector & aInstructions  )

{

                Instruction Tmp;

                Tmp.SetCode( EOPERATION_ADD );

                Tmp.mComment = "store array index register";

                Tmp.SetWriteChannel(ECHANNEL_Z);

                Tmp.SetDestinationAddress( SPR_CONTROL_REGISTER );

                Tmp.SetSrc1Address( aIndex );

                Tmp.SetSrc1Displace( true );

                Tmp.SetSrc1SwizzleX(SWX_X);

                Tmp.SetSrc1SwizzleY(SWY_X);

                Tmp.SetSrc1SwizzleZ(SWZ_X);

                Tmp.SetSrc0Address(0);

                Tmp.SetSrc0SwizzleX(SWX_X);

                Tmp.SetSrc0SwizzleY(SWY_X);

                Tmp.SetSrc0SwizzleZ(SWZ_X);

                //Tmp.SetImm( aIndex );

                //Tmp.SetDestZero( true );

                aInstructions.push_back( Tmp );

}

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

void UpdateFramePointer( std::vector & aInstructions )

{

                I.SetCode( EOPERATION_ADD );

                I.mComment = "displace next frame offset by the number of auto variables in current frame";

                I.SetWriteChannel(ECHANNEL_X);

                I.SetDestinationAddress( SPR_CONTROL_REGISTER );

                I.SetImm( GetCurretAutoVarFrameSize() );

                I.SetDestZero( false );

                aInstructions.push_back( I );

                I.Clear();

}

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

void CallFunction( std::string aFunctionName,  std::vector & aInstructions, std::map  &  aSymbolMap)

{

                I.SetCode( EOPERATION_ADD );

                I.mComment = "call the function";

                I.SetBranchFlag( true );

                I.SetBranchType( EBRANCH_ALWAYS );

                //Now do the branch

                if (aSymbolMap.find(aFunctionName) == aSymbolMap.end())

                        I.SetDestinationSymbol( "@"+aFunctionName );

                else

                        I.SetDestinationAddress( aSymbolMap[ aFunctionName ] );

                aInstructions.push_back( I );

                I.Clear();

}

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

void SetDestinationFromRegister( std::string aDestination, Instruction & aInst, bool Imm  )

{

                //Look for displament addressing mode

                if (aDestination.find("OFFSET") != std::string::npos)

                {

                        aDestination.erase(aDestination.find("OFFSET"));

                        ////std::cout << "^_^ left_hand_side " << Destination << "\n";

                        if (Imm == true)

                                aInst.SetSrc0Displace( true ); //When Imm == 0, then setting this makes offset

                        else

                                aInst.SetDestZero( true ); //When Imm != 0, DestZero means DST = DSTINDEX + offset

                }

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

                {

                        aInst.ClearWriteChannel();

                        if (aDestination.find("x") != std::string::npos)

                                aInst.SetWriteChannel(ECHANNEL_X);

                        if (aDestination.find("y") != std::string::npos)

                                aInst.SetWriteChannel(ECHANNEL_Y);

                        if (aDestination.find("z") != std::string::npos)

                                aInst.SetWriteChannel(ECHANNEL_Z);

                        aDestination.erase(aDestination.find("."));

                }

                aInst.SetDestinationAddress( atoi(aDestination.c_str()+1) );

}

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

void PopulateSourceRegisters( std::string a1, std::string a2, Instruction & I, std::vector & aInstructions )

{

                        if ( a1.find("R") == std::string::npos )

                        {

                                //This is for constants

                                unsigned int ImmediateValue;

                                std::string StringHex = a1;

                                std::stringstream ss;

                                ss << std::hex << StringHex;

                                ss >> ImmediateValue;

                                I.SetImm( ImmediateValue );

                        } else {

                                if (a1.find("array_element") != std::string::npos)

                                {

                                        std::string Index = a1.substr(a1.find("array_element"));

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

                                        Index = Index.substr(Index.find_first_not_of("array_element R"));

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

                                        SetIndexRegister( atoi(Index.c_str()), aInstructions );

                                        a1.erase(a1.find("array_element"));

                                        I.SetSrc0Displace( true );

                                        I.SetSrc1Displace( true );

                                        I.SetImmBit( true );

                                }

                                        //Look for displament addressing mode

                                else if (a1.find("OFFSET") != std::string::npos)

                                {

                                        a1.erase(a1.find("OFFSET"));

                                        ////std::cout << "^_^ a1" << a1 << "\n";

                                        I.SetSrc1Displace( true ); //When Imm != 0, DestZero means DST = DSTINDEX + offset

                                }

                                std::string Src1 = a1;

                                if (IsSwizzled( Src1 ))

                                {

                                        SetSwizzleAndSign( 1, Src1,  I );

                                        Src1.erase(Src1.find("."));

                                }

                                I.SetSrc1Address( atoi( Src1.c_str()+1 ) );

                        }

                        if ( a2.find("R") == std::string::npos)

                        {

                        } else {

                                //Look for displament addressing mode

                                if (a2.find("OFFSET") != std::string::npos)

                                {

                                        a2.erase(a2.find("OFFSET"));

                                        ////std::cout << "^_^ a2 " << a2 << "\n";

                                        I.SetSrc0Displace( true ); //When Imm != 0, DestZero means DST = DSTINDEX + offset

                                }

                                std::string Src0 = a2;

                                if (IsSwizzled( Src0 ))

                                {

                                        SetSwizzleAndSign( 0, Src0,  I );

                                        Src0.erase(Src0.find("."));

                                }

                                I.SetSrc0Address( atoi( Src0.c_str()+1 ) );

                        }

}

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

void ClearNextFunctionParamRegister()

{

        gFunctionParameterIndex = FUNCTION_PARAM_START_REGION;

}

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

void AddFunctionInputList( std::string aVar, std::vector & aInstructions,Theia::Parser::location_type  yylloc)

{

        //Get the value from the variable

        //Copy the value into function parameter register

        unsigned FunctionParamReg = GetNextFunctionParamRegister();

        I.Clear();

        I.SetCode( EOPERATION_ADD );

        I.mComment = "copy the value into function parameter register";

        I.SetWriteChannel(ECHANNEL_XYZ);

        //I.SetDestZero( true ); //When Imm != 0, DestZero means DST = DSTINDEX + offset

        I.SetDestinationAddress( FunctionParamReg );

        if (aVar.find("R") != std::string::npos)

        {

                if (aVar.find("OFFSET") != std::string::npos)

                {

                        I.SetSrc1Displace( true );

                        aVar.erase(aVar.find("OFFSET"));

                }

                I.SetSrc1Address(atoi(aVar.c_str()+1));

                return;

        }

        std::string Reg = GetRegisterFromFunctionParameter( aVar );

        if (Reg == "NULL")

        {

                Reg = GetRegisterFromAutoVar( aVar, yylloc );

                I.SetSrc1Address(atoi(Reg.c_str()+1));

                I.SetSrc1Displace( true );

        } else {

                I.SetSrc1Address(atoi(Reg.c_str()+1));

                I.SetSrc1Displace( false );

        }

        I.SetSrc1SwizzleX(SWX_X);

        I.SetSrc1SwizzleY(SWY_Y);

        I.SetSrc1SwizzleZ(SWZ_Z);

        I.SetSrc0Address(0);

        I.SetSrc0SwizzleX(SWX_X);

        I.SetSrc0SwizzleY(SWY_X);

        I.SetSrc0SwizzleZ(SWZ_X);

        aInstructions.push_back( I );

        I.Clear();

}

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

void SetExpressionDestination( std::string aStringDestination, Instruction & I )

{

                std::string Destination = aStringDestination;

                //Look for indirect addressing

                if (Destination.find("INDEX") != std::string::npos)

                {

                        std::string IndexRegister = Destination.substr(Destination.find("INDEX")+5);

                        Destination.erase(Destination.find("INDEX"));

                        I.SetImm( 0 );

                        I.SetCode( EOPERATION_ADD );

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

                        {

                                I.ClearWriteChannel();

                                if (Destination.find("x") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_X);

                                if (Destination.find("y") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_Y);

                                if (Destination.find("z") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_Z);

                                Destination.erase(Destination.find("."));

                        }

                        I.SetDestinationAddress( atoi(Destination.c_str()+1) );

                } else {

                        //Look for displament addressing mode

                        if (Destination.find("OFFSET") != std::string::npos)

                        {

                                Destination.erase(Destination.find("OFFSET"));

                                I.SetDestZero( true ); //When Imm != 0, DestZero means DST = DSTINDEX + offset

                        }

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

                        {

                                I.ClearWriteChannel();

                                if (Destination.find("x") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_X);

                                if (Destination.find("y") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_Y);

                                if (Destination.find("z") != std::string::npos)

                                        I.SetWriteChannel(ECHANNEL_Z);

                                Destination.erase(Destination.find("."));

                        }

                        I.SetDestinationAddress( atoi(Destination.c_str()+1) );

                }

}

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

bool SourceNull( std::string aSource )

{

        if (aSource == "NULL")

                return true;

        return false;

}

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

void PopulateInstruction( std::string aDestination, std::string aSource1, std::string aSource0, Instruction & I, Theia::Parser::location_type  yylloc, bool aHasLiteral = false, unsigned int aLiteral = 0)

{

        bool DestinationHasOffset  = false;

        bool DetinationHasIndex    = false;

        bool Source0HasOffset      = false;

        bool Source1HasOffset      = false;

        bool Source1HasIndex       = false;

        bool Source0HasIndex       = false;

        if (aDestination.find("INDEX") != std::string::npos)

        {

                std::string ArrayIndex = aDestination.substr(aDestination.find("INDEX")+5);

                aSource1 = ArrayIndex;

                DetinationHasIndex      = true;

        }

        if (aSource1.find("INDEX") != std::string::npos)

                Source1HasIndex = true;

        if (aSource0.find("INDEX") != std::string::npos)

                Source0HasIndex = true;

        if (aDestination.find("OFFSET") != std::string::npos)

                DestinationHasOffset = true;

        if      (aSource0.find("OFFSET") != std::string::npos)

                Source0HasOffset = true;

        if      (aSource1.find("OFFSET") != std::string::npos)

                Source1HasOffset = true;

        if (IsSwizzled( aSource1 ))

                SetSwizzleAndSign( 1, aSource1,  I );

        I.SetSrc1Address( atoi( aSource1.c_str()+1 ) );

        if (IsSwizzled( aSource0 ))

                SetSwizzleAndSign( 0, aSource0,  I );

        I.SetSrc0Address( atoi( aSource0.c_str()+1 ) );

        //Fisrt take care of the destination write channel

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

                {

                        I.ClearWriteChannel();

                        if (aDestination.find("x") != std::string::npos)

                                I.SetWriteChannel(ECHANNEL_X);

                        if (aDestination.find("y") != std::string::npos)

                                I.SetWriteChannel(ECHANNEL_Y);

                        if (aDestination.find("z") != std::string::npos)

                                I.SetWriteChannel(ECHANNEL_Z);

                        aDestination.erase(aDestination.find("."));

        } else {

                I.SetWriteChannel(ECHANNEL_XYZ);

        }

        //Now set the destination Index

        I.SetDestinationAddress( atoi(aDestination.c_str()+1) );

        //Now determine the addressing mode

        //Simple addressing modes

        if (!aHasLiteral &&     !DetinationHasIndex && !Source0HasIndex && !Source1HasIndex)

        {

                I.SetAddressingMode( DestinationHasOffset,Source1HasOffset,Source0HasOffset);

                return;

        }

        I.SetImmBit( true ); //This is to set the IMM bit = 1, may be overwritten latter

        //Complex addressing modes

        if

        (

        aHasLiteral &&

        !SourceNull( aSource0 ) &&

        !Source0HasOffset &&

        !Source1HasOffset &&

        !DestinationHasOffset

        )

        {

                I.SetAddressingMode( false,false,false);

                I.SetImm( aLiteral );

        }

        else

        if

        (

        aHasLiteral &&

        !SourceNull( aSource0 ) &&

        Source0HasOffset &&

        !Source0HasIndex &&

        DestinationHasOffset

        )

        {

                I.SetAddressingMode( false,false,true);

                I.SetImm( aLiteral );

        }

        else

        if

        (

        !aHasLiteral &&

        !SourceNull( aSource1 ) &&

        !Source1HasOffset &&

        !SourceNull( aSource0 ) &&

        Source0HasOffset &&

        Source0HasIndex &&

        DestinationHasOffset

        )

        {

                I.SetAddressingMode( false,true,false);

        }

        else

        if

        (

        !aHasLiteral &&

        !Source1HasOffset &&

        !SourceNull( aSource0 ) &&

        Source0HasOffset &&

        !Source0HasIndex &&

        DestinationHasOffset &&

        DetinationHasIndex

        )

        {

                I.SetAddressingMode( false,true,true);

        }

        else

        if

        (

        aHasLiteral &&

        SourceNull( aSource0 ) &&

        !DestinationHasOffset &&

        !DetinationHasIndex

        )

        {

                I.SetAddressingMode( true,false,false);

                I.SetImm( aLiteral );

        }

        else

        if

        (

        aHasLiteral &&

        SourceNull( aSource0 ) &&

        DestinationHasOffset &&

        !DetinationHasIndex

        )

        {

                I.SetAddressingMode( true,false,true);

                I.SetImm( aLiteral );

        }

        else

        if

        (

        !aHasLiteral &&

        Source1HasOffset &&

        Source1HasIndex &&

        SourceNull( aSource0 ) &&

        DestinationHasOffset &&

        !DetinationHasIndex

        )

        {

                I.SetAddressingMode( true,true,false);

        }

        else

        if

        (

        !aHasLiteral &&

        Source1HasOffset &&

        Source1HasIndex &&

        Source0HasOffset &&

        !Source0HasIndex &&

        DestinationHasOffset &&

        !DetinationHasIndex

        )

        {

                I.SetAddressingMode( true,true,true);

        } else {

                        std::ostringstream ret;

                        ret << "Could not determine addressing mode  at line " << yylloc << " \n";

                        throw ret.str();

        }

}

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

void PopulateBoolean(EBRANCHTYPE aBranchType, std::string Source1, std::string Source0, Instruction & I, std::vector & aInstructions, Theia::Parser::location_type & yylloc )

{

                                        if (Source0.find("R") == std::string::npos)

                                        {

                                                I.mSourceLine = GetCurrentLineNumber( yylloc );

                                                I.SetCode( EOPERATION_ADD );

                                                unsigned int TempRegIndex  = GetFreeTempRegister();

                                                I.SetDestinationAddress( TempRegIndex );

                                                unsigned int ImmediateValue;

                                                std::string StringHex = Source0;

                                                std::stringstream ss;

                                                ss << std::hex << StringHex;

                                                ss >> ImmediateValue;

                                                I.SetImm( ImmediateValue );

                                                I.SetDestZero( true );

                                                I.SetSrc0Displace( true );

                                                I.SetWriteChannel(ECHANNEL_X);

                                                I.SetWriteChannel(ECHANNEL_Y);

                                                I.SetWriteChannel(ECHANNEL_Z);

                                                aInstructions.push_back(I);

                                                I.Clear();

                                                std::stringstream ss2;

                                                ss2 << "R" << TempRegIndex;

                                                ss2 >> Source0;

                                                Source0 += " OFFSET ";

                                        }

                                        else

                                                I.mSourceLine = GetCurrentLineNumber( yylloc );

                                        I.SetCode( EOPERATION_ADD );

                                        I.SetSrc0SignX( true );

                                        I.SetSrc0SignY( true );

                                        I.SetSrc0SignZ( true );

                                        I.SetBranchFlag( true );

                                        I.ClearWriteChannel();

                                        I.SetBranchType( aBranchType );

                                        PopulateSourceRegisters( Source1, Source0, I, aInstructions);

                                        aInstructions.push_back(I);

                                        I.Clear();

                                        ////std::cout << "pushing code at position " << (mInstructions.size() - 1) << "\n";

                                        gBranchStack.push_back(aInstructions.size() - 1);

                                        ResetTempRegisterIndex();

}

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

        // Prototype for the yylex function

        static int yylex(Theia::Parser::semantic_type * yylval,

                         Theia::Parser::location_type * yylloc,

                         Theia::Scanner &scanner);

}

%token AUTO RETURN FUNCTION JMP EXIT EQUAL NOT_EQUAL GREATER_THAN LESS_THAN LESS_OR_EQUAL_THAN GREATER_OR_EQUAL_THAN IF ELSE OPEN_ROUND_BRACE CLOSE_ROUND_BRACE OPEN_BRACE CLOSE_BRACE ASSIGN DIV MUL ADD DECCONST HEXCONST BINCONST EOS DOT MINUS TK_X TK_Y TK_Z TK_N REG

%token IDENTIFIER SQRT SCALE UNSCALE USING FIXED_POINT COMMA OPEN_SQUARE_BRACE CLOSE_SQUARE_BRACE WHILE ADD_EQ THREAD START BITWISE_AND BITWISE_OR OUT

%%

statement_list: //empty

        |

        statement_list statement

        |

        statement

        ;

statement

        :

        AUTO auto_var_list EOS

        |

        USING FIXED_POINT EOS

        {

                mGenerateFixedPointArithmetic = true;

        }

        |

        EXIT EOS

        {

                //Insert a stupid NOP before the exit... is a bug but easier to just patch like this...

                I.Clear();

                I.mComment = "NOP";

                I.SetCode( EOPERATION_NOP );

                mInstructions.push_back(I);

                I.Clear();

                I.SetEofFlag(true);

                I.mComment = "Set the Exit bit";

                I.SetCode( EOPERATION_ADD );

                mInstructions.push_back(I);

                I.Clear();

        }

        |

        RETURN expression EOS

        {

                //////////////////////////////////////////////////////////////////////////////

                // This means this that the expression was just a constant.

                // No operations were inserted

                //////////////////////////////////////////////////////////////////////////////

                if (gInsertedInstructions == 0)

                {

                        I.Clear();

                        I.SetCode(EOPERATION_ADD);

                        I.mComment ="Set the return value";

                        if ($3.find("R") != std::string::npos)

                        {

                                PopulateInstruction( "R1", $2,"R0 . X X X",I,yylloc);

                        }

                        else

                        {

                                unsigned int ImmediateValue = 0;

                                std::string StringHex = $3;

                                std::stringstream ss;

                                ss << std::hex << StringHex;

                                ss >> ImmediateValue;

                                PopulateInstruction( "R1", $3,"NULL",I, yylloc, true, ImmediateValue);

                        }

                        mInstructions.push_back(I);

                        I.Clear();

                } else {

                        mInstructions[ mInstructions.size() - gInsertedInstructions].mSourceLine = GetCurrentLineNumber(yylloc);

                        gInsertedInstructions = 0;

                        mInstructions.back().mComment ="Assigning return value";

                        mInstructions.back().SetDestinationAddress( RETURN_VALUE_REGISTER );

                }

                ResetTempRegisterIndex();

                I.SetCode( EOPERATION_ADD );

                I.mComment = "Restore previous function frame offset";

                I.ClearWriteChannel();

                I.SetWriteChannel(ECHANNEL_X);

                I.SetDestinationAddress( SPR_CONTROL_REGISTER );

                I.SetSrc1Address(SPR_CONTROL_REGISTER);

                I.SetSrc1SwizzleX(SWX_Y);

                I.SetSrc1SwizzleY(SWY_Y);

                I.SetSrc1SwizzleZ(SWZ_Y);

                I.SetSrc0Address(0);

                I.SetSrc0SwizzleX(SWX_X);

                I.SetSrc0SwizzleY(SWY_X);

                I.SetSrc0SwizzleZ(SWZ_X);

                mInstructions.push_back( I );

                I.Clear();

                //Now return

                I.SetImm( 0 );

                I.SetCode( EOPERATION_ADD );

                I.mComment = "return from function";

                I.SetBranchFlag( true );

                I.SetBranchType( EBRANCH_ALWAYS );

                I.SetDestinationAddress( RETURN_ADDRESS_REGISTER );

                mInstructions.push_back(I);

                I.Clear();

        }

        |

        RETURN EOS

        {

                I.SetCode( EOPERATION_ADD );

                I.mComment = "Restore previous function frame offset";

                I.SetWriteChannel(ECHANNEL_X);

                I.SetDestinationAddress( SPR_CONTROL_REGISTER );

                I.SetSrc1Address(SPR_CONTROL_REGISTER);