예제 #1
0
 public Instruction(EP_InstCode cmd, Merker param = null, CodeNode cn = null)
 {
     _param = param;
     _cn    = cn;
     _blob  = false;
     Prepare(cmd);
 }
예제 #2
0
            public void AddInst(EP_InstCode ic, int pop = 0, int push = 0)
            {
                int         i;
                Instruction inst;

                for (i = 0; i < pop; i++)
                {
                    _compiler._sp.Pop();
                }
                code.Add(inst = new Instruction(ic));
                for (i = 0; i < push; i++)
                {
                    _compiler._sp.Push(inst);
                }
            }
예제 #3
0
            private void Prepare(EP_InstCode cmd)
            {
                int  tmp_d;
                uint tmp_D;

                switch (cmd)
                {
                case EP_InstCode.LABEL:
                    if (_code == null || _code.Length != 0)
                    {
                        _code = new byte[0];
                    }
                    break;

                case EP_InstCode.NOP:
                case EP_InstCode.DUP:
                case EP_InstCode.DROP:
                case EP_InstCode.NIP:
                case EP_InstCode.SWAP:
                case EP_InstCode.OVER:
                case EP_InstCode.ROT:
                case EP_InstCode.NOT:
                case EP_InstCode.AND:
                case EP_InstCode.OR:
                case EP_InstCode.XOR:
                case EP_InstCode.ADD:
                case EP_InstCode.SUB:
                case EP_InstCode.MUL:
                case EP_InstCode.DIV:
                case EP_InstCode.MOD:
                case EP_InstCode.INC:
                case EP_InstCode.DEC:
                case EP_InstCode.NEG:
                case EP_InstCode.CEQ:
                case EP_InstCode.CNE:
                case EP_InstCode.CGT:
                case EP_InstCode.CGE:
                case EP_InstCode.CLT:
                case EP_InstCode.CLE:
                case EP_InstCode.CZE:
                case EP_InstCode.LD_P0:
                case EP_InstCode.LD_P1:
                case EP_InstCode.LD_P2:
                case EP_InstCode.LD_P3:
                case EP_InstCode.LD_P4:
                case EP_InstCode.LD_P5:
                case EP_InstCode.LD_P6:
                case EP_InstCode.LD_P7:
                case EP_InstCode.LD_P8:
                case EP_InstCode.LD_P9:
                case EP_InstCode.LD_PA:
                case EP_InstCode.LD_PB:
                case EP_InstCode.LD_PC:
                case EP_InstCode.LD_PD:
                case EP_InstCode.LD_PE:
                case EP_InstCode.LD_PF:
                case EP_InstCode.LD_L0:
                case EP_InstCode.LD_L1:
                case EP_InstCode.LD_L2:
                case EP_InstCode.LD_L3:
                case EP_InstCode.LD_L4:
                case EP_InstCode.LD_L5:
                case EP_InstCode.LD_L6:
                case EP_InstCode.LD_L7:
                case EP_InstCode.LD_L8:
                case EP_InstCode.LD_L9:
                case EP_InstCode.LD_LA:
                case EP_InstCode.LD_LB:
                case EP_InstCode.LD_LC:
                case EP_InstCode.LD_LD:
                case EP_InstCode.LD_LE:
                case EP_InstCode.LD_LF:
                case EP_InstCode.ST_P0:
                case EP_InstCode.ST_P1:
                case EP_InstCode.ST_P2:
                case EP_InstCode.ST_P3:
                case EP_InstCode.ST_P4:
                case EP_InstCode.ST_P5:
                case EP_InstCode.ST_P6:
                case EP_InstCode.ST_P7:
                case EP_InstCode.ST_P8:
                case EP_InstCode.ST_P9:
                case EP_InstCode.ST_PA:
                case EP_InstCode.ST_PB:
                case EP_InstCode.ST_PC:
                case EP_InstCode.ST_PD:
                case EP_InstCode.ST_PE:
                case EP_InstCode.ST_PF:
                case EP_InstCode.ST_L0:
                case EP_InstCode.ST_L1:
                case EP_InstCode.ST_L2:
                case EP_InstCode.ST_L3:
                case EP_InstCode.ST_L4:
                case EP_InstCode.ST_L5:
                case EP_InstCode.ST_L6:
                case EP_InstCode.ST_L7:
                case EP_InstCode.ST_L8:
                case EP_InstCode.ST_L9:
                case EP_InstCode.ST_LA:
                case EP_InstCode.ST_LB:
                case EP_InstCode.ST_LC:
                case EP_InstCode.ST_LD:
                case EP_InstCode.ST_LE:
                case EP_InstCode.ST_LF:
                case EP_InstCode.LDM_B1_S:
                case EP_InstCode.LDM_S1_S:
                case EP_InstCode.LDM_S2_S:
                case EP_InstCode.LDM_S4_S:
                case EP_InstCode.LDM_U1_S:
                case EP_InstCode.LDM_U2_S:
                case EP_InstCode.STM_B1_S:
                case EP_InstCode.STM_S1_S:
                case EP_InstCode.STM_S2_S:
                case EP_InstCode.STM_S4_S:
                case EP_InstCode.LDI_MIN:
                case EP_InstCode.SJMP:
                case EP_InstCode.SCALL:
                case EP_InstCode.RET:
                    if (_code == null || _code.Length != 1)
                    {
                        _code = new byte[1];
                    }
                    _code[0] = (byte)cmd;
                    break;

                case EP_InstCode.LSL:
                case EP_InstCode.LSR:
                case EP_InstCode.ASR:
                    if (_code == null || _code.Length != 2)
                    {
                        _code = new byte[2];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)((int)((Constant)_cn).Value & 0x1F);
                    break;

                case EP_InstCode.LDM_B1_CS8:
                case EP_InstCode.STM_B1_CS8:

                case EP_InstCode.LDM_S1_CS8:
                case EP_InstCode.STM_S1_CS8:
                case EP_InstCode.LDM_U1_CS8:

                case EP_InstCode.LDM_S2_CS8:
                case EP_InstCode.STM_S2_CS8:
                case EP_InstCode.LDM_U2_CS8:

                case EP_InstCode.LDM_S4_CS8:
                case EP_InstCode.STM_S4_CS8:
                    if (_code == null || _code.Length != 2)
                    {
                        _code = new byte[2];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)_param.Addr;
                    break;

                case EP_InstCode.LDM_B1_C16:
                case EP_InstCode.LDM_B1_CS16:
                case EP_InstCode.STM_B1_C16:
                case EP_InstCode.STM_B1_CS16:

                case EP_InstCode.LDM_S1_C16:
                case EP_InstCode.LDM_S1_CS16:
                case EP_InstCode.STM_S1_C16:
                case EP_InstCode.STM_S1_CS16:

                case EP_InstCode.LDM_S2_C16:
                case EP_InstCode.LDM_S2_CS16:
                case EP_InstCode.STM_S2_C16:
                case EP_InstCode.STM_S2_CS16:

                case EP_InstCode.LDM_S4_C16:
                case EP_InstCode.LDM_S4_CS16:
                case EP_InstCode.STM_S4_C16:
                case EP_InstCode.STM_S4_CS16:

                case EP_InstCode.LDM_U1_C16:
                case EP_InstCode.LDM_U1_CS16:

                case EP_InstCode.LDM_U2_C16:
                case EP_InstCode.LDM_U2_CS16:

                case EP_InstCode.LPM_S1:
                case EP_InstCode.LPM_S2:
                case EP_InstCode.LPM_S4:
                case EP_InstCode.LPM_U1:
                case EP_InstCode.LPM_U2:

                case EP_InstCode.CALL:
                    if (_code == null || _code.Length != 3)
                    {
                        _code = new byte[3];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)_param.Addr;
                    _code[2] = (byte)(_param.Addr >> 8);
                    break;

                case EP_InstCode.API:
                    if (_code == null || _code.Length != 2)
                    {
                        _code = new byte[2];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)_param.Addr;
                    break;

                case EP_InstCode.LDI_0:
                case EP_InstCode.LDI_1:
                case EP_InstCode.LDI_M1:
                case EP_InstCode.LDI_S1:
                case EP_InstCode.LDI_U1:
                case EP_InstCode.LDI_S2:
                case EP_InstCode.LDI_U2:
                case EP_InstCode.LDI_S4:
                    if (_param != null && (_param.type == EP_Type.REFERENCE || _param.type == EP_Type.FUNCTION))
                    {
                        tmp_d = (int)_param.Addr;
                    }
                    else if ((_cn as Constant) != null)
                    {
                        tmp_d = (int)((Constant)_cn).Value;
                    }
                    else
                    {
                        tmp_d = 0;
                    }

                    if (tmp_d == 0)
                    {
                        if (_code == null || _code.Length != 1)
                        {
                            _code = new byte[1];
                        }
                        _code[0] = (byte)EP_InstCode.LDI_0;
                    }
                    else if (tmp_d == 1)
                    {
                        if (_code == null || _code.Length != 1)
                        {
                            _code = new byte[1];
                        }
                        _code[0] = (byte)EP_InstCode.LDI_1;
                    }
                    else if (tmp_d == -1)
                    {
                        if (_code == null || _code.Length != 1)
                        {
                            _code = new byte[1];
                        }
                        _code[0] = (byte)EP_InstCode.LDI_M1;
                    }
                    else if (tmp_d > -128 && tmp_d < 256)
                    {
                        if (_code == null || _code.Length != 2)
                        {
                            _code = new byte[2];
                        }
                        _code[0] = (byte)(tmp_d < 0 ? EP_InstCode.LDI_S1 : EP_InstCode.LDI_U1);
                        _code[1] = (byte)tmp_d;
                    }
                    else if (tmp_d > -32768 && tmp_d < 65536)
                    {
                        if (_code == null || _code.Length != 3)
                        {
                            _code = new byte[3];
                        }
                        _code[0] = (byte)(tmp_d < 0 ? EP_InstCode.LDI_S2 : EP_InstCode.LDI_U2);
                        _code[1] = (byte)tmp_d;
                        _code[2] = (byte)(tmp_d >> 8);
                    }
                    else
                    {
                        if (_code == null || _code.Length != 5)
                        {
                            _code = new byte[5];
                        }
                        _code[0] = (byte)EP_InstCode.LDI_S4;
                        _code[1] = (byte)tmp_d;
                        _code[2] = (byte)(tmp_d >> 8);
                        _code[3] = (byte)(tmp_d >> 16);
                        _code[4] = (byte)(tmp_d >> 24);
                    }
                    break;

                case EP_InstCode.OUT:
                case EP_InstCode.IN:
                    if (_code == null || _code.Length != 5)
                    {
                        _code = new byte[5];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)(_param.Addr >> 24); // Place
                    _code[2] = (byte)(_param.Addr >> 16); // Type
                    _code[3] = (byte)_param.Addr;         // Base low
                    _code[4] = (byte)(_param.Addr >> 8);  // Base high
                    break;

                case EP_InstCode.JZ:
                case EP_InstCode.JNZ:
                case EP_InstCode.JMP:
                    tmp_D = _ref == null ? uint.MaxValue : _ref.addr;
                    if (_code == null || _code.Length != 3)
                    {
                        _code = new byte[3];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)tmp_D;
                    _code[2] = (byte)(tmp_D >> 8);
                    break;

                case EP_InstCode.CHECK_IDX:
                    if (_code == null || _code.Length != 3)
                    {
                        _code = new byte[3];
                    }
                    _code[0] = (byte)cmd;
                    _code[1] = (byte)_param.pOut; //-V3125
                    _code[2] = (byte)(_param.pOut >> 8);
                    break;

                default:
                    throw new NotImplementedException(this.ToString());
                }
            }