Пример #1
0
Item AbstractFloatMathematician<isDouble>::calculate(const Item &o1,
                                                          const Operator op,
                                                          const Item &o2,
                                                          const QExplicitlySharedDataPointer<DynamicContext> &context) const
{
    const Numeric *const num1 = o1.template as<Numeric>();
    const Numeric *const num2 = o2.template as<Numeric>();
    switch(op)
    {
        case Div:
            return toItem(AbstractFloat<isDouble>::fromValue(num1->toDouble() / num2->toDouble()));
        case IDiv:
        {
            if(num1->isNaN() || num2->isNaN())
            {
                context->error(QtXmlPatterns::tr("No operand in an integer division, %1, can be %2.")
                                  .arg(formatKeyword("idiv"))
                                  .arg(formatData("NaN")),
                               ReportContext::FOAR0002, this);
            }
            else if(num1->isInf())
            {
                context->error(QtXmlPatterns::tr("The first operand in an integer division, %1, cannot be infinity (%2).")
                                                 .arg(formatKeyword("idiv"))
                                                 .arg(formatData("INF")),
                               ReportContext::FOAR0002, this);
            }
            else if(num2->toInteger() == 0)
                context->error(QtXmlPatterns::tr("The second operand in a division, %1, cannot be zero (%2).")
                                                 .arg(formatKeyword("idiv"))
                                                 .arg(formatData("0")),
                               ReportContext::FOAR0001, this);

            return Integer::fromValue(static_cast<xsInteger>(num1->toDouble() / num2->toDouble()));
        }
        case Substract:
            return toItem(AbstractFloat<isDouble>::fromValue(num1->toDouble() - num2->toDouble()));
        case Mod:
            return toItem(AbstractFloat<isDouble>::fromValue(::fmod(num1->toDouble(), num2->toDouble())));
        case Multiply:
            return toItem(AbstractFloat<isDouble>::fromValue(num1->toDouble() * num2->toDouble()));
        case Add:
            return toItem(AbstractFloat<isDouble>::fromValue(num1->toDouble() + num2->toDouble()));
    }

    Q_ASSERT(false);
    return Item(); /* GCC unbarfer. */
}
Пример #2
0
jschar *
Statistics::formatJSON(uint64_t timestamp)
{
    StatisticsSerializer ss(StatisticsSerializer::AsJSON);
    formatData(ss, timestamp);
    return ss.finishJSString();
}
Пример #3
0
 /*
 * Encrypt the given Payload, update sender context and output
 * decryption in ciphermessage.
 *
 * ciphermessage        pointer output array with size >= payload + MAC_LENGTH
 * ENC_sender_ctx       pointer to the encoding sender context
 * Payload              pointer to the plaintext to send
 * Plen                 the length of Payload in bytes max size = MAX_MESSAGE_LENGTH - MAC_LENGTH
 */
 void CCM_encrypt(message_ctx *ciphermessage, ENC_ctx *ENC_sender_ctx, const void *Payloadin, const unsigned int Plen)
 {
    const unsigned char *Payload = Payloadin;

    unsigned char TEMP[((MAX_MESSAGE_LENGTH*2 - MAC_LENGTH-1)/BLOCK_LENGTH + 1 + 2)*BLOCK_LENGTH];
    unsigned char MAC[MAC_LENGTH];
    unsigned int * temp = (unsigned int *) (ENC_sender_ctx->nonce+2);
    //increase counter part of Nonce, the counter part is written small endian
    (ENC_sender_ctx->counter)++;
    *temp = ENC_sender_ctx->counter;

    formatData(TEMP, ENC_sender_ctx->nonce ,Payload, Plen);

    generateMAC(MAC, ENC_sender_ctx->key,TEMP,(Plen-1)/BLOCK_LENGTH + 1 +2);
    create_cyphered_counter_block(TEMP, ENC_sender_ctx->key, ENC_sender_ctx->nonce, (Plen-1)/BLOCK_LENGTH + 2);
    XOR(MAC, MAC, TEMP, MAC_LENGTH);
    XOR(ciphermessage->data, Payload, TEMP+BLOCK_LENGTH, Plen);


    ciphermessage->seq_number = ENC_sender_ctx->counter;
    ciphermessage->length = Plen + MAC_LENGTH;

    memcpy(((unsigned char *) (ciphermessage->data)) + Plen,MAC,MAC_LENGTH);

 }
Пример #4
0
jschar *
Statistics::formatMessage()
{
    StatisticsSerializer ss(StatisticsSerializer::AsText);
    formatData(ss, 0);
    return ss.finishJSString();
}
Пример #5
0
void CastingPlatform<TSubClass, issueError>::issueCastError(const Item &validationError,
                                                            const Item &sourceValue,
                                                            const ReportContext::Ptr &context) const
{
    Q_ASSERT(validationError);
    Q_ASSERT(context);
    Q_ASSERT(validationError.isAtomicValue());
    Q_ASSERT(validationError.template as<AtomicValue>()->hasError());

    const ValidationError::Ptr err(validationError.template as<ValidationError>());
    QString msg(err->message());

    if(msg.isNull())
    {
        msg = QtXmlPatterns::tr("It's not possible to cast the value %1 of type %2 to %3")
                 .arg(formatData(sourceValue.stringValue()))
                 .arg(formatType(context->namePool(), sourceValue.type()))
                 .arg(formatType(context->namePool(), targetType()));
    }
    else
    {
        Q_ASSERT(!msg.isEmpty());
        msg = QtXmlPatterns::tr("Failure when casting from %1 to %2: %3")
                 .arg(formatType(context->namePool(), sourceValue.type()))
                 .arg(formatType(context->namePool(), targetType()))
                 .arg(msg);
    }

    /* If m_errorCode is FORG0001, we assume our sub-classer doesn't have a
     * special wish about error code, so then we use the error object's code.
     */
    context->error(msg, m_errorCode == ReportContext::FORG0001 ? err->errorCode() : m_errorCode,
                   static_cast<const TSubClass*>(this));
}
Пример #6
0
 /*
 * Decrypt the given ciphermessage, update receiver context and output
 * decryption in payload.
 *
 * payload              pointer to output array with size >= ciphermessage - MAC_LENGTH
 * payload_size         size of the output payload
 * ENC_receiver_ctx     pointer to the encoding receiver context
 * ciphermessage        pointer to the encrypted input message
 */
 void CCM_decrypt(void *payloadin, unsigned int *payload_size,  ENC_ctx *ENC_receiver_ctx, const message_ctx *ciphermessage){
    unsigned char *payload = payloadin;

    unsigned char MAC[MAC_LENGTH], MAC_check[MAC_LENGTH];
    unsigned char temp[ (1+((MAX_MESSAGE_LENGTH*2 - MAC_LENGTH-1)/BLOCK_LENGTH)+2)*BLOCK_LENGTH];
    unsigned char temp_payload[MAX_MESSAGE_LENGTH*2 - MAC_LENGTH];

    //check of message is not sended again:
    if (ENC_receiver_ctx->counter>=ciphermessage->seq_number){
        if (PRINT_errors == 1){
                printf("\n");
                printf("resending of message");
                printf("\n \n");};
        *payload_size = 0;
        return;
    };

    if (ciphermessage->length <= MAC_LENGTH){
        if (PRINT_errors == 1){
                printf("\n");
                printf("invalid1\n");
                printf("\n \n");};
        *payload_size = 0;
        return;
        };

    // set Nonce counter part to the received counter part (small endian)
    memcpy(ENC_receiver_ctx->nonce+2, &ciphermessage->seq_number, 4);

    create_cyphered_counter_block(temp, ENC_receiver_ctx->key, ENC_receiver_ctx->nonce, (ciphermessage->length -MAC_LENGTH-1)/BLOCK_LENGTH + 2);

    XOR(MAC, ((unsigned char *) (ciphermessage->data)) + ciphermessage->length-MAC_LENGTH,temp, MAC_LENGTH);
    XOR(temp_payload, ciphermessage->data, temp+BLOCK_LENGTH, ciphermessage->length - MAC_LENGTH);

    formatData(temp, ENC_receiver_ctx->nonce ,temp_payload, ciphermessage->length - MAC_LENGTH);

    generateMAC(MAC_check, ENC_receiver_ctx->key,temp,2+(ciphermessage->length - MAC_LENGTH-1)/BLOCK_LENGTH + 1);

    if (memcmp(MAC, MAC_check, MAC_LENGTH) != 0){
        if (PRINT_errors == 1){
                printf("\n");
                printf("invalid2\n");
                printf("\n \n");};
        *payload_size = 0;
        return;
    };
    ENC_receiver_ctx->counter =  ciphermessage->seq_number;
    *payload_size = ciphermessage->length - MAC_LENGTH;
    memcpy(payload,temp_payload, *payload_size);
 }
Пример #7
0
void DataFileExporter::exportDataLine(double timeData, QList <double> dataValues)
{
    /* QList correspond with activeGraphList */

    if (_pSettingsModel->writeDuringLog())
    {
        // Use buffering
        _dataExportBuffer.append(formatData(timeData, dataValues));

        if ((QDateTime::currentMSecsSinceEpoch() - lastLogTime) > _cLogBufferTimeout)
        {
            flushExportBuffer();
        }
    }
}
Пример #8
0
void
Statistics::printStats()
{
    if (fullFormat) {
        fprintf(fp, "GC(T+%.3fs) %s\n",
                t(slices[0].start - startupTime) / 1000.0,
                formatData());
    } else {
        fprintf(fp, "%f %f %f\n",
                t(gcDuration()),
                t(phaseTimes[PHASE_MARK]),
                t(phaseTimes[PHASE_SWEEP]));
    }
    fflush(fp);
}
Пример #9
0
void MainWindow::reload(){
    cout<<"glv "<<this->path<<" "<<logStart<<" "<<logLength<<endl;
    cout<<"dir:"<<this->path<<" start:"<<logStart<<" length:"<<logLength<<endl;
    this->setWindowTitle("glv"+(this->path==""?"":" "+this->path));
    QString split = "*********GLV***xiaozhuai***GLV*********";
    QString result;
    QString cmd;
    cmd= "git";
    QStringList argv;
    argv<<"-C"<<this->path<<"log"<<"--pretty=format:%H*********GLV***xiaozhuai***GLV*********%an*********GLV***xiaozhuai***GLV*********%ae*********GLV***xiaozhuai***GLV*********%ct*********GLV***xiaozhuai***GLV*********%cr*********GLV***xiaozhuai***GLV*********%s";
    //s = "(git -C '"+this->path+"' log --pretty=format:'%H %an %ae %d %s %ct %cr' --abbrev-commit) | (awk 'NR>="+QString::number(this->logStart)+"&&NR<="+QString::number(this->logLength+1)+"')";

    result = this->runCmd(cmd,argv,this->logStart,this->logLength);

    formatData(result);
    render();
}
Пример #10
0
void
Statistics::printStats()
{
    if (fullFormat) {
        StatisticsSerializer ss(StatisticsSerializer::AsText);
        formatData(ss, 0);
        char *msg = ss.finishCString();
        if (msg) {
            fprintf(fp, "GC(T+%.3fs) %s\n", t(slices[0].start - startupTime) / 1000.0, msg);
            js_free(msg);
        }
    } else {
        fprintf(fp, "%f %f %f\n",
                t(gcDuration()),
                t(phaseTimes[PHASE_MARK]),
                t(phaseTimes[PHASE_SWEEP]));
    }
    fflush(fp);
}
Пример #11
0
void
Statistics::endSlice()
{
    slices.back().end = PRMJ_Now();

    if (JSAccumulateTelemetryDataCallback cb = runtime->telemetryCallback)
        (*cb)(JS_TELEMETRY_GC_SLICE_MS, t(slices.back().end - slices.back().start));

    bool last = runtime->gcIncrementalState == gc::NO_INCREMENTAL;
    if (last)
        endGC();

    if (GCSliceCallback cb = runtime->gcSliceCallback) {
        if (last)
            (*cb)(runtime, GC_CYCLE_END, GCDescription(formatData(), !!compartment));
        else
            (*cb)(runtime, GC_SLICE_END, GCDescription(NULL, !!compartment));
    }
}
Пример #12
0
void DataFileExporter::exportDataFile(QString dataFile)
{
    if (_pGraphDataModel->activeCount() != 0)
    {
        const QList<double> keyList = _pGraphView->graphTimeData();
        QList<QCPDataMap *> dataList;
        QStringList logData;

        // Create header
        logData.append(constructDataHeader(false));

        // Create label row
        logData.append(createLabelRow());

        QList<quint16> activeGraphIndexes;
        _pGraphDataModel->activeGraphIndexList(&activeGraphIndexes);

        for(qint32 idx = 0; idx < activeGraphIndexes.size(); idx++)
        {
            // Save data lists
            dataList.append(_pGraphDataModel->dataMap(activeGraphIndexes[idx]));
        }

        // Add data lines
        for(qint32 i = 0; i < keyList.size(); i++)
        {
            QList<double> dataRowValues;
            for(qint32 d = 0; d < dataList.size(); d++)
            {
                dataRowValues.append(dataList[d]->value(keyList[i]).value);
            }

            logData.append(formatData(keyList[i], dataRowValues));
        }

        // Clean file
        clearFile(dataFile);

        // Export data
        writeToFile(dataFile, logData);
    }
}
Пример #13
0
void AccelTreeBuilder<FromDocument>::attribute(const QXmlName &name, const QStringRef &value)
{
    /* Attributes adds a namespace binding, so lets synthesize one.
     *
     * We optimize by checking whether we have a namespace for which a binding would
     * be generated. Happens relatively rarely. */
    if(name.hasPrefix())
        namespaceBinding(QXmlName(name.namespaceURI(), 0, name.prefix()));

    m_document->basicData.append(AccelTree::BasicNodeData(currentDepth(), currentParent(), QXmlNodeModelIndex::Attribute, 0, name));
    ++m_preNumber;
    ++m_size.top();

    m_isPreviousAtomic = false;

    if(name.namespaceURI() == StandardNamespaces::xml && name.localName() == StandardLocalNames::id)
    {
        const QString normalized(value.toString().simplified());

        if(QXmlUtils::isNCName(normalized))
        {
            const QXmlName::LocalNameCode id = m_namePool->allocateLocalName(normalized);

            const int oldSize = m_document->m_IDs.count();
            m_document->m_IDs.insert(id, currentParent());
            /* We don't run the value through m_attributeCompress here, because
             * the likelyhood of it deing identical to another attribute is
             * very small. */
            m_document->data.insert(m_preNumber, normalized);

            /**
             * In the case that we're called for doc-available(), m_context is
             * null, and we need to flag somehow that we failed to load this
             * document.
             */
            if(oldSize == m_document->m_IDs.count() && m_context) // TODO
            {
                Q_ASSERT(m_context);
                m_context->error(QtXmlPatterns::tr("An %1-attribute with value %2 has already been declared.")
                                                   .arg(formatKeyword("xml:id"),
                                                        formatData(normalized)),
                                 FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
                                 this);
            }
        }
        else if(m_context) // TODO
        {
            Q_ASSERT(m_context);

            /* If we're building from an XML Document(e.g, we're fed from QXmlStreamReader, we raise FODC0002,
             * otherwise XQDY0091. */
            m_context->error(QtXmlPatterns::tr("An %1-attribute must have a "
                                               "valid %2 as value, which %3 isn't.").arg(formatKeyword("xml:id"),
                                                                                         formatType(m_namePool, BuiltinTypes::xsNCName),
                                                                                         formatData(value.toString())),
                             FromDocument ? ReportContext::FODC0002 : ReportContext::XQDY0091,
                             this);
        }
    }
    else
        m_document->data.insert(m_preNumber, *m_attributeCompress.insert(value.toString()));
}
Пример #14
0
	DataRetrieval :: DataRetrieval(string file)	
	{
		vector<string>  lines = dataExtraction(file);
		//particle = new ArrayList<ParticleInformation>();
		formatData(lines);
	}