Ejemplo n.º 1
0
         //
         // Info::putChunkMIMP
         //
         void Info::putChunkMIMP()
         {
            if(!numChunkMIMP) return;

            Core::Array<IR::Object const *> imps{numChunkMIMP};

            auto itr = imps.begin();
            for(auto const &obj : prog->rangeObject())
            {
               if(!obj.defin && obj.space.base == IR::AddrBase::MapReg)
                  *itr++ = &obj;
            }

            Core::FastU size = numChunkMIMP * 4;
            for(auto const &imp : imps)
               size += lenString(imp->glyph);

            putData("MIMP", 4);
            putWord(size);

            for(auto const &imp : imps)
            {
               putWord(imp->value);
               putString(imp->glyph);
            }
         }
Ejemplo n.º 2
0
         //
         // Info::putChunkATAG
         //
         void Info::putChunkATAG()
         {
            if(!numChunkATAG) return;

            for(auto const &itr : init)
               if(itr.first->space.base == IR::AddrBase::MapArr)
            {
               auto const &ini = itr.second;

               if(!ini.needTag || ini.onlyStr) continue;

               putData("ATAG", 4);
               putWord(ini.vals.size() + 5);

               putByte(0); // version
               putWord(itr.first->value);

               for(auto const &i : itr.second.vals) switch(i.tag)
               {
               case InitTag::Empty: putByte(0); break;
               case InitTag::Fixed: putByte(0); break;
               case InitTag::Funct: putByte(2); break;
               case InitTag::StrEn: putByte(1); break;
               }
            }
         }
Ejemplo n.º 3
0
bool 
SimpleProperties::Writer::add(Uint16 key, Uint32 value){
  Uint32 head = Uint32Value;  
  head <<= 16;
  head += key;
  if(!putWord(htonl(head)))
    return false;
  
  return putWord(htonl(value));
}
Ejemplo n.º 4
0
         //
         // Info::putChunkSPTR
         //
         void Info::putChunkSPTR()
         {
            if(!numChunkSPTR) return;

            putData("SPTR", 4);
            putWord(numChunkSPTR * (UseFakeACS0 ? 8 : 12));

            for(auto const &itr : prog->rangeFunction())
            {
               if(itr.ctype != IR::CallType::Script  &&
                  itr.ctype != IR::CallType::ScriptI &&
                  itr.ctype != IR::CallType::ScriptS)
                  continue;

               if(!itr.defin) continue;

               Core::FastU stype, value;

               // Convert script type.
               switch(itr.stype)
               {
               case IR::ScriptType::None:       stype =  0; break;
               case IR::ScriptType::Death:      stype =  3; break;
               case IR::ScriptType::Disconnect: stype = 14; break;
               case IR::ScriptType::Enter:      stype =  4; break;
               case IR::ScriptType::Lightning:  stype = 12; break;
               case IR::ScriptType::Open:       stype =  1; break;
               case IR::ScriptType::Respawn:    stype =  2; break;
               case IR::ScriptType::Return:     stype = 15; break;
               case IR::ScriptType::Unloading:  stype = 13; break;
               }

               // Convert script index.
               if(itr.ctype == IR::CallType::ScriptS)
                  value = -static_cast<Core::FastI>(itr.valueInt) - 1;
               else
                  value = itr.valueInt;

               // Write entry.
               if(UseFakeACS0)
               {
                  putHWord(value);
                  putByte(stype);
                  putByte(itr.param);
                  putExpWord(resolveGlyph(itr.label));
               }
               else
               {
                  putHWord(value);
                  putHWord(stype);
                  putExpWord(resolveGlyph(itr.label));
                  putWord(itr.param);
               }
            }
         }
Ejemplo n.º 5
0
         //
         // Info::putChunkMSTR
         //
         void Info::putChunkMSTR()
         {
            if(!numChunkMSTR) return;

            putData("MSTR", 4);
            putWord(numChunkMSTR * 4);

            auto const &ini = init[&prog->getSpaceMapReg()];

            for(std::size_t i = 0, e = ini.vals.size(); i != e; ++i)
               if(ini.vals[i].tag == InitTag::StrEn) putWord(i);
         }
Ejemplo n.º 6
0
bool
SimpleProperties::Writer::add(Uint16 key, const void* value, int len){
  Uint32 head = BinaryValue;
  head <<= 16;
  head += key;
  if(!putWord(htonl(head)))
    return false;
  if(!putWord(htonl(len)))
    return false;

  return add((const char*)value, len);
}
Ejemplo n.º 7
0
         //
         // Info::putChunkASTR
         //
         void Info::putChunkASTR()
         {
            if(!numChunkASTR) return;

            putData("ASTR", 4);
            putWord(numChunkASTR * 4);

            for(auto const &itr : init)
               if(itr.first->space.base == IR::AddrBase::MapArr)
            {
               if(itr.second.needTag && itr.second.onlyStr)
                  putWord(itr.first->value);
            }
         }
Ejemplo n.º 8
0
bool
SimpleProperties::Writer::add(Uint16 key, const char * value){
  Uint32 head = StringValue;
  head <<= 16;
  head += key;
  if(!putWord(htonl(head)))
    return false;
  Uint32 strLen = Uint32(strlen(value) + 1); // Including NULL-byte
  if(!putWord(htonl(strLen)))
    return false;

  return add(value, (int)strLen);

}
Ejemplo n.º 9
0
         //
         // Info::putChunkMINI
         //
         void Info::putChunkMINI()
         {
            if(!numChunkMINI) return;

            auto const &ini = init[&prog->getSpaceMapReg()];

            for(std::size_t i = 0, e = ini.vals.size(); i != e; ++i) if(ini.vals[i].val)
            {
               putData("MINI", 4);
               putWord(8);
               putWord(i);
               putWord(ini.vals[i].val);
            }
         }
Ejemplo n.º 10
0
         //
         // Info::putChunkARAY
         //
         void Info::putChunkARAY()
         {
            if(!numChunkARAY) return;

            putData("ARAY", 4);
            putWord(numChunkARAY * 8);

            for(auto const &itr : prog->rangeSpaceMapArs())
            {
               if(!itr.defin) continue;

               putWord(itr.value);
               putWord(itr.words);
            }
         }
Ejemplo n.º 11
0
         //
         // Info::putChunkAINI
         //
         void Info::putChunkAINI()
         {
            if(!numChunkAINI) return;

            for(auto const &itr : init)
               if(itr.first->space.base == IR::AddrBase::MapArr)
            {
               putData("AINI", 4);
               putWord(itr.second.vals.size() * 4 + 4);
               putWord(itr.first->value);

               for(auto const &i : itr.second.vals)
                  putWord(i.val);
            }
         }
Ejemplo n.º 12
0
/*
 * memoryStage - writes or reads from memory when needed
 *               Updates values for writebackStage
 *
 * params - forwardType * forward, statusType* status, bubbleType* bubble
 * 
 */
void memoryStage(forwardType * forward, statusType* status, bubbleType* bubble)
{
    unsigned int addr = mem_addr();
    unsigned int valM = M.valA;
    bool memError = false;
    unsigned int stat = M.stat;
    
    if(mem_write())
    {
        putWord(addr, valM, &memError);
    }
    if(mem_read())
    {
        valM = getWord(addr, &memError);
    }
    if(memError)
        stat = SADR;
    
    //forward values
    forward->M_dstM = M.dstM;
    forward->M_dstE = M.dstE;
    forward->m_valM = valM;
    forward->M_valE = M.valE;
    forward->M_Cnd = M.Cnd;
    forward->M_valA = M.valA;
    forward->M_icode = M.icode;
    status->m_stat = stat;
    
    bubble->M_icode = M.icode;

    updateWregister(stat, M.icode, M.valE, valM, M.dstE, M.dstM);
}
Ejemplo n.º 13
0
         //
         // Info::putChunkSFLG
         //
         void Info::putChunkSFLG()
         {
            if(!numChunkSFLG) return;

            putData("SFLG", 4);
            putWord(numChunkSFLG * 4);

            for(auto const &itr : prog->rangeFunction())
            {
               if(itr.ctype != IR::CallType::Script  &&
                  itr.ctype != IR::CallType::ScriptI &&
                  itr.ctype != IR::CallType::ScriptS)
                  continue;

               if(!itr.defin) continue;

               Core::FastU flags = 0;

               if(itr.sflagClS) flags |= 0x0002;
               if(itr.sflagNet) flags |= 0x0001;

               if(!flags) continue;

               putHWord(itr.valueInt);
               putHWord(flags);
            }
         }
Ejemplo n.º 14
0
         //
         // Info::putChunkCODE
         //
         void Info::putChunkCODE()
         {
            putData("\0\0\0\0", 4);
            putWord(numChunkCODE);

            // Put statements.
            for(auto &itr : prog->rangeFunction())
               putFunc(itr);
         }
Ejemplo n.º 15
0
QVector<QPointF> *Visualizer::putText(QStringList wordList, float x, float y, bool isOnTop, QMap<int, QVector<int> > map)
{
    int pos = 0;
    QVector<QPointF> *points = new QVector<QPointF>;
    QRectF rect = putWord("___", x, y, isOnTop, pos, map);
    points->push_back(findPointForConnection(rect, x, y, isOnTop));
    x += rect.width() + space;   
    QStringListIterator i(wordList);    
    pos++;
    while(i.hasNext()) {
        QString word = i.next();
        QRectF rect = putWord(word, x, y, isOnTop, pos, map);
        points->push_back(findPointForConnection(rect, x, y, isOnTop));
        x += rect.width() + space;        
        pos++;
    }
    return points;
}
Ejemplo n.º 16
0
         //
         // Info::putChunk
         //
         void Info::putChunk(char const *name, Core::Array<Core::String> const &strs, bool junk)
         {
            std::size_t base;
            std::size_t off;

            // Calculate base offset.
            base = strs.size() * 4 + 4;
            if(junk) base += 8;

            // Calculate size of chunk.
            off = base;
            for(auto const &s : strs)
               off += lenString(s);

            // Write chunk header.
            putData(name, 4);
            putWord(off);

            // Write string count.
            if(junk) putWord(0);
            putWord(strs.size());
            if(junk) putWord(0);

            // Write string offsets.
            off = base;
            for(auto const &s : strs)
            {
               putWord(off);
               off += lenString(s);
            }

            // Write strings.
            if(junk && UseChunkSTRE)
            {
               off = base;
               for(auto const &s : strs)
               {
                  putString(s, off * 157135);
                  off += lenString(s);
               }
            }
            else for(auto const &s : strs)
               putString(s);
         }
Ejemplo n.º 17
0
/**
 * Function: memCond
 * This function returns the value to be sent as valM
 * and reads or writes from memory if needed
 * Return: value to be used as valM
 */
unsigned int memCond(unsigned int valE,bool * memError) {
     bool tempEr = FALSE;
     unsigned int ret = M.valA;
     if(memRead()){
         ret = getWord(valE,&tempEr);
         *memError = tempEr; 
     }
     else if(memWrite()){
         putWord(valE,M.valA,&memError);
         ret = M.valA;
     }
     return ret;
}
Ejemplo n.º 18
0
void mFormat(char *string)
{
    char wordBuf[MAXWORD + 8];
    int i;

    for (i = 0; string[i] &&
    (outFlag == OUTOK || outFlag == IMPERVIOUS || outFlag == OUTPARAGRAPH);) {
        i = getWord(wordBuf, string, i, MAXWORD);
        putWord(wordBuf);
        if (mAbort())
            return;
    }
}
Ejemplo n.º 19
0
         //
         // Info::putChunkFUNC
         //
         void Info::putChunkFUNC()
         {
            if(!numChunkFUNC) return;

            Core::Array<IR::Function const *> funcs{numChunkFUNC};

            for(auto &f : funcs) f = nullptr;

            for(auto const &itr : prog->rangeFunction())
            {
               if(itr.ctype != IR::CallType::LangACS)
                  continue;

               funcs[itr.valueInt] = &itr;
            }

            putData("FUNC", 4);
            putWord(numChunkFUNC * 8);

            for(auto f : funcs)
            {
               if(f)
               {
                  putByte(f->param);
                  putByte(std::max(f->localReg, f->param));
                  putByte(!!f->retrn);
                  putByte(0);

                  if(f->defin)
                     putExpWord(resolveGlyph(f->label));
                  else
                     putWord(0);
               }
               else
                  putData("\0\0\0\0\0\0\0\0", 8);
            }
         }
Ejemplo n.º 20
0
         //
         // Info::putChunkAIMP
         //
         void Info::putChunkAIMP()
         {
            if(!numChunkAIMP) return;

            Core::Array<IR::Space const *> imps{numChunkAIMP};

            auto itr = imps.begin();
            for(auto const &sp : prog->rangeSpaceMapArs())
               if(!sp.defin) *itr++ = &sp;

            Core::FastU size = numChunkAIMP * 8;
            for(auto const &imp : imps)
               size += lenString(imp->glyph);

            putData("AIMP", 4);
            putWord(size);

            for(auto const &imp : imps)
            {
               putWord(imp->value);
               putWord(imp->words);
               putString(imp->glyph);
            }
         }
Ejemplo n.º 21
0
         //
         // Info::putChunkLOAD
         //
         void Info::putChunkLOAD()
         {
            numChunkLOAD = prog->sizeImport();

            if(!numChunkLOAD) return;

            Core::FastU size = 0;

            for(auto const &itr : prog->rangeImport())
               size += lenString(itr.glyph);

            putData("LOAD", 4);
            putWord(size);

            for(auto const &itr : prog->rangeImport())
               putString(itr.glyph);
         }
Ejemplo n.º 22
0
void Speller::addToDictionary()
{
    if (QAction* act = qobject_cast<QAction*>(sender())) {
        const QString &word = act->data().toString();
        putWord(word);

        if (!m_userDictionary.open(QFile::WriteOnly | QFile::Append)) {
            qWarning() << "SpellCheck: Cannot open file" << m_userDictionary.fileName() << "for writing!";
            return;
        }

        QTextStream stream(&m_userDictionary);
        stream.setCodec("UTF-8");
        stream << word << endl;
        m_userDictionary.close();
    }
}
Ejemplo n.º 23
0
void Speller::initialize()
{
    delete m_hunspell;
    m_hunspell = 0;

    if (m_dictionaryPath.isEmpty()) {
        qWarning() << "SpellCheck: Cannot locate dictionary path!";
        return;
    }

    QString dictionary = m_dictionaryPath + m_language.code;

    if (!dictionaryExists(dictionary)) {
        qWarning() << "SpellCheck: Dictionaries for" << dictionary << "doesn't exists!";
        return;
    }

    const QString dicPath = dictionary + ".dic";
    const QString affPath = dictionary + ".aff";

    m_hunspell = new Hunspell(affPath.toLocal8Bit().constData(),
                              dicPath .toLocal8Bit().constData());

    m_textCodec = QTextCodec::codecForName(m_hunspell->get_dic_encoding());

    if (m_userDictionary.exists()) {
        if (!m_userDictionary.open(QFile::ReadOnly)) {
            qWarning() << "SpellCheck: Cannot open" << m_userDictionary.fileName() << "for reading!";
        }
        else {
            QString word;
            QTextStream stream(&m_userDictionary);
            stream.setCodec("UTF-8");
            while (!stream.atEnd()) {
                stream >> word;
                putWord(word);
            }
        }
        m_userDictionary.close();
    }

    qDebug() << "SpellCheck: Language =" << language().code
             << (m_textCodec ? m_textCodec->name() : "invalid text codec");
}
Ejemplo n.º 24
0
bool
SimpleProperties::Writer::add(const char * value, int len){
  const Uint32 valLen = (len + 3) / 4;

  if ((len % 4) == 0)
    return putWords((Uint32*)value, valLen);

  const Uint32 putLen= valLen - 1;
  if (!putWords((Uint32*)value, putLen))
    return false;

  // Special handling of last bytes
  union {
    Uint32 lastWord;
    char lastBytes[4];
  } tmp;
  tmp.lastWord =0 ;
  memcpy(tmp.lastBytes,
         value + putLen*4,
         len - putLen*4);
  return putWord(tmp.lastWord);
}
Ejemplo n.º 25
0
         //
         // Info::putChunkSVCT
         //
         void Info::putChunkSVCT()
         {
            if(!numChunkSVCT) return;

            putData("SVCT", 4);
            putWord(numChunkSFLG * 4);

            for(auto const &itr : prog->rangeFunction())
            {
               if(itr.ctype != IR::CallType::Script  &&
                  itr.ctype != IR::CallType::ScriptI &&
                  itr.ctype != IR::CallType::ScriptS)
                  continue;

               if(!itr.defin) continue;

               if(itr.localReg <= 20) continue;

               putHWord(itr.valueInt);
               putHWord(itr.localReg);
            }
         }
Ejemplo n.º 26
0
/* memoryStage
 *      Controls the main combinational logic of the memory stage
 * Params:   fwdStruct *fwd - contains a bunch of forwarding info 
 * Returns:  void
 * Modifies: Writeback Register
 */
void memoryStage(fwdStruct *fwd) {

    if (M.stat == SINS || M.stat == SADR || M.stat == SHLT)
        canUpdateMem = FALSE;
 
    int valM = M.valA, stat = M.stat;

    bool readC = FALSE, writeC = FALSE, memError = FALSE;
    
    memoryControl(&readC, &writeC);
    
    int memAddr = memoryAddr();
    
    if (readC)
        valM = getWord(memAddr, &memError);
    
    if (writeC && canUpdateMem)
        putWord(memAddr, M.valA, &memError);

    if (memError) {
        stat = SADR;
        canUpdateMem = FALSE;
    }
    
    fwd->M_valE = M.valE;
    fwd->m_valM = valM;
    fwd->M_dstE = M.dstE;
    fwd->M_dstM = M.dstM;
    fwd->M_Cnd = M.Cnd;
    fwd->M_icode = M.icode;
    fwd->M_valA = M.valA;
    fwd->m_stat = stat;

    if (!W_stall(fwd))
        updateWregister(stat, M.icode, M.valE, valM, M.dstE, M.dstM);
    
}
Ejemplo n.º 27
0
void executeSDT(struct single_data_transfer_decoded single_data_transfer_instr){

   //PREINDEXING
   if(single_data_transfer_instr.pre_or_post_indexing_bit){
      
     //LOADED FROM MEMORY Rn := [address], LDR PREINDEXING
     if(single_data_transfer_instr.load_or_store_bit){ 
       
       //Offset is added to base register
       if(single_data_transfer_instr.up_bit){
	
	 //Memory address is definitely in memory
         if(machine.registers[single_data_transfer_instr.base_reg]
                               + single_data_transfer_instr.offset < MEMSIZE) {
	
	  machine.registers[single_data_transfer_instr.src_or_dst_reg] =
                 getWord(machine.registers[single_data_transfer_instr.base_reg]
                  + single_data_transfer_instr.offset);
		 
         //NOTE: isGPIOPin prints 'Pin accessed..'
	 } else if(
	   isGPIOPin(machine.registers[single_data_transfer_instr.base_reg] 
	          + single_data_transfer_instr.offset)) { 
	   
	    machine.registers[single_data_transfer_instr.src_or_dst_reg] =
	          machine.registers[single_data_transfer_instr.base_reg] 
	             + single_data_transfer_instr.offset;
	    
	  //No print needed here for ldr
	  } else if(
        isGPIOSetOrClear(machine.registers[single_data_transfer_instr.base_reg]
	                             + single_data_transfer_instr.offset)) {  
	    
	    //This bit of memory isn't actually in the emulator
	    
	  } else {
            printf("Error: Out of bounds memory access at address 0x%08x\n", 
                    machine.registers[single_data_transfer_instr.base_reg]
                        + single_data_transfer_instr.offset);
	  }

        } else {
	  
	  if(machine.registers[single_data_transfer_instr.base_reg]
                       - single_data_transfer_instr.offset < MEMSIZE) {
	
	    machine.registers[single_data_transfer_instr.src_or_dst_reg] =
              getWord(machine.registers[single_data_transfer_instr.base_reg]
                      - single_data_transfer_instr.offset);
	      
	  //NOTE: isGPIOPin prints 'Pin accessed..'
	  } else if(
	    isGPIOPin(machine.registers[single_data_transfer_instr.base_reg]
	                              - single_data_transfer_instr.offset)) { 
	   
	    machine.registers[single_data_transfer_instr.src_or_dst_reg] = 
	       machine.registers[single_data_transfer_instr.base_reg] 
	          - single_data_transfer_instr.offset;
	    
	  //No print needed here for ldr
	  } else if(
	isGPIOSetOrClear(machine.registers[single_data_transfer_instr.base_reg]
	                 - single_data_transfer_instr.offset)) { 

	    //This bit of memory isn't actually in the emulator
	    
	  } else {
            printf("Error: Out of bounds memory access at address 0x%08x\n",
		   machine.registers[single_data_transfer_instr.base_reg]
                   - single_data_transfer_instr.offset);
	  }
         
        }
        
    //STORING INTO MEMORY [address] := Rn, STR PREINDEXING
    } else {
       
       if(single_data_transfer_instr.up_bit){
        
	 if(machine.registers[single_data_transfer_instr.base_reg]
                 + single_data_transfer_instr.offset < MEMSIZE) {
	
	  putWord(machine.registers[single_data_transfer_instr.base_reg] +
             single_data_transfer_instr.offset,
                 machine.registers[single_data_transfer_instr.src_or_dst_reg]);
	  
	  //NOTE: isGPIOPin prints 'Pin accessed..'
	  } else if(
	    isGPIOPin(machine.registers[single_data_transfer_instr.base_reg]
	                               + single_data_transfer_instr.offset)) {
	   
            //This bit of memory isn't actually in emulator
	    
	  } else if(
	isGPIOSetOrClear(machine.registers[single_data_transfer_instr.base_reg]
	                 + single_data_transfer_instr.offset)) {
	    
	    if (machine.registers[single_data_transfer_instr.src_or_dst_reg] != 0) {
	    
	      //If output set register, PIN ON, otherwise it is clearing
              if(machine.registers[single_data_transfer_instr.base_reg] 
		      + single_data_transfer_instr.offset == GPIO_OUTPUT_SET_0) {
	        printf("PIN ON\n");
	      } else {
	        printf("PIN OFF\n");
	      }
	      
	    }
	    
	    //This bit of memory isn't actually in emulator
	    
	  } else {
          printf("Error: Out of bounds memory access at address 0x%08x\n",
		 machine.registers[single_data_transfer_instr.base_reg]
                 + single_data_transfer_instr.offset);
	  } 
	 
	 
       } else {
	 
	 if(machine.registers[single_data_transfer_instr.base_reg]
                    - single_data_transfer_instr.offset < MEMSIZE) {
	
	  putWord(machine.registers[single_data_transfer_instr.base_reg] -
             single_data_transfer_instr.offset,
                 machine.registers[single_data_transfer_instr.src_or_dst_reg]);
	  
	  //NOTE: isGPIOPin prints 'Pin accessed..'
	  } else if(
	    isGPIOPin(machine.registers[single_data_transfer_instr.base_reg]
	              - single_data_transfer_instr.offset)) { 
	   
            //This bit of memory isn't actually in emulator
	    
	  } else if(
       isGPIOSetOrClear(machine.registers[single_data_transfer_instr.base_reg] 
	            - single_data_transfer_instr.offset)) {
	    
	    if (machine.registers[single_data_transfer_instr.src_or_dst_reg]
	                                                               != 0) {
	    
              if(machine.registers[single_data_transfer_instr.base_reg]
		    - single_data_transfer_instr.offset == GPIO_OUTPUT_SET_0) {
	        printf("PIN ON\n");
	      } else { 
	        printf("PIN OFF\n");
	      }
	      
	    }
	    
	    //This bit of memory isn't actually in emulator
	    
	  } else {
	    
            printf("Error: Out of bounds memory access at address 0x%08x\n", 
		   machine.registers[single_data_transfer_instr.base_reg]
                     - single_data_transfer_instr.offset);
	    
	  } 
	
       }
    }
    
  //POSTINDEXING
  } else {

    //LOADED FROM MEMORY, LDR POSTINDEXING (No offset)
    if(single_data_transfer_instr.load_or_store_bit) {   
      
       if(machine.registers[single_data_transfer_instr.base_reg] < MEMSIZE){
	
	  machine.registers[single_data_transfer_instr.src_or_dst_reg] =
             getWord(machine.registers[single_data_transfer_instr.base_reg]);
	     
	  //NOTE: isGPIOPin prints 'Pin accessed..'   
	} else if(
	   isGPIOPin(machine.registers[single_data_transfer_instr.base_reg])) { 
	   
	    machine.registers[single_data_transfer_instr.src_or_dst_reg] =
	               machine.registers[single_data_transfer_instr.base_reg];
		       
	//No print needed here for ldr  
	} else if(isGPIOSetOrClear(
	             machine.registers[single_data_transfer_instr.base_reg])) {
	    
	  //This bit of memory isn't actually in the emulator
	    
	} else {
	    
          printf("Error: Out of bounds memory access at address 0x%08x\n", 
	         machine.registers[single_data_transfer_instr.base_reg]);
	    
	}
	  
      //Adding offset
      if(single_data_transfer_instr.up_bit) {

        machine.registers[single_data_transfer_instr.base_reg] +=
           single_data_transfer_instr.offset;

      //Subtracting offset   
      } else {

       machine.registers[single_data_transfer_instr.base_reg] -=
           single_data_transfer_instr.offset;
	   
      }

    //STR POSTINDEXING
    } else {

      if(machine.registers[single_data_transfer_instr.base_reg] < MEMSIZE){
	
	  putWord(machine.registers[single_data_transfer_instr.base_reg],
                 machine.registers[single_data_transfer_instr.src_or_dst_reg]);
	  
	  //NOTE: isGPIOPin prints 'Pin accessed..'
	  } else if(isGPIOPin(
	            machine.registers[single_data_transfer_instr.base_reg])) { 
	   
            //This bit of memory isn't actually in emulator
	    
	  } else if(isGPIOSetOrClear(
	             machine.registers[single_data_transfer_instr.base_reg])) {
	    
	    if (machine.registers[single_data_transfer_instr.src_or_dst_reg]
	                                                                != 0) {
	    
              if(machine.registers[single_data_transfer_instr.base_reg]
		                                               == GPIO_OUTPUT_SET_0) {
	        printf("PIN ON\n");
	      } else { 
	        printf("PIN OFF\n");
	      }
	      
	    }
	    
	    //This bit of memory isn't actually in emulator
	    
	  } else {
	    
          printf("Error: Out of bounds memory access at address 0x%08x\n", 
		  machine.registers[single_data_transfer_instr.base_reg]);
	  
	  }    
	  
      if(single_data_transfer_instr.up_bit){

        machine.registers[single_data_transfer_instr.base_reg] +=
            single_data_transfer_instr.offset;
	  
      } else {
      
        machine.registers[single_data_transfer_instr.base_reg] -=
            single_data_transfer_instr.offset;
	  
      }
    
    }

  }

}
Ejemplo n.º 28
0
void laydata::TEDfile::putRevision() 
{
   putByte(tedf_REVISION);
   putWord(_revision);
   putWord(_subrevision);
}
Ejemplo n.º 29
0
Bool OutputControl::CheckInput(Bool Pause)
#endif
	{
	if (User.Continuous)
		{
		Pause = FALSE;
		}

	if (User.ControlD)
		{
		tw()KBReady();			// for screenblanker
		SetOutFlag(OUTSKIP);	// Auto-Stop everything
		return (TRUE);
		}

	// Cannot abort IMPERVIOUS
	if (User.GetOutFlag() == IMPERVIOUS)
		{
		tw()KBReady();			// for screenblanker
		return (FALSE);
		}

	// Carrier loss and not on Console
	if (!tw()HaveConnectionToUser())
		{
		SetOutFlag(OUTSKIP);
		return (TRUE);
		}

	Bool toReturn = FALSE;

	// Check for keypress
	if (tw()BBSCharReady() || Pause)
		{
		int c;

		if (!Pause)
			{
			c = toupper(tw()iCharNE());
			}

		if (Pause || c == 'P' || c == 19)   // P or ^S (XOFF) - Pause
			{
			if (Pause)
				{
				char Buffer[80];
				tw()CurrentUser->GetMorePrompt(Buffer, sizeof(Buffer));

				if (!tw()outSpeech(TRUE, tw()loggedIn ? Buffer : cfg.moreprompt))
					{
					tw()putWord((uchar *) (tw()loggedIn ? Buffer : cfg.moreprompt));
					}
				}

			do
				{
				// wait to resume
				c = toupper(tw()iCharNE());
				} while (!tw()CurrentUser->IsPUnPauses() && (c == 'P' || c == 19));

			if (Pause)
				{
				char Buffer[80];
				int i, backspace = strlen(tw()loggedIn ?
						tw()CurrentUser->GetMorePrompt(Buffer, sizeof(Buffer)) : cfg.moreprompt);

				for (i = 0; i < backspace; i++)
					{
					tw()doBS();
					}
				}
			}

		if (User.GetOutFlag() == NOSTOP)
			{
			return (FALSE);
			}

		const Bool WasFormatting = Formatting;
		Formatting = TRUE;

		switch (c)
			{
			case CTRL_D:
				{
				User.ControlD = TRUE;
				SetOutFlag(OUTSKIP);

				toReturn = TRUE;
				break;
				}

			case '9':
				{
				if (tw()hitSix)
					{
					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (!tw()outSpeech(TRUE, getmsg(69)))
						{
						tw()putWord((uchar *) getmsg(69));
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					tw()doCR();
					}

				break;
				}

			case 'J':                               // jump paragraph
				{
				tw()doCR();

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(327));

				tw()termCap(TERM_BOLD);
				if (!tw()outSpeech(TRUE, getmsg(547)))
					{
					tw()putWord((uchar *) getmsg(547));
					}

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(326));

				tw()doCR();

				SetOutFlag(OUTPARAGRAPH);

				break;
				}

			case 'K':                               // kill
				{
				if (User.CanK)
					{
					tw()MRO.DotoMessage = PULL_IT;

					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (!tw()outSpeech(TRUE, getmsg(546)))
						{
						tw()putWord((uchar *) getmsg(546));
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					SetOutFlag(OUTNEXT);

					toReturn = TRUE;
					}

				break;
				}

			case 'M':                               // mark
				{
				if (User.CanM)
					{
					tw()MRO.DotoMessage = MARK_IT;

					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (!tw()outSpeech(TRUE, getmsg(543)))
						{
						tw()putWord((uchar *) getmsg(543));
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					SetOutFlag(OUTNEXT);

					toReturn = TRUE;
					}

				break;
				}

			case '*':                               // censor
				{
				if (User.CanStar)
					{
					tw()MRO.DotoMessage = CENSOR_IT;

					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (!tw()outSpeech(TRUE, getmsg(538)))
						{
						tw()putWord((uchar *) getmsg(538));
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					SetOutFlag(OUTNEXT);

					toReturn = TRUE;
					}

				break;
				}

			case 'N':                               // next
				{
				tw()doCR();

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(327));

				tw()termCap(TERM_BOLD);
				if (!tw()outSpeech(TRUE, getmsg(537)))
					{
					tw()putWord((uchar *) getmsg(537));
					}

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(326));

				tw()doCR();
				SetOutFlag(OUTNEXT);

				toReturn = TRUE;
				break;
				}

			case 'S':                               // stop
				{
				tw()numLines = 0;	// Don't pause for stop!

				tw()doCR();

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(327));

				tw()termCap(TERM_BOLD);
				if (!tw()outSpeech(TRUE, getmsg(528)))
					{
					tw()putWord((uchar *) getmsg(528));
					}

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(326));

				tw()doCR();
				SetOutFlag(OUTSKIP);

				toReturn = TRUE;
				break;
				}

			case 'C':                               // continuous
				{
				tw()doCR();

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(327));

				tw()termCap(TERM_BOLD);
				if (!User.Continuous)
					{
					if (!tw()outSpeech(TRUE, getmsg(527)))
						{
						tw()putWord((uchar *) getmsg(527));
						}
					}
				else
					{
					if (!tw()outSpeech(TRUE, getmsg(526)))
						{
						tw()putWord((uchar *) getmsg(526));
						}
					}

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(326));

				User.Continuous = !User.Continuous;

				tw()doCR();

				break;
				}

			case 'R':
				{
				if (User.CanR)
					{
					tw()MRO.DotoMessage = REVERSE_READ;
					SetOutFlag(OUTNEXT);
					}

				break;
				}

			case 'V':
				{
				tw()MRO.Verbose = !tw()MRO.Verbose;

				tw()doCR();

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(327));

				tw()termCap(TERM_BOLD);
				if (tw()MRO.Verbose)
					{
					if (!tw()outSpeech(TRUE, getmsg(524)))
						{
						tw()putWord((uchar *) getmsg(524));
						}
					}
				else
					{
					if (!tw()outSpeech(TRUE, getmsg(519)))
						{
						tw()putWord((uchar *) getmsg(519));
						}
					}

				tw()termCap(TERM_NORMAL);
				tw()putWord((const uchar *) getmsg(326));

				tw()doCR();

				break;
				}

			case '!':
				{
				if (User.CanBang)
					{
					tw()MRO.Headerscan = !tw()MRO.Headerscan;

					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (tw()MRO.Headerscan)
						{
						if (!tw()outSpeech(TRUE, getmsg(517)))
							{
							tw()putWord((uchar *) getmsg(517));
							}
						}
					else
						{
						if (!tw()outSpeech(TRUE, getmsg(511)))
							{
							tw()putWord((uchar *) getmsg(511));
							}
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					tw()doCR();
					}

				break;
				}

			case '@':
				{
				if (User.CanAt)
					{
					tw()MRO.DotoMessage = REPLY;

					tw()doCR();

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(327));

					tw()termCap(TERM_BOLD);
					if (!tw()outSpeech(TRUE, getmsg(470)))
						{
						tw()putWord((uchar *) getmsg(470));
						}

					tw()termCap(TERM_NORMAL);
					tw()putWord((const uchar *) getmsg(326));

					tw()doCR();
					}

				break;
				}
			}

		Formatting = WasFormatting;

		if (c == '6')
			{
			tw()hitSix = TRUE;
			}
		else
			{
			tw()hitSix = FALSE;
			}
		}

	return (toReturn);
	}
Ejemplo n.º 30
0
int main(int argc, char *argv[])
{
  // for error returns from vm520 functions
  int errorNumber;

  // expects the number of processors to be given on the command line
  if ((argc != 2) || (argv[1][0] == 0))
  {
    fprintf(stderr, "usage: pi numberOfprocessors\n");
    exit(-1);
  }

  // get the specified number of processors
  errno = 0;
  char *p;
  long int processors = strtol(argv[1], &p, 10);
  if ((*p != 0) || errno || (processors < 0) || (processors > 16))
  {
    fprintf(stderr, "%s is not a valid number of processors\n", argv[1]);
    exit(-1);
  }

  // load pi.obj
  if (!loadObjectFile("pi.obj", &errorNumber))
  {
    fprintf(stderr, "loadObjectFile fails with error %d\n", errorNumber);
    exit(-1);
  }

  // get the addresses of the exported labels
  unsigned int addressFour;
  unsigned int addressOne;
  unsigned int addressOneHalf;
  unsigned int addressWidth;
  unsigned int addressIntervals;
  unsigned int addressAnswer;
  if (!getAddress("four", &addressFour))
  {
    fprintf(stderr, "getAddress fails for four\n");
    exit(-1);
  }
  if (!getAddress("one", &addressOne))
  {
    fprintf(stderr, "getAddress fails for one\n");
    exit(-1);
  }
  if (!getAddress("oneHalf", &addressOneHalf))
  {
    fprintf(stderr, "getAddress fails for oneHalf\n");
    exit(-1);
  }
  if (!getAddress("intervals", &addressIntervals))
  {
    fprintf(stderr, "getAddress fails for intervals\n");
    exit(-1);
  }
  if (!getAddress("width", &addressWidth))
  {
    fprintf(stderr, "getAddress fails for width\n");
    exit(-1);
  }
  if (!getAddress("answer", &addressAnswer))
  {
    fprintf(stderr, "getAddress fails for answer\n");
    exit(-1);
  }

  // put initial values into the exported symbols
  float x;
  int intervals = INTERVALS;
  x = 1.0;
  if (!putWord(addressOne, * (int *) &x))
  {
    fprintf(stderr, "putWord fails for one (%d)\n", addressOne);
    exit(-1);
  }
  x = 4.0;
  if (!putWord(addressFour, * (int *) &x))
  {
    fprintf(stderr, "putWord fails for four (%d)\n", addressFour);
    exit(-1);
  }
  x = 0.5;
  if (!putWord(addressOneHalf, * (int *) &x))
  {
    fprintf(stderr, "putWord fails for oneHalf (%d)\n", addressOneHalf);
    exit(-1);
  }
  if (!putWord(addressIntervals, intervals))
  {
    fprintf(stderr, "putWord fails for intervals (%d)\n", addressIntervals);
    exit(-1);
  }
  x = 1.0 / intervals;
  if (!putWord(addressWidth, * (int *) &x))
  {
    fprintf(stderr, "putWord fails for width (%d)\n", addressWidth);
    exit(-1);
  }
 
  // execute the program
  unsigned int SP[processors];
  int status[processors];
  int wordAnswer;
  int i;
  int nextSP = 1000;
  for (i = 0; i < processors; i++)  // set initial SP values
  {
    SP[i] = nextSP;
    nextSP += 1000;
  }
  printf("starting vm520 with %ld processors\n", processors);
  if (!execute(processors, SP, status, TRACE))
  {
    fprintf(stderr, "execute fails\n");
    exit(-1);
  } 
  for (i = 0; i < processors; i++)
  {
    printf("processor %d halted with status %d\n", i, status[i]);
  }
  if (!getWord(addressAnswer, &wordAnswer))
  {
    fprintf(stderr, "getWord fails for answer (%u)\n", addressAnswer);
    exit(-1);
  }
  printf("answer is %8.6f\n", * (float *) &wordAnswer);

  return 0;
}