vm/vm.cpp

@@ -128,24 +128,7 @@ void VM::initVariables(void) {
   }
   return;
 }
-bool VM::dstRegCheck(uint8_t reg) {
+
-  if (reg == IP || reg == SP || reg == RP) {
-    DBG_ERROR(("Invalid register!\n"));
-    return false;
-  }
-  return true;
-}
-bool VM::srcDstRegCheck(uint8_t dst, uint8_t src) {
-  if (dst == IP || dst == SP || dst == RP) {
-    DBG_ERROR(("Invalid register!\n"));
-    return false;
-  }
-  if (src == IP || src == SP || src == RP) {
-    DBG_ERROR(("Invalid register!\n"));
-    return false;
-  }
-  return true;
-}
 /*
 INSTRUCTIONS IMPLEMENTATIONS
 */
@@ -159,7 +142,8 @@ bool VM::execMOVI(void) {
   dst = as.code[regs[IP] + 1];
   imm = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("MOVI %s, 0x%x\n", getRegName(dst), imm));
-  if (!dstRegCheck(dst)) {
+  if (dst == IP) {
+    DBG_ERROR(("Can't MOVI to IP!\n"));
     return false;
   }
   regs[dst] = imm;
@@ -176,7 +160,8 @@ bool VM::execMOVR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("MOVR %s, %s\n", getRegName(dst), getRegName(src)));
-  if (!srcDstRegCheck(src, dst)) {
+  if (dst == IP || src == IP) {
+    DBG_ERROR(("Can't MOVR IP!\n"));
     return false;
   }
   regs[dst] = regs[src];
@@ -192,9 +177,6 @@ bool VM::execLODI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("LODI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] = *((uint16_t *)&as.data[src]);
   return true;
 }
@@ -208,9 +190,6 @@ bool VM::execLODR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("LODR %s, %s\n", getRegName(dst), getRegName(src)));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] = *((uint16_t *)&as.data[regs[src]]);
   return true;
 }
@@ -223,9 +202,6 @@ bool VM::execSTRI(void) {
   dst = *((uint16_t *)&as.code[regs[IP] + 1]);
   src = as.code[regs[IP] + 3];
   DBG_INFO(("STRI 0x%x, %s\n", dst, getRegName(src)));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   *((uint16_t *)&as.data[dst]) = regs[src];
   return true;
 }
@@ -240,9 +216,6 @@ bool VM::execSTRR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("STRR %s, %s\n", getRegName(dst), getRegName(src)));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   *((uint16_t *)&as.data[regs[dst]]) = regs[src];
   return true;
 }
@@ -257,9 +230,6 @@ bool VM::execADDI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("ADDI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] += src;
   return true;
 }
@@ -274,9 +244,6 @@ bool VM::execADDR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("ADDR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] += regs[src];
   return true;
 }
@@ -291,9 +258,6 @@ bool VM::execSUBI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("SUBI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] -= src;
   return true;
 }
@@ -307,9 +271,6 @@ bool VM::execSUBR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("SUBR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] -= regs[src];
   return true;
 }
@@ -323,9 +284,6 @@ bool VM::execANDB(void) {
   dst = as.code[regs[IP] + 1];
   src = as.code[regs[IP] + 2];
   DBG_INFO(("ANDB %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] &= src;
   return true;
 }
@@ -339,9 +297,6 @@ bool VM::execANDW(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] &= src;
   return true;
 }
@@ -355,9 +310,6 @@ bool VM::execANDR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("ANDR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] &= regs[src];
   return true;
 }
@@ -371,9 +323,6 @@ bool VM::execYORB(void) {
   dst = as.code[regs[IP] + 1];
   src = as.code[regs[IP] + 2];
   DBG_INFO(("YORB %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] |= src;
   return true;
 }
@@ -387,9 +336,6 @@ bool VM::execYORW(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] |= src;
   return true;
 }
@@ -403,9 +349,6 @@ bool VM::execYORR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("XORR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] |= regs[src];
   return true;
 }
@@ -419,9 +362,6 @@ bool VM::execXORB(void) {
   dst = as.code[regs[IP] + 1];
   src = as.code[regs[IP] + 2];
   DBG_INFO(("XORB %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] ^= src;
   return true;
 }
@@ -435,9 +375,6 @@ bool VM::execXORW(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("XORW %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] ^= src;
   return true;
 }
@@ -451,9 +388,6 @@ bool VM::execXORR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("XORR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] ^= regs[src];
   return true;
 }
@@ -467,9 +401,6 @@ bool VM::execNOTR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("NOTR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] = ~regs[src];
   return true;
 }
@@ -483,9 +414,6 @@ bool VM::execMULI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("SUBI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] *= src;
   return true;
 }
@@ -499,9 +427,6 @@ bool VM::execMULR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("MULR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] *= regs[src];
   return true;
 }
@@ -515,9 +440,6 @@ bool VM::execDIVI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("DIVI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] /= src;
   return true;
 }
@@ -531,9 +453,6 @@ bool VM::execDIVR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("DIVR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] /= regs[src];
   return true;
 }
@@ -547,9 +466,6 @@ bool VM::execSHLI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("SHLI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] = regs[dst] << src;
   return true;
 }
@@ -563,9 +479,6 @@ bool VM::execSHLR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("SHLR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] = regs[dst] << regs[src];
   return true;
 }
@@ -579,9 +492,6 @@ bool VM::execSHRI(void) {
   dst = as.code[regs[IP] + 1];
   src = *((uint16_t *)&as.code[regs[IP] + 2]);
   DBG_INFO(("SHRI %s, 0x%x\n", getRegName(dst), src));
-  if (!dstRegCheck(dst)) {
-    return false;
-  }
   regs[dst] = regs[dst] >> src;
   return true;
 }
@@ -595,34 +505,25 @@ bool VM::execSHRR(void) {
   dst = as.code[regs[IP] + 1] >> 4;
   src = as.code[regs[IP] + 1] & 0b00001111;
   DBG_INFO(("SHRR %s, 0x%x\n", getRegName(dst), src));
-  if (!srcDstRegCheck(src, dst)) {
-    return false;
-  }
   regs[dst] = regs[dst] >> regs[src];
   return true;
 }
 bool VM::execPUSH(void) {
+  // TODO: STACK < 0
   uint8_t src;
 
   src = as.code[regs[IP] + 1];
   DBG_INFO(("PUSH %s\n", getRegName(src)));
-  if (regs[SP] + sizeof(uint16_t) > 0xffff) {
-    DBG_ERROR(("Out of bound: stack is going above 0xFFFF!\n"));
-    return false;
-  }
   memcpy(&as.stack[regs[SP]], &regs[src], sizeof(uint16_t));
   regs[SP] += sizeof(uint16_t);
   return true;
 }
 bool VM::execPOOP(void) {
+  // TODO: STACK < 0
   uint8_t dst;
 
   dst = as.code[regs[IP] + 1];
   DBG_INFO(("POOP %s\n", getRegName(dst)));
-  if (regs[SP] - sizeof(uint16_t) < 0) {
-    DBG_ERROR(("Out of bound: stack is going below 0!\n"));
-    return false;
-  }
   regs[SP] -= sizeof(uint16_t);
   memcpy(&regs[dst], &as.stack[regs[SP]], sizeof(uint16_t));
   return true;
@@ -862,274 +763,107 @@ bool VM::execGRMN(void) {
 void VM::run(void) {
   uint8_t opcode;
   bool finished = false;
-  bool ret;
   while (!finished) {
     opcode = (uint8_t)as.code[regs[IP]];
     if (opcode == OPS[MOVI]) {
-      ret = execMOVI();
+      execMOVI();
-      if (ret) {
+      regs[IP] += MOVI_SIZE;
-        regs[IP] += MOVI_SIZE;
-      } else {
-        DBG_ERROR(("MOVI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[MOVR]) {
-      ret = execMOVR();
+      execMOVR();
-      if (ret) {
+      regs[IP] += MOVR_SIZE;
-        regs[IP] += MOVR_SIZE;
-      } else {
-        DBG_ERROR(("MOVR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[LODI]) {
-      ret = execLODI();
+      execLODI();
-      if (ret) {
+      regs[IP] += LODI_SIZE;
-        regs[IP] += LODI_SIZE;
-      } else {
-        DBG_ERROR(("LODI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[LODR]) {
-      ret = execLODR();
+      execLODR();
-      if (ret) {
-        regs[IP] += LODR_SIZE;
-      } else {
-        DBG_ERROR(("LODR FAILED.\n"));
-        finished = true;
-      }
       regs[IP] += LODR_SIZE;
     } else if (opcode == OPS[STRI]) {
-      ret = execSTRI();
+      execSTRI();
-      if (ret) {
+      regs[IP] += STRI_SIZE;
-        regs[IP] += STRI_SIZE;
-      } else {
-        DBG_ERROR(("MOVI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[STRR]) {
-      ret = execSTRR();
+      execSTRR();
-      if (ret) {
+      regs[IP] += STRR_SIZE;
-        regs[IP] += STRR_SIZE;
-      } else {
-        DBG_ERROR(("STRR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[ADDI]) {
-      ret = execADDI();
+      execADDI();
-      if (ret) {
+      regs[IP] += ADDI_SIZE;
-        regs[IP] += ADDI_SIZE;
-      } else {
-        DBG_ERROR(("ADDI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[ADDR]) {
-      ret = execADDR();
+      execADDR();
-      if (ret) {
+      regs[IP] += ADDR_SIZE;
-        regs[IP] += ADDR_SIZE;
-      } else {
-        DBG_ERROR(("ADDR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SUBI]) {
-      ret = execSUBI();
+      execSUBI();
-      if (ret) {
+      regs[IP] += SUBI_SIZE;
-        regs[IP] += SUBI_SIZE;
-      } else {
-        DBG_ERROR(("SUBI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SUBR]) {
-      ret = execSUBR();
+      execSUBR();
-      if (ret) {
+      regs[IP] += SUBR_SIZE;
-        regs[IP] += SUBR_SIZE;
-      } else {
-        DBG_ERROR(("SUBR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[ANDB]) {
-      ret = execANDB();
+      execANDB();
-      if (ret) {
+      regs[IP] += ANDB_SIZE;
-        regs[IP] += ANDB_SIZE;
-      } else {
-        DBG_ERROR(("ANDB FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[ANDW]) {
-      ret = execANDW();
+      execANDW();
-      if (ret) {
+      regs[IP] += ANDW_SIZE;
-        regs[IP] += ANDW_SIZE;
-      } else {
-        DBG_ERROR(("ANDW FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[ANDR]) {
-      ret = execANDR();
+      execANDR();
-      if (ret) {
+      regs[IP] += ANDR_SIZE;
-        regs[IP] += ANDR_SIZE;
-      } else {
-        DBG_ERROR(("ANDR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[YORB]) {
-      ret = execYORB();
+      execYORB();
-      if (ret) {
+      regs[IP] += YORB_SIZE;
-        regs[IP] += YORB_SIZE;
-      } else {
-        DBG_ERROR(("YORB FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[YORW]) {
-      ret = execYORW();
+      execYORW();
-      if (ret) {
+      regs[IP] += YORW_SIZE;
-        regs[IP] += YORW_SIZE;
-      } else {
-        DBG_ERROR(("YORW FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[YORR]) {
-      ret = execYORR();
+      execYORR();
-      if (ret) {
+      regs[IP] += YORR_SIZE;
-        regs[IP] += YORR_SIZE;
-      } else {
-        DBG_ERROR(("YORR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[XORB]) {
-      ret = execXORB();
+      execXORB();
-      if (ret) {
+      regs[IP] += XORB_SIZE;
-        regs[IP] += XORB_SIZE;
-      } else {
-        DBG_ERROR(("XORB FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[XORW]) {
-      ret = execXORW();
+      execXORW();
-      if (ret) {
+      regs[IP] += XORW_SIZE;
-        regs[IP] += XORW_SIZE;
-      } else {
-        DBG_ERROR(("XORW FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[XORR]) {
-      ret = execXORR();
+      execXORR();
-      if (ret) {
+      regs[IP] += XORR_SIZE;
-        regs[IP] += XORR_SIZE;
-      } else {
-        DBG_ERROR(("XORR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[NOTR]) {
-      ret = execNOTR();
+      execNOTR();
-      if (ret) {
+      regs[IP] += NOTR_SIZE;
-        regs[IP] += NOTR_SIZE;
-      } else {
-        DBG_ERROR(("NOTR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[MULI]) {
-      ret = execMULI();
+      execMULI();
-      if (ret) {
+      regs[IP] += MULI_SIZE;
-        regs[IP] += MULI_SIZE;
-      } else {
-        DBG_ERROR(("MULI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[MULR]) {
-      ret = execMULR();
+      execMULR();
-      if (ret) {
+      regs[IP] += MULR_SIZE;
-        regs[IP] += MULR_SIZE;
-      } else {
-        DBG_ERROR(("MULR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[DIVI]) {
-      ret = execDIVI();
+      execDIVI();
-      if (ret) {
+      regs[IP] += DIVI_SIZE;
-        regs[IP] += DIVI_SIZE;
-      } else {
-        DBG_ERROR(("DIVI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[DIVR]) {
-      ret = execDIVR();
+      execDIVR();
-      if (ret) {
+      regs[IP] += DIVR_SIZE;
-        regs[IP] += DIVR_SIZE;
-      } else {
-        DBG_ERROR(("DIVR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SHLI]) {
-      ret = execSHLI();
+      execSHLI();
-      if (ret) {
+      regs[IP] += SHLI_SIZE;
-        regs[IP] += SHLI_SIZE;
-      } else {
-        DBG_ERROR(("SHLI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SHLR]) {
-      ret = execSHLR();
+      execSHLR();
-      if (ret) {
+      regs[IP] += SHLR_SIZE;
-        regs[IP] += SHLR_SIZE;
-      } else {
-        DBG_ERROR(("SHLR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SHRI]) {
-      ret = execSHRI();
+      execSHRI();
-      if (ret) {
+      regs[IP] += SHRI_SIZE;
-        regs[IP] += SHRI_SIZE;
-      } else {
-        DBG_ERROR(("SHRI FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[SHRR]) {
-      ret = execSHRR();
+      execSHRR();
-      if (ret) {
+      regs[IP] += SHRR_SIZE;
-        regs[IP] += SHRR_SIZE;
-      } else {
-        DBG_ERROR(("SHRR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[PUSH]) {
-      ret = execPUSH();
+      execPUSH();
-      if (ret) {
+      regs[IP] += PUSH_SIZE;
-        regs[IP] += PUSH_SIZE;
-      } else {
-        DBG_ERROR(("PUSH FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[POOP]) {
-      ret = execPOOP();
+      execPOOP();
-      if (ret) {
+      regs[IP] += POOP_SIZE;
-        regs[IP] += POOP_SIZE;
-      } else {
-        DBG_ERROR(("POOP FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[CMPB]) {
-      ret = execCMPB();
+      execCMPB();
-      if (ret) {
+      regs[IP] += CMPB_SIZE;
-        regs[IP] += CMPB_SIZE;
-      } else {
-        DBG_ERROR(("CMPB FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[CMPW]) {
-      ret = execCMPW();
+      execCMPW();
-      if (ret) {
+      regs[IP] += CMPW_SIZE;
-        regs[IP] += CMPW_SIZE;
-      } else {
-        DBG_ERROR(("CMPW FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[CMPR]) {
-      ret = execCMPR();
+      execCMPR();
-      if (ret) {
+      regs[IP] += CMPR_SIZE;
-        regs[IP] += CMPR_SIZE;
-      } else {
-        DBG_ERROR(("CMPR FAILED.\n"));
-        finished = true;
-      }
     } else if (opcode == OPS[JMPI]) {
       execJMPI();
     } else if (opcode == OPS[JMPR]) {

vm/vm.h

@@ -16,9 +16,6 @@ private:
   ///////////////////////
   void initVariables(void);
   void encryptOpcodes(uint8_t *key);
-  bool dstRegCheck(uint8_t reg);
-  bool srcDstRegCheck(uint8_t dst, uint8_t src);
-
   /*
   DBG UTILS
   */