//  /*--------------------------------------------------------*\
//  |   Main Program: BL Disassembler
//  |*--------------------------------------------------------*|
//  |   Date:    November 15, 1999
//  |   Author:  Paolo Bucci
//  |
//  |   Brief User's Manual:
//  |   
//  |       Disassembler < input > output
//  |   
//  |
//  \*--------------------------------------------------------*/


///-------------------------------------------------------------
/// Global Context ---------------------------------------------
///-------------------------------------------------------------

#include "RESOLVE_Foundation.h"

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

enumeration Instruction_Codes
{
    MOVE,
    TURNLEFT,
    TURNRIGHT,
    INFECT,
    SKIP,
    HALT,
    JUMP,
    JUMP_IF_NOT_NEXT_IS_EMPTY,
    JUMP_IF_NOT_NEXT_IS_NOT_EMPTY,
    JUMP_IF_NOT_NEXT_IS_WALL,
    JUMP_IF_NOT_NEXT_IS_NOT_WALL,
    JUMP_IF_NOT_NEXT_IS_FRIEND,
    JUMP_IF_NOT_NEXT_IS_NOT_FRIEND,
    JUMP_IF_NOT_NEXT_IS_ENEMY,
    JUMP_IF_NOT_NEXT_IS_NOT_ENEMY,
    JUMP_IF_NOT_RANDOM,
    JUMP_IF_NOT_TRUE
};

///-------------------------------------------------------------
/// Global operations ------------------------------------------
///-------------------------------------------------------------

///-------------------------------------------------------------
/// Global operation bodies ------------------------------------
///-------------------------------------------------------------

procedure_body To_Text_With_Padding (
        preserves Integer i,
	preserves Integer w,
	produces Text& t
    )
{
    object Text tmp;

    tmp = To_Text (i);
    while (tmp.Length () < w)
    {
	tmp.Add (0, ' ');
    }
    t &= tmp;
}

///-------------------------------------------------------------
/// Interface --------------------------------------------------
///-------------------------------------------------------------

program_body main ()
{
    object Character_IStream ins;
    object Character_OStream outs;
    object Integer index, length, next, width = 5;
    object Text t;

    // Open input and output streams
    
    ins.Open_External ("");
    outs.Open_External ("");

    ins >> length;
    while (index < length)
    {
        ins >> next;
	To_Text_With_Padding (index, width, t);
	outs << t << "\t";
	case_select (next)
	{
	    case MOVE:
	    {
		outs << "MOVE";
	    }
	    break;

	    case TURNLEFT:
	    {
		outs << "TURNLEFT";
	    }
	    break;
	    
	    case TURNRIGHT:
	    {
		outs << "TURNRIGHT";
	    }
	    break;
	    
	    case INFECT:
	    {
		outs << "INFECT";
	    }
	    break;
	    
	    case HALT:
	    {
		outs << "HALT";
	    }
	    break;

	    case SKIP:
	    {
		outs << "SKIP";
	    }
	    break;
	    
	    case JUMP:
	    {
		outs << "JUMP\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_EMPTY:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_EMPTY\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_NOT_EMPTY:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_NOT_EMPTY\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_WALL:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_WALL\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_NOT_WALL:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_NOT_WALL\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_FRIEND:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_FRIEND\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_NOT_FRIEND:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_NOT_FRIEND\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_ENEMY:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_ENEMY\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_NEXT_IS_NOT_ENEMY:
	    {
		outs << "JUMP_IF_NOT_NEXT_IS_NOT_ENEMY\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_RANDOM:
	    {
		outs << "JUMP_IF_NOT_RANDOM\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	    
	    case JUMP_IF_NOT_TRUE:
	    {
		outs << "JUMP_IF_NOT_TRUE\n";
		index++;
		ins >> next;
		To_Text_With_Padding (index, width, t);
		outs << t << "\t" << next;
	    }
	    break;
	}
	outs << "\n";
        index++;
    }

    // Close streams

    ins.Close_External ();
    outs.Close_External ();
}