コード例 #1
0
ファイル: ColorEyeIDoc.cpp プロジェクト: dwatow/ColorEyeI
void CColorEyeIDoc::debugByTxt(CString pathName)
{
    std::vector<CString> vStr;
    CString str;

    str.IsEmpty();
    vStr.clear();
    str.Format("點位描述\tLv\tx\ty\tdu\tdv\tT\tDuv\tX\tY\tZ\t量測時間\n");
    vStr.push_back(str);

    for (std::vector<Cartridge2>::iterator iter = m_docRNA.Begin(); iter != m_docRNA.End(); ++iter)
    {                  
        str.Format("%s\t%s\t%s\t\n", iter->GetDescrip(), iter->GetBullet().ShowData(), iter->GetBullet().GetLastTime());
        vStr.push_back(str);
    }

    CStdioFile file;
    CFileException fx;

    pathName.Format("%s_debug.omd", pathName.Left(pathName.GetLength()-4));

    if (!file.Open(pathName, CFile::modeCreate | CFile::modeWrite | CFile::typeText, &fx))
    {
        TCHAR buf[255];
        fx.GetErrorMessage(buf, 255);
        CString strPrompt(buf);
        AfxMessageBox(strPrompt);
    }
    else
    {
        if (!vStr.empty())
            for (std::vector<CString>::iterator it = vStr.begin(); it != vStr.end(); ++it)
                file.WriteString(it->GetBuffer(0));            

        file.Close();
    }
}
コード例 #2
0
ファイル: vm.cpp プロジェクト: 0x7CFE/llst
TObject* SmalltalkVM::performPrimitive(uint8_t opcode, hptr<TProcess>& process, TVMExecutionContext& ec, bool& failed) {
    switch (opcode) {
        // FIXME opcodes 253-255 are not standard
        case 255:
            // Debug trap
            std::printf("Debug trap\n");
            break;

        case 254:
            m_memoryManager->collectGarbage();
            break;

#if defined(LLVM)
        case primitive::LLVMsendMessage: { //252
            TObjectArray* args = ec.stackPop<TObjectArray>();
            TSymbol*  selector = ec.stackPop<TSymbol>();
            try {
                return sendMessage(ec.currentContext, selector, args, 0);
            } catch(TBlockReturn& blockReturn) {
                //When we catch blockReturn we change the current context to block.creatingContext.
                //The post processing code will change 'block.creatingContext' to the previous one
                // and the result of blockReturn will be injected on the stack
                ec.currentContext = blockReturn.targetContext;
                return blockReturn.value;
            } catch(TContext* errorContext) {
                //context is thrown by LLVM:throwError primitive
                //that means that it was not caught by LLVM:executeProcess function
                //so we have to stop execution of the current process and return returnError
                process->context = errorContext;
                failed = true;
                return globals.nilObject;
            }
        } break;

        case 247: { // Jit once: aBlock
            try {
                TBlock* const block = ec.stackPop<TBlock>();
                return JITRuntime::Instance()->invokeBlock(block, ec.currentContext, true);
            } catch(TBlockReturn& blockReturn) {
                ec.currentContext = blockReturn.targetContext;
                return blockReturn.value;
            } catch(TContext* errorContext) {
                process->context = errorContext;
                failed = true;
                return globals.nilObject;
            }
        }
#endif

        case 251: {
            // TODO Unicode support

            TString* prompt = ec.stackPop<TString>();
            std::string strPrompt(reinterpret_cast<const char*>(prompt->getBytes()), prompt->getSize());

            std::string input;
            bool userInsertedAnything = CompletionEngine::Instance()->readline(strPrompt, input);

            if ( userInsertedAnything ) {
                if ( !input.empty() )
                    CompletionEngine::Instance()->addHistory(input);

                TString* result = static_cast<TString*>( newBinaryObject(globals.stringClass, input.size()) );
                std::memcpy(result->getBytes(), input.c_str(), input.size());
                return result;
            } else
                return globals.nilObject;
        } break;

#if defined(LLVM)
        case 250: // patchHotMethods
            JITRuntime::Instance()->patchHotMethods();
            break;

        case 249: { // printMethod
            TMethod* method = ec.stackPop<TMethod>();
            JITRuntime::Instance()->printMethod(method);
        } break;

        case 248:
            JITRuntime::Instance()->printStat();
            break;
#endif

        case primitive::startNewProcess: { // 6
            TInteger  ticks = ec.stackPop();
            TProcess* newProcess = ec.stackPop<TProcess>();

            // FIXME possible stack overflow due to recursive call
            TExecuteResult result = this->execute(newProcess, ticks);

            return TInteger(result);
        } break;

        case primitive::allocateObject: { // 7
            // Taking object's size and class from the stack
            TObject* size  = ec.stackPop();
            TClass*  klass = ec.stackPop<TClass>();
            uint32_t fieldsCount = TInteger(size);

            // Instantinating the object. Each object has size and class fields

            return newOrdinaryObject(klass, sizeof(TObject) + fieldsCount * sizeof(TObject*));
        } break;

        case primitive::blockInvoke: { // 8
            TBlock*  block = ec.stackPop<TBlock>();
            uint32_t argumentLocation = block->argumentLocation;

            // Amount of arguments stored on the stack except the block itself
            uint32_t argCount = ec.instruction.getArgument() - 1;

            // Checking the passed temps size
            TObjectArray* blockTemps = block->temporaries;

            if (argCount > (blockTemps ? blockTemps->getSize() - argumentLocation : 0) ) {
                ec.stackTop -= (argCount  + 1); // unrolling stack
                failed = true;
                break;
            }

            // Loading temporaries array
            for (uint32_t index = argCount - 1, count = argCount; count > 0; index--, count--)
                (*blockTemps)[argumentLocation + index] = ec.stackPop();

            // Switching execution context to the invoking block
            block->previousContext = ec.currentContext->previousContext;
            ec.currentContext = static_cast<TContext*>(block);
            ec.stackTop = 0; // resetting stack

            // Block is bound to the method's bytecodes, so it's
            // first bytecode will not be zero but the value specified
            ec.bytePointer = block->blockBytePointer;

            return block;
        } break;

        case primitive::throwError: // 19
            process->context = ec.currentContext;
            process->result  = ec.returnedValue;
            break;

        case primitive::allocateByteArray: { // 20
            TInteger dataSize = ec.stackPop();
            TClass* klass     = ec.stackPop<TClass>();

            return newBinaryObject(klass, dataSize);
        } break;

        case primitive::arrayAt:      // 24
        case primitive::arrayAtPut: { // 5
            TObject* indexObject = ec.stackPop();
            TObjectArray* array  = ec.stackPop<TObjectArray>();
            TObject* valueObject = 0;

            // If the method is Array:at:put then pop a value from the stack
            if (opcode == primitive::arrayAtPut)
                valueObject = ec.stackPop();

            if (! isSmallInteger(indexObject) ) {
                failed = true;
                break;
            }

            // Smalltalk indexes arrays starting from 1, not from 0
            // So we need to recalculate the actual array index before
            uint32_t actualIndex = TInteger(indexObject) - 1;

            // Checking boundaries
            if (actualIndex >= array->getSize()) {
                failed = true;
                break;
            }

            if (opcode == primitive::arrayAt) {
                return array->getField(actualIndex);
            } else {
                // Array:at:put

                TObject** objectSlot = &( array->getFields()[actualIndex] );

                // Checking whether we need to register current object slot in the GC
                checkRoot(valueObject, objectSlot);

                // Storing the value into the array
                array->putField(actualIndex, valueObject);

                // Return self
                return static_cast<TObject*>(array);
            }
        } break;

        case primitive::cloneByteObject: { // 23
            TClass* klass = ec.stackPop<TClass>();
            hptr<TByteObject> original = newPointer( ec.stackPop<TByteObject>() );

            // Creating clone
            uint32_t dataSize  = original->getSize();
            TByteObject* clone = newBinaryObject(klass, dataSize);

            // Cloning data
            std::memcpy(clone->getBytes(), original->getBytes(), dataSize);
            return static_cast<TObject*>(clone);
        } break;

        //         case primitive::integerDiv:   // Integer /
        //         case primitive::integerMod:   // Integer %
        //         case primitive::integerAdd:   // Integer +
        //         case primitive::integerMul:   // Integer *
        //         case primitive::integerSub:   // Integer -
        //         case primitive::integerLess:  // Integer <
        //         case primitive::integerEqual: // Integer ==
        //             //TODO integer operations
        //             break;

        case primitive::integerNew: { // 32
            TObject* object = ec.stackPop();
            if (! isSmallInteger(object)) {
                failed = true;
                break;
            }

            return object; // FIXME long integer
        } break;

        case primitive::flushCache: // 34
            flushMethodCache();
            break;

        case primitive::bulkReplace: { // 38
            //Implementation of replaceFrom:to:with:startingAt: as a primitive

            // Array replaceFrom: start to: stop with: replacement startingAt: repStart
            //      <38 start stop replacement repStart self>.

            // Current stack contents (top is the top)
            //      self
            //      repStart
            //      replacement
            //      stop
            //      start

            TObject* destination            = ec.stackPop();
            TObject* sourceStartOffset      = ec.stackPop();
            TObject* source                 = ec.stackPop();
            TObject* destinationStopOffset  = ec.stackPop();
            TObject* destinationStartOffset = ec.stackPop();

            bool isSucceeded = doBulkReplace( destination, destinationStartOffset, destinationStopOffset, source, sourceStartOffset );

            if (! isSucceeded) {
                failed = true;
                break;
            }
            return destination;
        } break;

        // TODO cases 33, 35, 40
        // TODO case 18 // turn on debugging

        case primitive::objectsAreEqual:    // 1
        case primitive::getClass:           // 2
        case primitive::getSize:            // 4

        case primitive::ioGetChar:          // 9
        case primitive::ioPutChar:          // 3
        case primitive::ioFileOpen:         // 100
        case primitive::ioFileClose:        // 103
        case primitive::ioFileSetStatIntoArray:   // 105
        case primitive::ioFileReadIntoByteArray:  // 106
        case primitive::ioFileWriteFromByteArray: // 107
        case primitive::ioFileSeek:         // 108

        case primitive::stringAt:           // 21
        case primitive::stringAtPut:        // 22

        case primitive::smallIntAdd:        // 10
        case primitive::smallIntDiv:        // 11
        case primitive::smallIntMod:        // 12
        case primitive::smallIntLess:       // 13
        case primitive::smallIntEqual:      // 14
        case primitive::smallIntMul:        // 15
        case primitive::smallIntSub:        // 16
        case primitive::smallIntBitOr:      // 36
        case primitive::smallIntBitAnd:     // 37
        case primitive::smallIntBitShift:   // 39

        case primitive::getSystemTicks:     //253

        default: {
            uint32_t argCount = ec.instruction.getArgument();
            hptr<TObjectArray> args = newObject<TObjectArray>(argCount);

            uint32_t i = argCount;
            while (i > 0)
                args[--i] = ec.stackPop();

            TObject* result = callPrimitive(opcode, args, failed);
            return result;
        }
    }

    return globals.nilObject;
}