Line data    Source code

       1             : #include <iostream>
       2             : #include "common/poliz.hpp"
       3             : #include "common/obstacle.hpp"
       4             : 
       5         415 : POLIZ::POLIZ(int s) {
       6         415 :     iter = 0;
       7             : 
       8      425375 :     for (int i = 0; i < MAXCMD; i++) {
       9      424960 :         prog[i] = (op_t) NONE;
      10      424960 :         execBit[i] = false;
      11             :     }
      12             : 
      13         415 : }
      14             : 
      15           0 : POLIZ& POLIZ::operator=(const POLIZ& p) {
      16           0 :     if (this == &p) return *this;
      17           0 :     for (int i = 0; i < p.iter; i++) {
      18           0 :         prog[i] = p.prog[i];
      19           0 :         execBit[i] = p.execBit[i];
      20             :     }
      21           0 :     iter = p.iter;
      22           0 :     return *this;
      23             : }
      24             : 
      25          58 : POLIZ::POLIZ(const POLIZ& p) {
      26          58 :     if (this == &p) return;
      27          58 :     for (int i = 0; i < p.iter; i++) {
      28           0 :         prog[i] = p.prog[i];
      29           0 :         execBit[i] = p.execBit[i];
      30             :     }
      31          58 :     iter = p.iter;
      32             : }
      33             : 
      34          58 : void POLIZ::repr(bool dontBreak) {
      35          58 :     for (int i = 0; i < iter; i++) {
      36           0 :         std::cout << i << ") ";
      37           0 :         if (execBit[i]) interpretAsOp(prog[i]);
      38           0 :         else interpretAsVal(prog[i]);
      39           0 :         if (!dontBreak)
      40           0 :             std::cout << "\n";
      41             :         else
      42           0 :             std::cout << "\\n";
      43             :     }
      44          58 : }
      45             : 
      46         824 : void POLIZ::pushVal(IdentTable * val) {
      47             :     #ifdef DEBUG
      48             :     std::cout << "POLIZ pushVal";
      49             :     val->whoami();
      50             :     if (val->isReg())
      51             :         std::cout << " REGISTER";
      52             :     std::cout << std::endl;
      53             :     #endif
      54             : 
      55         824 :     if (val->isReg()) {
      56          38 :         IdentTable * mainIT = val->getMainTable();
      57          38 :         mainIT->pushType(_INT_);
      58          38 :         mainIT->pushVal(new int (val->getOrd()));
      59          38 :         pushVal(mainIT->confirm());
      60          38 :         pushOp(_NONE_, _INT_, LOAD);
      61          38 :         prog[iter - 1] = (char) val->getType() << 24 | (prog[iter - 1] & 0xFFF);
      62             :     } else {
      63         786 :         prog[iter] = (op_t) val;
      64         786 :         execBit[iter] = false;
      65         786 :         iter++;
      66             : 
      67         786 :         checkIter();
      68             :     }
      69         824 : }
      70             : 
      71         851 : void POLIZ::pushOp(type_t lval, type_t rval, operation_t op){
      72             :     #ifdef DEBUG
      73             :     std::cout << "POLIZ pushOp ";
      74             :     interpretAsOp(op);
      75             :     std::cout << std::endl;
      76             :     #endif
      77         851 :     type_t rest = expressionType(lval, rval, op);
      78         851 :     prog[iter] = (char) rest << 24 | (char) lval << 16 | (char) rval << 8 | (char) op;
      79         851 :     execBit[iter] = true;
      80         851 :     iter++;
      81             : 
      82         851 :     checkIter();
      83         851 : }
      84             : 
      85           0 : void POLIZ::interpretAsOp(op_t op) {
      86           0 :     switch (op & 0xFF) {
      87           0 :         case INV: std::cout << "INV "; break;
      88           0 :         case PLUS: std::cout << "PLUS "; break;
      89           0 :         case MINUS: std::cout << "MINUS "; break;
      90           0 :         case MUL: std::cout << "MUL "; break;
      91           0 :         case DIV: std::cout << "DIV "; break;
      92           0 :         case LOR: std::cout << "LOR "; break;
      93           0 :         case LAND: std::cout << "LAND "; break;
      94           0 :         case LNOT: std::cout << "LNOT "; break;
      95           0 :         case MOD: std::cout << "MOD "; break;
      96           0 :         case LESS: std::cout << "LESS "; break;
      97           0 :         case GRTR: std::cout << "GRTR "; break;
      98           0 :         case LESSEQ: std::cout << "LESSEQ "; break;
      99           0 :         case GRTREQ: std::cout << "GRTREQ "; break;
     100           0 :         case EQ: std::cout << "EQ "; break;
     101           0 :         case NEQ: std::cout << "NEQ "; break;
     102           0 :         case ASSIGN: std::cout << "ASSIGN "; break;
     103           0 :         case STOP: std::cout << "STOP "; break;
     104           0 :         case WRITE: std::cout << "WRITE "; break;
     105           0 :         case ENDL: std::cout << "ENDL "; break;
     106           0 :         case READ: std::cout << "READ "; break;
     107           0 :         case JIT: std::cout << "JIT "; break;
     108           0 :         case JMP: std::cout << "JMP "; break;
     109           0 :         case RET: std::cout << "RET "; break;
     110           0 :         case CALL: std::cout << "CALL "; break;
     111           0 :         case LOAD: std::cout << "LOAD "; break;
     112           0 :         case SHARE: std::cout << "SHARE "; break;
     113           0 :         case FORK: std::cout << "FORK "; break;
     114           0 :         case LOCK: std::cout << "LOCK "; break;
     115           0 :         case NONE: std::cout << "NONE "; break;
     116           0 :         case UNPACK: std::cout << "UNPACK "; break;
     117           0 :         default: throw Obstacle(PANIC);
     118             :     }
     119           0 :     std::cout << "["  << typetostr((type_t)((op >>  8) & 0xFF));
     120           0 :     std::cout << ", " << typetostr((type_t)((op >> 16) & 0xFF));
     121           0 :     std::cout << "]";
     122           0 : }
     123             : 
     124           0 : void POLIZ::interpretAsVal(op_t val) {
     125           0 :     reinterpret_cast<IdentTable *>(val)->whoami();
     126           0 : }
     127             : 
     128        9135 : op_t * POLIZ::getProg(void) {
     129        9135 :     return prog;
     130             : }
     131             : 
     132       12587 : bool * POLIZ::getEB(void) {
     133       12587 :     return execBit;
     134             : }
     135             : 
     136       15911 : int POLIZ::getSize(void) const {
     137       15911 :     return iter;
     138             : }
     139             : 
     140         558 : void POLIZ::pop(void) {
     141         558 :     iter = (iter <= 0) ? 0 : iter - 1;
     142         558 : }
     143             : 
     144          87 : void POLIZ::clear(void) {
     145          87 :     iter = 0;
     146          87 : }
     147             : 
     148        1239 : void POLIZ::incIter(void) {
     149        1239 :     iter++;
     150        1239 :     checkIter();
     151        1239 : }
     152             : 
     153        1753 : void POLIZ::push(op_t op, bool eb) {
     154             :     #ifdef DEBUG
     155             :     std::cout << "POLIZ push ";
     156             :     if (eb)
     157             :         interpretAsOp(op);
     158             :     else
     159             :         interpretAsVal(op);
     160             :     std::cout << std::endl;
     161             :     #endif
     162             : 
     163        1753 :     prog[iter] = op;
     164        1753 :     execBit[iter] = eb;
     165        1753 :     iter++;
     166        1753 :     checkIter();
     167        1753 : }
     168             : 
     169        4629 : void POLIZ::checkIter(void) const {
     170        4629 :     if (iter >= MAXCMD) {
     171           0 :         std::cout << "Слот для байткода переполнен. Текущее значение: ";
     172           0 :         std::cout << MAXCMD << ". Скомпилируйте с большим значением.\n";
     173           0 :         exit(1);
     174             :     }
     175        4629 : }
     176             : 
     177          58 : bool POLIZ::endsWithCall(void) const {
     178          58 :     bool call = (operation_t)(prog[iter - 1] & 0xFF) == CALL;
     179          58 :     bool exec = execBit[iter - 1];
     180          58 :     return call && exec;
     181             : }
     182             : 
     183          58 : bool POLIZ::endsWithRet(void) const {
     184          58 :     bool call = (operation_t)(prog[iter - 1] & 0xFF) == RET;
     185          58 :     bool exec = execBit[iter - 1];
     186          58 :     return call && exec;
     187             : }