ivannosys3/src/target/mips/TListenerMips.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package target.mips;

import API.Api;
import API.Utils;
import java.util.ArrayList;
import java.util.HashMap;
import template.TPLInterface;
import template.TemplateCtx;
import template.TemplateParser;

/**
 *
 * @author EUGENIO CARVALHO
 */
class TListenerMips extends template.TListener {

    public HashMap<String, TPLInterface> templates;
//    public int AddressGap = 1;

    public TListenerMips(TemplateCtx ctx, TemplateCtx gctx) {
        super(ctx, gctx);
    }

    @Override
    public void exitCall(TemplateParser.CallContext ctx) {
        ArrayList<String> arguments = ExecCall(ctx);

        if (Utils.Empty(this.returnCall)) {
            switch (ctx.ID().getText()) {
                case "OFFSET":
                    this.returnCall = OFFSET(arguments);
                    break;
                case "INSTHEX":
                    this.returnCall = INSTHEX(arguments);
                    break;
                case "INSTDEC":
                    this.returnCall = INSTDEC(arguments);
                    break;
                case "INSTBIN":
                    this.returnCall = INSTBIN(arguments);
                    break;
                case "BIN":
                    this.returnCall = BIN(arguments);
                case "RBIN":
                    this.returnCall = RBIN(arguments);
                    break;
            }
        }
    }

    public String OFFSET(ArrayList<String> args) {
        return args.get(0) + "(" + args.get(1) + ")";
    }

    @Override
    protected String L(ArrayList<String> arguments) {

        String label = arguments.get(0).trim();

        if (label.equals("")) {
            return label;
        }

        String format = (arguments.size() > 1) ? arguments.get(1) : "dec",
                // Corresponde ao nome do label que marca o inicio do bloco 
                base = gctx.G("label." + label).split("\\+")[0],
                // Corresponde ao endereco do label base (decimal)
                baseAddress = gctx.G(base),
                // Corresponde a posicao do label destino (decimal)
                laddress = gctx.G(label);

        System.out.printf("TemplateListener:{%s\n %s\n %s\n %s\n}\n", base, baseAddress, label, laddress);
        int value = Integer.parseInt(laddress);
        int fromStart = value - Integer.parseInt(baseAddress);

        switch (ctx.G("type")) {
            case "I": // (bne...) Salta para posicao em relacao ao pc atual

//                System.out.println("TemplateListenerLabel::" + base + "|" + laddress + "|" + baseAddress + "|\n" + ctx);
//                System.out.println("I Branch:{{\n" + base
//                        + "\n:" + Integer.parseInt(gctx.G(base))
//                        + "\n:" + label
//                        + "\n:" + value
//                        + "\n:" + FormatNum(value, format)
//                        + "\n}}");
//                System.out.println("Tranalate>>>>>>>>> I:[" + address + "]" + ctx);
                //                address -= Integer.parseInt(ctx.G("block.position"));
                break;
            case "J": // (j | jal) Salta para o endereco de destino
//                System.out.println(">>>>" + label + ":" + format + ":" + value + ":" + FormatNum(value, format));
//                address = valueint;
                break;
            default:
                System.out.println(String.format("Label type '%s' not defined", ctx.G("type")));
        }
//        address = address * this.AddressGap;
//        value = value * this.AddressGap;
//        System.out.println("============LaBEL:" + label + ":" + format + ":" + value + ":" + base);
//        System.out.println("============LaBEL:" + value + ":" + address);

        return laddress.trim().equals("")
                ? ""
                : (FormatNum(value, format) + " <" + base + "+0x" + FormatNum(fromStart, format) + ">");
    }

    // Converte um binario para hex
    protected String INSTHEX(ArrayList<String> arguments) {
        try {
            String bin = INSTBIN(arguments);
            if (Utils.Empty(bin)) {
                return "";
            }
            String hex = PAD(Long.toString(Long.parseLong(bin, 2), 16), "0", 8);
            ctx.Set("inst.hex", hex);
            return hex;

        } catch (Exception e) {
            if (ctx.G("inst").equals("bgtz")) {
                System.out.println("hex-Error:" + e.getMessage());
                e.printStackTrace();
            }
            return "error!";
        }
    }

//    100111101111011111111111111000 == addiu sp,sp,-8
    protected String INSTDEC(ArrayList<String> arguments) {
        try {
            String bin = INSTBIN(arguments);
            if (Utils.Empty(bin)) {
                return "";
            }

//            System.out.println("Convertendo bin :" + arguments + ":" + bin + ":dec:" + Long.parseLong(bin, 2));
            String dec = PAD("" + Long.parseLong(bin, 2), "0", 10);
            ctx.Set("inst.dec", dec);
            return dec;

        } catch (Exception e) {
            if (ctx.G("inst").equals("bgtz")) {
                System.out.println("hex-Error:" + e.getMessage());
                e.printStackTrace();
            }
            return "error!";
        }

    }

    protected String INSTBIN(ArrayList<String> arguments) {
        String type = ctx.G("type");
        if (type.equals("label")) {
            return "";
        }

        long shift;
        //
        switch (type) {
            case "S": // (j | jal) Salta para o endereco de destino
//                System.out.println("instbin:" + ctx);
                break;
            case "J": // (j | jal) Salta para o endereco de destino
//                System.out.println("JUMP:" + gctx.G(ctx.G("label")) + ":"
//                        + (Long.parseLong(gctx.G(ctx.G("label")), 10) >> 2));

                shift = (Long.parseLong(gctx.G(ctx.G("label")), 10) >> 2);
                ctx.Set("target", BIN("" + shift, 26));
                break;
            case "I": // (bne...) Salta para posicao em relacao ao pc atual + 4
//                System.out.println("BIN iiiiii" + ctx);
//                shift = (Long.parseLong(gctx.G(ctx.G("label")), 10) >> 2);
//                ctx.Set("target", BIN("" + shift, 26));

//                if (ctx.G("offset").equals("") && !ctx.G("label").equals("")) {
//
//                    int target = Integer.parseInt(gctx.G(ctx.G("label")));
//                    int position = Integer.parseInt(ctx.G("global.position")) + 1;
//
////                    System.out.println("INSTBIN:->" + FormatNum(target - position, "hex"));
//                    ctx.Set("offset", (target - position) + "");
//
//                }
//                System.out.println("INSTBIN[" + type + ":" + bin + "]:" + ctx);
                break;
            case "R": // (bne...) Salta para posicao em relacao ao pc atual
//                System.out.println("INSTBIN[" + type + "]:" + ctx);
                break;
            default:
        }
        String bin = templates.get("bin." + type).Render(ctx);
        ctx.Set("inst.bin", bin);
//        System.out.println("bin." + type + "::" + bin);
        return bin;
    }

    protected String BIN(ArrayList<String> arguments) {
//        System.out.println("BIN(" + arguments + ")");
        return BIN(arguments.get(0), arguments.get(1));
    }

    protected String BIN(String val, String pad) {
        return BIN(val, Integer.parseInt(pad));
    }

    protected String BIN(String val, int pad) {
        return Api.num2bin(val, pad);
    }

    protected String RBIN(ArrayList<String> arguments) {
//        System.out.println("RBIN(" + arguments + ")");
        String reg = arguments.get(0);
        if (reg.equals("")) {
            reg = "0";
        }
        if (!Utils.isNumber(reg)) {
            reg = Mips.Register(reg);
        }
        return Api.num2bin(reg, Integer.parseInt(arguments.get(1)));
    }

}