#include "ps1.0_program.h"

#include "nvparse_errors.h"
#include "nvparse_externs.h"


#include <string>
#include <map>
#include <algorithm>
#include <set>

#include <cstdlib>
#include <cstring>
#include <cassert>

using namespace std;
using namespace ps10;
struct ltstr
{
    bool operator()(const char* s1, const char* s2) const
    {
        return strcmp(s1, s2) < 0;
    }
};

#define DBG_MESG(msg, line)     errors.set(msg, line)
//#define DBG_MESG(msg, line)
namespace ps10
{
    std::map<int, std::pair<int,int> > constToStageAndConstMap;
    std::vector<int> constToStageArray;
    std::map<int, int> stageToConstMap; // to keep track of which constants have been used up for this stage.
        // r-value of 0 means none, r-value of 1 means c0 used, and r-value of 2 means both used.
    //std::map<int, int> constToStageMap;
    // std::map<int, GLenum> stageToTargetMap;
    std::map<int, int> stageToTargetMap;
    std::set<const char*, ltstr> alphaBlueRegisters; // Keeps track of whether the result of a register
        // was a dp3, if a register is in this set, it means that if it is used a source for the alpha 
        // component the blue component should be used, and not the alpha component.
    void SetFinalCombinerStage();
}

void RemoveFromAlphaBlue(std::string s)
{
    std::set<const char*, ltstr>::iterator iter = 
        ps10::alphaBlueRegisters.find(s.c_str());
    if (iter != alphaBlueRegisters.end())
        alphaBlueRegisters.erase(iter);
}

/*
void AddToMap(string s, int stage)
{
    const char* cstr = s.c_str();
    if (cstr[0] == 'c')
    {
        int constNum = atoi(&cstr[1]);
        if (constNum < 0 || constNum > 7)
            return;
        constToStageMap[constNum] = stage;
    }
}
*/

// bool AddToMap(string s, int stage, GLenum& constVal)
// {
//     const char* cstr = s.c_str();
//     if (cstr[0] == 'c')
//     {
//         int constNum = atoi(&cstr[1]);
//         std::map<int, int>::iterator iter = stageToConstMap.find(stage);
//         if (iter == stageToConstMap.end())
//         {
//             // no constants used for this stage. 
//             std::pair<int, int> temp;
//             temp.first = stage;
//             temp.second = 0;
//             constToStageAndConstMap[constNum] = temp;
//             stageToConstMap[stage] = 0;
//             constVal = 0;
//             constToStageArray.push_back(constNum);
//             constToStageArray.push_back(stage);
//             constToStageArray.push_back(constVal);
//         }
//         else
//         {
//             int constUsed = (*iter).second;
//             if (constUsed >= 1)
//                 return false;
//             else // const0 has been used, so use const1 for this stage.
//             {
//                 std::pair<int,int> temp;
//                 temp.first = stage;
//                 temp.second = 1;
//                 constToStageAndConstMap[constNum] = temp;
//                 stageToConstMap[stage] = 1;
//                 constVal = 1;
//                 constToStageArray.push_back(constNum);
//                 constToStageArray.push_back(stage);
//                 constToStageArray.push_back(constVal);
//             }
            
//         }
//     }
//     constVal += GL_CONSTANT_COLOR0_NV;
//     return true;
// }

bool IsLegalTarget(int target)
{
//     if (target == GL_TEXTURE_CUBE_MAP_ARB)
//         return true;
//     if (target == GL_TEXTURE_3D)
//         return true;
// #if defined(GL_EXT_texture_rectangle)
//     if (target == GL_TEXTURE_RECTANGLE_EXT)
//         return true;
// #elif defined(GL_NV_texture_rectangle)
//         if (target == GL_TEXTURE_RECTANGLE_NV)
//                 return true;
// #endif
//     if (target == GL_TEXTURE_2D)
//         return true;
//     if (target == GL_TEXTURE_1D)
//         return true;
    assert(false);
    return false;
}

bool ps10_set_map(const std::vector<int>& argv)
{
    if (argv.size() % 2 != 0)
    {
        errors.set("Odd number of arguments for texture target map.");
        return false;
    }
    for (unsigned int i=0;i<argv.size();i=i+2)
    {
        int stage = argv[i];
        int target = argv[i+1];
        if (!IsLegalTarget(target))
        {
            errors.set("Illegal target in texture target map.");
            return false;
        }
        ps10::stageToTargetMap[stage] = target;
    }
    return true;
}

int const_to_combiner_reg_mapping[32][3]; // each 3 tuple is: (constant#, stage #, reg #)
int const_to_combiner_reg_mapping_count = 0;


namespace
{
    struct set_constants
    {
        void operator() (constdef c)
        {
            if(c.reg[0] != 'c' && c.reg.size() != 2)
                DBG_MESG("def line must use constant registers", 0);
            int reg = c.reg[1] - '0';
            // GLenum stage = GL_COMBINER0_NV + (reg / 2);
            // GLenum cclr  = GL_CONSTANT_COLOR0_NV + (reg % 2);

            // GLfloat cval[4];
            // cval[0] = c.r;
            // cval[1] = c.g;
            // cval[2] = c.b;
            // cval[3] = c.a;
            // glCombinerStageParameterfvNV(stage, cclr, cval);
            assert(false);
        }
    };

//     GLenum get_tex_target(int stage)
//     {
//         std::map<int, GLenum>::iterator iter = stageToTargetMap.find(stage);
//         if (iter != stageToTargetMap.end())
//             return (*iter).second;
//         // If no mapping set, use the current state. This will not work correctly, in general,
//         // if nvparse was invoked within a display list.
//         if(glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
//             return GL_TEXTURE_CUBE_MAP_ARB;
//         if(glIsEnabled(GL_TEXTURE_3D))
//             return GL_TEXTURE_3D;
// #if defined(GL_EXT_texture_rectangle)
//         if(glIsEnabled(GL_TEXTURE_RECTANGLE_EXT))
//             return GL_TEXTURE_RECTANGLE_EXT;
// #elif defined(GL_NV_texture_rectangle)
//                 if(glIsEnabled(GL_TEXTURE_RECTANGLE_NV))
//                         return GL_TEXTURE_RECTANGLE_NV;
// #endif
//         if(glIsEnabled(GL_TEXTURE_2D))
//             return GL_TEXTURE_2D;
//         if(glIsEnabled(GL_TEXTURE_1D))
//             return GL_TEXTURE_1D;

//         //otherwise make the op none...
//         return GL_NONE;
//     }

    

    struct set_texture_shaders
    {
        set_texture_shaders(vector<constdef> * cdef)
        {
            for(stage = 0; stage < 4; stage++)
            {
                // glActiveTextureARB(GL_TEXTURE0_ARB + stage);
                // glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
                assert(false);
            }
            stage = 0;
            c = cdef;
        }

        void operator() (vector<string> & instr)
        {
            // if(stage > 3)
            //     return;
            // glActiveTextureARB(GL_TEXTURE0_ARB + stage);

            // string op = instr[0];
            // if(op == "tex")
            // {
            //     if(instr.size() != 2)
            //         fprintf(stderr,"incorrect \"tex\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, get_tex_target(stage));
            // }
            // else if(op == "texbem")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texbem\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_NV);
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texbem\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texbeml")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texbeml\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_OFFSET_TEXTURE_2D_SCALE_NV);
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texbeml\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texcoord")
            // {
            //     if(instr.size() != 2)
            //         fprintf(stderr,"incorrect \"texcoord\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_PASS_THROUGH_NV);
            // }
            // else if(op == "texkill")
            // {
            //     if(instr.size() != 2)
            //         fprintf(stderr,"incorrect \"texkill\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_CULL_FRAGMENT_NV);
            // }
            // else if(op == "texm3x2pad")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x2pad\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x2pad\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texm3x2tex")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x2tex\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_TEXTURE_2D_NV);
            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x2tex\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texm3x3pad")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x3pad\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_NV);
            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x3pad\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texm3x3tex")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x3tex\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;

            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV);

            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x3tex\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texm3x3spec")
            // {
            //     if(instr.size() != 4 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x3spec\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;

            //     if(! c)
            //         return;
            //     constdef cd;
            //     for(int i = c->size()-1; i >= 0; i--)
            //     {
            //         cd = (*c)[i];
            //         if(cd.reg == "c0")
            //             break;
            //     }

            //     if(cd.reg != "c0" || instr[3] != "c0")
            //         return;
            //     GLfloat eye[4];
            //     eye[0] = cd.r;
            //     eye[1] = cd.g;
            //     eye[2] = cd.b;
            //     eye[3] = cd.a;

            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV);
            //     glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_CONST_EYE_NV, eye);

            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x3tex\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texm3x3vspec")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texm3x3vspec\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;

            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);

            //     if(instr[2].find("_bx2") != string::npos)
            //     {
            //        instr[2].erase(instr[2].begin() + instr[2].find("_bx2"), instr[2].end());
            //        glTexEnvi(GL_TEXTURE_SHADER_NV, GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL_EXPAND_NORMAL_NV);
            //     }
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texm3x3tex\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texreg2ar")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texreg2ar\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DEPENDENT_AR_TEXTURE_2D_NV);
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texreg2ar\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            // else if(op == "texreg2gb")
            // {
            //     if(instr.size() != 3 || stage == 0)
            //         fprintf(stderr,"incorrect \"texreg2gb\" instruction, stage %d...\n", stage);
            //     reg2stage[instr[1]] = stage;
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_DEPENDENT_GB_TEXTURE_2D_NV);
            //     if(reg2stage.count(instr[2]) == 0)
            //         fprintf(stderr,"incorrect \"texreg2gb\" instruction, stage %d...\n", stage);
            //     glTexEnvi(GL_TEXTURE_SHADER_NV, GL_PREVIOUS_TEXTURE_INPUT_NV, GL_TEXTURE0_ARB + reg2stage[instr[2]]);
            // }
            assert(false);
            stage++;
        }

        map<string, int> reg2stage;
        int stage;
        vector<constdef> * c;
    };
    
    // GLenum reg_enum(string s, int stage)
    // {
    //     /*if(s == "c0")
    //         return GL_CONSTANT_COLOR0_NV;
    //     else if(s == "c1")
    //         return GL_CONSTANT_COLOR1_NV;
    //     else if(s == "c2")
    //         return GL_CONSTANT_COLOR0_NV;
    //     else if(s == "c3")
    //         return GL_CONSTANT_COLOR1_NV;
    //     else if(s == "c4")
    //         return GL_CONSTANT_COLOR0_NV;
    //     else if(s == "c5")
    //         return GL_CONSTANT_COLOR1_NV;
    //     else if(s == "c6")
    //         return GL_CONSTANT_COLOR0_NV;
    //     else if(s == "c7")
    //         return GL_CONSTANT_COLOR1_NV;
    //         */
    //     if (s == "c0" || s == "c1" || s == "c2" || s == "c3" || 
    //         s == "c4" || s == "c5" || s == "c6" || s == "c7")
    //     {
    //         GLenum result;
    //         if (!AddToMap(s,stage,result))
    //             errors.set("Illegal constant usage.",line_number);
    //           // This is a pain, since the caller is a void and no check is made for errors. Sigh.
    //         return result;
    //     }
    //     else if(s == "t0")
    //         return GL_TEXTURE0_ARB;
    //     else if(s == "t1")
    //         return GL_TEXTURE1_ARB;
    //     else if(s == "t2")
    //         return GL_TEXTURE2_ARB;
    //     else if(s == "t3")
    //         return GL_TEXTURE3_ARB;
    //     else if(s == "v0")
    //         return GL_PRIMARY_COLOR_NV;
    //     else if(s == "v1")
    //         return GL_SECONDARY_COLOR_NV;
    //     else if(s == "r0")
    //         return GL_SPARE0_NV;
    //     else if(s == "r1")
    //         return GL_SPARE1_NV;
    //     else // ??
    //         return GL_DISCARD_NV;
    // }

    struct src
    {
        src(string s, int stage, string *regname=NULL)
        {
            init(s, stage, regname);
        }


        void init(string s, int stage, string *regname=NULL)
        {
            arg = s;
            // comp = GL_RGB;
            // alphaComp = GL_ALPHA;
            // map = GL_SIGNED_IDENTITY_NV;

            // unsigned int offset;
            // if(
            //     (offset = s.find(".a")) != string::npos ||
            //     (offset = s.find(".w")) != string::npos
            //   )
            // {
            //     comp = GL_ALPHA;
            //     s.erase(offset, offset+2);
            // }
            // else if ((offset = s.find(".b")) != string::npos ||
            //          (offset = s.find(".z")) != string::npos)
            // {
            //     alphaComp = GL_BLUE;
            //     s.erase(offset,offset+2);
            // }

            // bool negate = false;

            // if(s[0] == '1')
            // {
            //     s.erase(0, 1);
            //     while(s[0] == ' ')
            //         s.erase(0,1);
            //     if(s[0] == '-')
            //         s.erase(0,1);
            //     while(s[0] == ' ')
            //         s.erase(0,1);
            //     map = GL_UNSIGNED_INVERT_NV;
            // }
            // else if(s[0] == '-')
            // {
            //     s.erase(0, 1);
            //     while(s[0] == ' ')
            //         s.erase(0,1);
            //     negate = true;
            //     map = GL_UNSIGNED_INVERT_NV;
            // }

            // bool half_bias = false;
            // bool expand = false;
            // if(s.find("_bias") != string::npos)
            // {
            //     s.erase(s.find("_bias"), 5);
            //     half_bias = true;
            // }
            // else if(s.find("_bx2") != string::npos)
            // {
            //     s.erase(s.find("_bx2"), 4);
            //     expand = true;
            // }
            
            // if(expand)
            // {
            //     if(negate)
            //         map = GL_EXPAND_NEGATE_NV;
            //     else
            //         map = GL_EXPAND_NORMAL_NV;
            // }
            // else if(half_bias)
            // {
            //     if(negate)
            //         map = GL_HALF_BIAS_NEGATE_NV;
            //     else
            //         map = GL_HALF_BIAS_NORMAL_NV;
            // }
            // reg = reg_enum(s,stage);

            // if (regname != NULL) 
            //     *regname = s; // return the bare register name

            
            // //alphaComp = GL_ALPHA;
            // std::set<const char*, ltstr>::iterator iter = 
            //     ps10::alphaBlueRegisters.find(s.c_str());
            // if (iter != ps10::alphaBlueRegisters.end())
            //     alphaComp = GL_BLUE;
            assert(false);

        }

        string arg;
        // GLenum reg;
        // GLenum map;
        // GLenum comp;
        // GLenum alphaComp;
    };


    struct set_register_combiners
    {
        set_register_combiners()
        {
          // combiner = 0;
          combiner = -1;
        }

        void operator() (vector<string> & instr)
        {
            string op;
            int scale = SCALE_NONE;
            bool op_sat = false;
            bool paired_instr = false;
            int instr_base = 0;
            if (instr[0]=="+") {
              paired_instr = true;
              instr_base = 1;
            }
            op = instr[instr_base];
            size_t offset;
            if((offset = op.find("_x2")) != string::npos)
            {
                scale = SCALE_BY_TWO;
                op.erase(op.begin()+offset, op.begin()+offset+3);
            }
            else if((offset = op.find("_x4")) != string::npos)
            {
                scale = SCALE_BY_FOUR;
                op.erase(op.begin()+offset, op.begin()+offset+3);
            }
            else if((offset = op.find("_d2")) != string::npos)
            {
                scale = SCALE_BY_ONE_HALF;
                op.erase(op.begin()+offset, op.begin()+offset+3);
            }

            if((offset = op.find("_sat")) != string::npos)
            {
                // need to actually use this...
                op_sat = true;
                op.erase(op.begin()+offset, op.begin()+offset+4);
            }
            
            string dst = instr[1+instr_base];
            int mask = MASK_RGBA;
            if(
                (offset = dst.find(".rgba")) != string::npos  ||
                (offset = dst.find(".xyzw")) != string::npos 
                )
            {
                dst.erase(offset, offset + 5);
            }
            else if(
                (offset = dst.find(".rgb")) != string::npos  ||
                (offset = dst.find(".xyz")) != string::npos 
                )
            {
                dst.erase(offset, offset + 4);
                mask = MASK_RGB;
            }
            else if(
                (offset = dst.find(".a")) != string::npos  ||
                (offset = dst.find(".w")) != string::npos 
                )
            {
                dst.erase(offset, offset + 2);
                mask = MASK_ALPHA;
            }

            if (!paired_instr) 
              combiner++;

            // GLenum dreg = reg_enum(dst,combiner);
            // GLenum C = GL_COMBINER0_NV + combiner;

            bool isAlphaBlue = false; // To keep track of whether the dst register's alpha was its blue value.

            // if(op == "add" || op == "sub")
            // {
            //     src a(instr[2+instr_base],combiner);
            //     src b(instr[3+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_C_NV, b.reg, b.map, b.comp);
            //         if(op == "add")
            //             glCombinerInputNV(C, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         else
            //             glCombinerInputNV(C, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO, GL_EXPAND_NORMAL_NV, GL_RGB);
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_C_NV, b.reg, b.map, b.alphaComp);
            //         if(op == "add")
            //             glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         else
            //             glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_D_NV, GL_ZERO, GL_EXPAND_NORMAL_NV, GL_ALPHA);
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "cnd")
            // {
            //     src a(instr[3+instr_base],combiner);
            //     src b(instr[4+instr_base],combiner);

            //     if(instr[2+instr_base] != "r0.a" && instr[2+instr_base] != "r0.w")
            //     {} // bad
            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_C_NV, b.reg, b.map, b.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_TRUE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_C_NV, b.reg, b.map, b.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_D_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_TRUE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "dp3")
            // {
            //     src a(instr[2+instr_base],combiner);
            //     src b(instr[3+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
            //         glCombinerOutputNV(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
            //             GL_TRUE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         // ooh.. what to do here?
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         // todo -- make next ref to dst.a actually ref dst.b since combiners can't write dp3 to the alpha channel
            //         // Done by Ashu: Put this register in the alphaBlueRegister set. 
            //         isAlphaBlue = true;
            //         ps10::alphaBlueRegisters.insert(dst.c_str());
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "lrp")
            // {
            //     src a(instr[2+instr_base],combiner);
            //     src b(instr[3+instr_base],combiner);
            //     src c(instr[4+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, GL_UNSIGNED_IDENTITY_NV, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_C_NV, a.reg, GL_UNSIGNED_INVERT_NV, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_D_NV, c.reg, c.map, c.comp);
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, GL_UNSIGNED_IDENTITY_NV, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_C_NV, a.reg, GL_UNSIGNED_INVERT_NV, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_D_NV, c.reg, c.map, c.alphaComp);
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "mad")
            // {
            //     src a(instr[2+instr_base],combiner);
            //     src b(instr[3+instr_base],combiner);
            //     src c(instr[4+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);                   
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_D_NV, c.reg, c.map, c.comp);
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_C_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_D_NV, c.reg, c.map, c.alphaComp);
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, dreg, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "mov")
            // {
            //     src a(instr[2+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_RGB);
            //         glCombinerOutputNV(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, GL_ZERO, GL_UNSIGNED_INVERT_NV, GL_ALPHA);
            //         glCombinerOutputNV(C, GL_ALPHA, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            // else if(op == "mul")
            // {
            //     src a(instr[2+instr_base],combiner);
            //     src b(instr[3+instr_base],combiner);

            //     if(mask == GL_RGBA || mask == GL_RGB)
            //     {
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_A_NV, a.reg, a.map, a.comp);
            //         glCombinerInputNV(C, GL_RGB, GL_VARIABLE_B_NV, b.reg, b.map, b.comp);
            //         glCombinerOutputNV(C, GL_RGB, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }

            //     if(mask == GL_RGBA || mask == GL_ALPHA)
            //     {
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_A_NV, a.reg, a.map, a.alphaComp);
            //         glCombinerInputNV(C, GL_ALPHA, GL_VARIABLE_B_NV, b.reg, b.map, b.alphaComp);
            //         glCombinerOutputNV(C, GL_ALPHA, dreg, GL_DISCARD_NV, GL_DISCARD_NV, scale, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            //     else if (!paired_instr)
            //     {
            //         glCombinerOutputNV(C, GL_ALPHA, GL_DISCARD_NV, GL_DISCARD_NV, GL_DISCARD_NV, GL_NONE, GL_NONE,
            //                            GL_FALSE, GL_FALSE, GL_FALSE);
            //     }
            // }
            assert(false);

            // combiner++;
            if (!isAlphaBlue)
                RemoveFromAlphaBlue(dst);
        }

        int combiner;
    };


}

void ps10::SetFinalCombinerStage()
{
    // glFinalCombinerInputNV(GL_VARIABLE_A_NV,GL_FOG,GL_UNSIGNED_IDENTITY_NV,GL_ALPHA);
    // glFinalCombinerInputNV(GL_VARIABLE_B_NV,GL_SPARE0_NV,
    //         GL_UNSIGNED_IDENTITY_NV,GL_RGB);
    // glFinalCombinerInputNV(GL_VARIABLE_C_NV,GL_FOG,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
    // glFinalCombinerInputNV(GL_VARIABLE_D_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
    // glFinalCombinerInputNV(GL_VARIABLE_E_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
    // glFinalCombinerInputNV(GL_VARIABLE_F_NV,GL_ZERO,GL_UNSIGNED_IDENTITY_NV,GL_RGB);
    // std::set<const char*, ltstr>::iterator iter = ps10::alphaBlueRegisters.find("r0");
    // GLenum alphaComp = GL_ALPHA;
    // if (iter != ps10::alphaBlueRegisters.end())
    //     alphaComp = GL_BLUE;
    // glFinalCombinerInputNV(GL_VARIABLE_G_NV,GL_SPARE0_NV,GL_UNSIGNED_IDENTITY_NV,alphaComp);
    assert(false);
    // We can now clear alphaBlueRegisters for the next go around
    alphaBlueRegisters.clear();
}

void ps10::invoke(vector<constdef> * c,
                  list<vector<string> > * a,
                  list<vector<string> > * b)
{
    const_to_combiner_reg_mapping_count = 0; // Hansong


    // glEnable(GL_PER_STAGE_CONSTANTS_NV); // should we require apps to do this?
    // if(c)
    //     for_each(c->begin(), c->end(), set_constants());
    // if(a)
    //     for_each(a->begin(), a->end(), set_texture_shaders(c));
    // glActiveTextureARB( GL_TEXTURE0_ARB );
    // int numCombiners = 0;
    // list<vector<string> >::iterator it = b->begin();
    // for(; it!=b->end(); ++it) {
    //   if ( (*it)[0] != "+" )
    //     numCombiners++;
    // }
    // glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, numCombiners);
    assert(false);
    if(b)
        for_each(b->begin(), b->end(), set_register_combiners());
    SetFinalCombinerStage();
    // We can clear the stageToTarget map now.
    stageToTargetMap.clear();
}

// simple identification - just look for magic substring
//  -- easy to break...
bool is_ps10(const char * s)
{
    if(strstr(s, "ps.1.0"))
        return true;
    if(strstr(s, "Ps.1.0"))
        return true;
    if(strstr(s, "ps.1.1"))
        return true;
    if(strstr(s, "Ps.1.1"))
        return true;
    return false;
}

// bool ps10::init_extensions()
// {
//     // register combiners   
//     static bool rcinit = false;
//     if(rcinit == false)
//     {
//         if(! glh_init_extensions("GL_NV_register_combiners"))
//         {
//             errors.set("unable to initialize GL_NV_register_combiners\n");
//             return false;
//         }
//         else
//         {
//             rcinit = true;
//         }
//     }

//     // register combiners 2
//     static bool rc2init = false;
//     if(rc2init == false)
//     {
//         if( ! glh_init_extensions("GL_NV_register_combiners2"))
//         {
//             errors.set("unable to initialize GL_NV_register_combiners2\n");
//             return false;
//         }
//         else
//         {
//             rc2init = true;
//         }
//     }
    
//     static bool tsinit = 0; 
//     if (tsinit == false )
//     {
//         if(! glh_init_extensions( "GL_NV_texture_shader " "GL_ARB_multitexture " ))
//         {
//             errors.set("unable to initialize GL_NV_texture_shader\n");
//             return false;
//         }
//         else
//         {
//             tsinit = true;
//         }
//     }
//     constToStageAndConstMap.clear();
//     constToStageArray.clear();
//     stageToConstMap.clear();
//     line_number = 1;
//     return true;
// }

const int* ps10_get_info(int* pcount)
{
    if (pcount)
        *pcount = constToStageArray.size();
    return &(constToStageArray[0]);
}
