labelmaniger_c.cpp

单片机宏汇编器的源程序。给一些爱好者作为学习编译原理和 C 程序设计的例子.

   { masm.OutputErr(DataExceedErr); return DataExceedLen; } // endif

  if(a.rel == 'A') { a.rseg = NULL; } // endif
  else // a.rel may be 'R' or 'E'
   { bool empty = true;
     for(int8u i = optr.getSP(); empty && i>0; --i)
      { if(optr.GetSK(i)!= '(') { empty = false; } // endif
      } // end for

     if(empty)     // High 位于最外层
      { a.fix = FIX_HIGH; return OK_no_Err; } // endif
     else          // High 位于里层
      { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else
   } // end else

  a.val =  (a.val >> 8) & 0xff;
  return OK_no_Err;
} // end OPHigh
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//    LOW A
//---------------------------------------------------------------------------
ERR LabelManager::OPLow(TriVal &a, TokenStack& optr)
{ if(not16bit(a.val)) // Only can "LOW" data <= 16-bit
   { masm.OutputErr(DataExceedErr); return DataExceedLen; } // endif

  if(a.rel == 'A') { a.rseg = NULL; } // endif
  else // a.rel may be 'R' or 'E'
   { bool empty = true;
     for(int8u i = optr.getSP(); empty && i>0; --i)
      { if(optr.GetSK(i)!= '(') { empty = false; } // endif
      } // end for

     if(empty)     // High 位于最外层
      { a.fix = FIX_LOW; return OK_no_Err; } // endif
     else          // High 位于里层
      { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else
   } // end else

  a.val &= 0xff;
  return OK_no_Err;
} // end OPLow
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//    + A = A           + N = N
//---------------------------------------------------------------------------
ERR LabelManager::OPPlus(TriVal &a)
{ if(a.rel == 'A') { a.rseg = NULL; } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  if(a.typ != LB_NUM)
   { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // endif
  else
   { a.typ = LB_NUM; } // end else

  return OK_no_Err;
} // end OPNot
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//    - A = A           - N = N
//---------------------------------------------------------------------------
ERR LabelManager::OPNeg(TriVal &a)
{ if(a.rel == 'A') { a.rseg = NULL; } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  if(a.typ != LB_NUM)
   { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // endif
  else
   { a.typ = LB_NUM; } // end else

  a.val =  - a.val;
  return OK_no_Err;
} // end OPNot
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//   NOT A = A       NOT N = N
//---------------------------------------------------------------------------
ERR LabelManager::OPNot(TriVal &a)
{ if(a.rel == 'A') { a.rseg = NULL; } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  if(a.typ != LB_NUM)
   { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // endif
  else
   { a.typ = LB_NUM; } // end else

  if(not16bit(a.val)) // Only can "NOT" 16-bit data
   { masm.OutputErr(DataExceedErr); return DataExceedLen; } // endif

  a.val =  (~a.val) & 0xffff;
  return OK_no_Err;
} // end OPNot
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//  A SHL A = A;      N SHL N = N;
//  A SHR A = A;      N SHR N = N;
//---------------------------------------------------------------------------
ERR LabelManager::OPShlShr(TriVal &a, TriVal &b, TriVal &c, TvFuncPt fun)
{ ifRel( 'A', 'A' ) { c.rel = 'A'; c.rseg = NULL; } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  ifTypNum( !=, !=) { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // endif
  else              { c.typ = LB_NUM; } // end else

  if(not4bit(b.val)) // Only can move 16-bit, so b.val = 0 ~ 0x0F
   { masm.OutputErr(ShiftOutRangeErr); return ShiftsOuts; } // endif

  c.val = fun(a.val, b.val);
  return OK_no_Err;
} // end OPAndOrXor
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A & A = A,                  N & N = N
//  A & R = Error!              N & C = N
//  R & A = Error!              C & N = N
//  R & R = Error!              ? & ? = Error!
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A | A = A,                  N | N = N
//  A | R = Error!              N | C = N
//  R | A = Error!              C | N = N
//  R | R = Error!              ? | ? = Error!
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A ^ A = A,                  N ^ N = N
//  A ^ R = Error!              N ^ C = N
//  R ^ A = Error!              C ^ N = N
//  R ^ R = Error!              ? ^ ? = Error!
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
ERR LabelManager::OPAndOrXor(TriVal &a, TriVal &b, TriVal &c, TvFuncPt fun)
{ ifRel( 'A', 'A' ) { c.rel = 'A'; c.rseg = NULL; } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  ifTypNum( !=, !=) { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // endif
  else              { c.typ = LB_NUM; } // end else

  c.val = fun(a.val, b.val);
  return OK_no_Err;
} // end OPAndOrXor
//---------------------------------------------------------------------------


//---------------------------------------------------------------------------
//  A == A = A,                  N == N = N
//  A == R = Error!              N == C = N
//  R == A = Error!              C == N = N
//  R == R = A (same seg)        ? == ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A < A = A,                  N < N = N
//  A < R = Error!              N < C = N
//  R < A = Error!              C < N = N
//  R < R = A (same seg)        ? < ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A > A = A,                  N > N = N
//  A > R = Error!              N > C = N
//  R > A = Error!              C > N = N
//  R > R = A (same seg)        ? > ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A >= A = A,                  N >= N = N
//  A >= R = Error!              N >= C = N
//  R >= A = Error!              C >= N = N
//  R >= R = A (same seg)        ? >= ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A <= A = A,                  N <= N = N
//  A <= R = Error!              N <= C = N
//  R <= A = Error!              C <= N = N
//  R <= R = A (same seg)        ? <= ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A != A = A,                  N != N = N
//  A != R = Error!              N != C = N
//  R != A = Error!              C != N = N
//  R != R = A (same seg)        ? != ? = N (same typ)
//---------------------------------------------------------------------------
//  err = BadRelExp         (x)
//  err = IllExpTypOp       (x)
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
ERR LabelManager::OPEquLesGrt(TriVal &a, TriVal &b, TriVal &c, TvFuncPt fun)
{      ifRel( 'A', 'A' ) { c.rel = 'A'; c.rseg = NULL; } // endif
  else ifRel( 'R', 'R' )
        { if( IsSameSeg(a,b) )
           { c.rel = 'A'; c.rseg = NULL; } // endif
          else
           { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else
        } // endif
  else { masm.OutputErr(BadRelExpErr); return BadRelExp; } // end else

  ifTypNum(!=, !=)
    { if( IsSameTyp(a,b) ) { c.typ = LB_NUM; } // endif
      else { masm.OutputErr(IllTypExpErr); return IllExpTypOp; } // end else
    } // endif
  else                     { c.typ = LB_NUM; } // end else

  c.val = fun(a.val, b.val);
  return OK_no_Err;
} // end OPEquLesGrt
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  A + A = A,                  N + N = N
//  A + R = R,                  N + C = C, N + D = D, N + B = B,  ...
//  R + A = R,                  C + N = C, D + N = D, B + N = B,  ...
//  R + R = Error!              ? + ? = Error!
//  Register:  A + DPTR = (A+DPTR),   A + PC =(A+PC)