コード例 #1
0
ファイル: ValidNumber.cpp プロジェクト: yuandaxing/leetcode
 bool isNumber(const char *s) {
     int l = 0;
     while(*(s + l) == ' ')
     {
         l++;
     }
     int r = strlen(s) - 1;
     while(*(s + r) == ' ')
     {
         r--;
     }
     int il = l;
     int ir;
     int dl;
     int dr;
     for(int i = l; i <= r; i++)
     {
         if(*(s + i) == 'e')
         {
             ir = i - 1;
             dl = i + 1;
             dr = r;
             return isFloat(s, il, ir) && isInteger(s, dl, dr);
         }
     }
     return isFloat(s, il, r);
 }
コード例 #2
0
/***************************************************************************
 * emit shiftRightUnsigned Operation
  ***************************************************************************/	
CCgNodeData* CCilCodeGen::emitShiftRightUnsignedOperator( CCgNodeData* nodetree )
{
	assert( nodetree != NULL );
	assert( nodetree->NodeType == CG_NODE_FORMULANODE );

	CCgNodeData* ptr = nodetree->lhsNode;
	if( isValue( ptr ) && isValue( nodetree->rhsNode ) )
	{
		//Special case for both values.
		//Create new node
		if( isFloat( ptr ) )
		{
			uint64_t iLhs = (uint64_t)m_FloatConstantPool[ ptr->iIndex ];
			if ( isFloat( nodetree->rhsNode ) )
			{
				int64_t iRhs = (int64_t)m_FloatConstantPool[ nodetree->rhsNode->iIndex ];
				ptr = emitLoadStack( integerConstant( iLhs OP iRhs ) );
				delete ptr;
				return nodetree;
			}
			else
			{
				int64_t iRhs = (int64_t)m_IntegerConstantPool[ nodetree->rhsNode->iIndex ];
				ptr = emitLoadStack( integerConstant( iLhs OP iRhs ) );
				delete ptr;
				return nodetree;
			}
		}
		else
		{
			uint64_t iLhs = m_IntegerConstantPool[ ptr->iIndex ];
			if ( isFloat( nodetree->rhsNode ) )
			{
				int64_t iRhs = (int64_t)m_FloatConstantPool[ nodetree->rhsNode->iIndex ];
				ptr = emitLoadStack( integerConstant( iLhs OP iRhs ) );
				delete ptr;
				return nodetree;
			}
			else
			{
				int64_t iRhs = m_IntegerConstantPool[ nodetree->rhsNode->iIndex ];
				ptr = emitLoadStack( integerConstant( iLhs OP iRhs ) );
				delete ptr;
				return nodetree;
			}
		}	
	}

	//Left hand side
	emitLoadStack( ptr );

	//Right hand side
	ptr = nodetree->rhsNode;
	emitLoadStack( ptr );

	//shiftRightUnsigned 2 stack entries
	emit( CEE_SHR_UN );

	return nodetree;
}
コード例 #3
0
void MessagePackAdaptorTests::testFloat() {
    // Negative
    {
        pack(Datum(-1.5));
        auto o = unpack();
        CPPUNIT_ASSERT_EQUAL( msgpack::type::FLOAT, o.type );
        auto d = o.as<Datum>();
        CPPUNIT_ASSERT( d.isFloat() );
        CPPUNIT_ASSERT_EQUAL( -1.5, d.getFloat() );
    }

    // Zero
    {
        pack(Datum(0.0));
        auto o = unpack();
        CPPUNIT_ASSERT_EQUAL( msgpack::type::FLOAT, o.type );
        auto d = o.as<Datum>();
        CPPUNIT_ASSERT( d.isFloat() );
        CPPUNIT_ASSERT_EQUAL( 0.0, d.getFloat() );
    }

    // Positive
    {
        pack(Datum(2.5));
        auto o = unpack();
        CPPUNIT_ASSERT_EQUAL( msgpack::type::FLOAT, o.type );
        auto d = o.as<Datum>();
        CPPUNIT_ASSERT( d.isFloat() );
        CPPUNIT_ASSERT_EQUAL( 2.5, d.getFloat() );
    }
}
コード例 #4
0
ファイル: Type.cpp プロジェクト: Dgame/Transcompiler
Match matchType(BasicType lhs, BasicType rhs) {
    if (lhs == rhs)
        return Match::Exact;

    if (isNumeric(lhs) && isNumeric(rhs)) {
        const u16_t lhs_size = BasicTypeSize[static_cast<u16_t>(lhs)];
        const u16_t rhs_size = BasicTypeSize[static_cast<u16_t>(rhs)];

        if (isIntegral(lhs) && isIntegral(rhs)) {
            if (isSigned(lhs) == isSigned(rhs)) {
                if (lhs_size >= rhs_size)
                    return Match::Exact;
            }

            return Match::Convert;
        }

        if (isFloat(lhs) && isFloat(rhs)) {
            if (lhs_size >= rhs_size)
                return Match::Exact;
            return Match::Convert;
        }

        if (isFloat(lhs) && isIntegral(rhs)) {
            if (lhs_size >= rhs_size)
                return Match::Exact;
            return Match::Convert;
        }
    }

    return Match::No;
}
コード例 #5
0
ファイル: test_MergeSort.c プロジェクト: JangSing/MergeSort
void test_function_is_float()
{
  float len1=100,len2=100.1212;

  TEST_ASSERT_EQUAL(0,isFloat( len1 ));
  TEST_ASSERT_EQUAL(1,isFloat( len2 ));

}
コード例 #6
0
void Token::setType(){
	char operators[] = {'+', '-', '*', '/', '^'};
	if(token_string.size() == 1){
		if(token_string[0] == 't'){
			is_partial = false;
			token_type = ID_VAR;
			return;
		}
		if(token_string[0] == '@'){
			is_partial = false;
			token_type = ID_FUNCTION;
			return;
		}
		if(token_string[0] == '(' || token_string[0] == ')'){
			is_partial = false;
			token_type = ID_PAREN;
			return;
		}
		for(unsigned int i = 0; i < sizeof(operators)/sizeof(operators[0]); i++){
			if(token_string[0] == operators[i]){
				is_partial = false;
				token_type = ID_OPERATOR;
				if(operators[i] == '+' || operators[i] == '-'){
					precedence = 0;
					is_left_assoc = true;
				}
				if(operators[i] == '*' || operators[i] == '/'){
					precedence = 1;
					is_left_assoc = true;
				}
				if(operators[i] == '^'){
					precedence = 2;
					is_left_assoc = false;
				}
				return;
			}
		}
		//If it gets here, it's neither an operator nor a variable
		if(isFloat(token_string) || token_string[0] == '.'){
			token_type = ID_NUMBER;
		}
	}
	else if(token_string.size() > 1){
		if(isFloat(token_string)){
			token_type = ID_NUMBER;
		}
	}
}
コード例 #7
0
ファイル: AtomContainer.cpp プロジェクト: paulhof/GraDe-A
void AtomContainer::addAtom(const double * pos, const std::vector<std::string>& atomProperties){
	int iProperty;
	//after adding the atom was successful, continue with adding additional properties
	if(addAtom(pos)) {
		//save additional properties
		for (iProperty = 0; iProperty < atomProperties.size(); iProperty++){
			if (!atomPropertyList.isPropertyInt(iProperty)) {
				//property has float type
				atomPropertyList.addFloatPropertyValue(iProperty, atof(atomProperties[iProperty].c_str()));
			} else {
				//property has integer type
				if (isFloat(atomProperties[iProperty])) {
					//but current value is of float type -> conversion
					atomPropertyList.convertPropertyToFloat(iProperty);
					atomPropertyList.addFloatPropertyValue(iProperty, atof(atomProperties[iProperty].c_str()));
				} else {
					//value has also integer type -> add value
					atomPropertyList.addIntPropertyValue(iProperty,atoi(atomProperties[iProperty].c_str()));
				}
			}
		}
	} else {
		std::cout << "WARNING: Adding atom " << getNumAtoms() <<" failed (placed outside container)" << std::endl;
	}
}
コード例 #8
0
ファイル: Valid Number.cpp プロジェクト: xhSong/leetcode
 bool isNumber(const char *s) {
     int left = 0, right = strlen(s) - 1;
     while(left <= right && (s[left] == ' ' || s[left] == '\t' || s[left] == '\n')) {
         ++ left;
     }
     while(left <= right && (s[right] == ' ' || s[right] == '\t' || s[right] == '\n')) {
         -- right;
     }
     if (left > right) return false;
     int cnt_dot = 0, cnt_e = 0, pos_e = 0;
     for (int i = left; i <= right; ++i) {
         if (!('0' <= s[i] && s[i] <= '9')) {
             if (s[i] == '.') {
                 ++ cnt_dot;
             } else if (s[i] == 'e' || s[i] == 'E'){
                 ++ cnt_e;
                 pos_e = i;
             } else if (s[i] != '-' && s[i] != '+'){
                 return false;
             }
         }
     }
     if (cnt_e > 1 || cnt_dot > 1) {
         return false;
     }
     if ((cnt_e && isFloat(s, left, pos_e - 1) && isInt(s, pos_e + 1, right)) || (!cnt_e && isFloat(s, left, right))) {
         return true;
     }
     return false;
 }
コード例 #9
0
void str::operator-=(float n)
{
    if(isFloat())
    {
        (*this) = (float)str::toFloat(mpStr) - n; // Call Assignment Operator for float
    }
}
コード例 #10
0
/***************************************************************************
 * emit unaryPlus Operation
  ***************************************************************************/
CCgNodeData* CCilCodeGen::emitUnaryPlusOperator( CCgNodeData* nodetree )
{
    assert( nodetree != NULL );
    assert( nodetree->NodeType == CG_NODE_FORMULANODE );
    assert( nodetree->lhsNode != NULL );
    assert( nodetree->rhsNode == NULL );

    CCgNodeData* ptr = nodetree->lhsNode;
    if( isValue( ptr ) )
    {
        //Special case for both values.
        //Create new node
        if( isFloat( ptr ) )
        {
            double dLhs = m_FloatConstantPool[ ptr->iIndex ];
            ptr = emitLoadStack( floatConstant( OP dLhs ) );
            delete ptr;
            return nodetree;
        }
        else
        {
            int64_t iLhs = m_IntegerConstantPool[ ptr->iIndex ];
            ptr = emitLoadStack( integerConstant( OP iLhs ) );
            delete ptr;
            return nodetree;
        }
    }

    //Left hand side
    emitLoadStack( ptr );
    emit( CEE_EXT_STARGLIST_S, (uint8_t)1 );	//Move to arglist
    emit( CEE_CALL, m_ridMethodToNumber );		//Function Object Constructor

    return nodetree;
}
コード例 #11
0
ファイル: 2622.c プロジェクト: Crmiv/AlgoSolution
int main()
{
    char str[1024];

    while(gets(str)!=NULL && strcmp(str,"#"))/*/空行/*/
        printf("%s\n",isFloat(str)?"Yes":"No");
}
コード例 #12
0
ファイル: PdTypes.cpp プロジェクト: Apolotary/libpd
//----------------------------------------------------------
float List::getFloat(const unsigned int index) const {
	if(!isFloat(index)) {
		std::cerr << "Pd: List: object " << index << " is not a float" << std::endl;
		return 0;
	}
	return objects[index].value;
}
コード例 #13
0
ファイル: SpatialInterface.cpp プロジェクト: esheldon/misc
// parse the string, returning the number of floats
// that have been in the string.
bool
htmInterface::parseVec( cmdCode code, float64 *v) {

  VarStr  token;
  size_t  i = 0, len;

  if(code == J2000)
    len = 2;
  else if(code == CARTESIAN)
    len = 3;
  else
    throw SpatialInterfaceError("htmInterface:parseVec: Expected code J2000 or CARTESIAN.");

  // parse the next len positions
  while( i < len  ) {
    token = t_->next();
    if(token.empty())break;

    if(!isFloat(token))
      throw SpatialInterfaceError("htmInterface:parse: Expected float at this position of Command. ",cmd_.data());
    if(i == len)
      throw SpatialInterfaceError("htmInterface:parse: Expect less floats in Command. ", cmd_.data());
    v[i++] = atof(token.data());
  }

  if(i < len)
    return false;
  return true;

}
コード例 #14
0
ファイル: AsmJsTypes.cpp プロジェクト: Cellule/ChakraCore
    bool AsmJsType::isSubType(AsmJsType type) const
    {
        switch (type.which_)
        {
        case Js::AsmJsType::Double:
            return isDouble();
            break;

        case Js::AsmJsType::MaybeDouble:
            return isMaybeDouble();
            break;
        case Js::AsmJsType::DoubleLit:
            return isDoubleLit();
            break;
        case Js::AsmJsType::Float:
            return isFloat();
            break;
        case Js::AsmJsType::MaybeFloat:
            return isMaybeFloat();
            break;
        case Js::AsmJsType::Floatish:
            return isFloatish();
            break;
        case Js::AsmJsType::FloatishDoubleLit:
            return isFloatishDoubleLit();
            break;
        case Js::AsmJsType::Fixnum:
            return which_ == Fixnum;
            break;
        case Js::AsmJsType::Int:
            return isInt();
            break;
        case Js::AsmJsType::Signed:
            return isSigned();
            break;
        case Js::AsmJsType::Unsigned:
            return isUnsigned();
            break;
        case Js::AsmJsType::Intish:
            return isIntish();
            break;
        case Js::AsmJsType::Void:
            return isVoid();
            break;
        case AsmJsType::Int32x4:
            return isSIMDInt32x4();
            break;
        case AsmJsType::Float32x4:
            return isSIMDFloat32x4();
            break;
        case AsmJsType::Float64x2:
            return isSIMDFloat64x2();
            break;
        default:
            break;
        }
        return false;
    }
コード例 #15
0
int ParseProfLine(const char *pchIn, long *plAddress, int *piSamples, float *pfPercentage)
{
  char chVal[128], *pchOut;
  
  /* skip any initial whitespace */
  while (isSpace(*pchIn)) pchIn++;
  if (!isHex(*pchIn)) return 0;
  
  /* parse hexadecimal address value */
  pchOut = chVal;
  while (isHex(*pchIn)) *pchOut++ = *pchIn++;
  *pchOut = 0;
  if (!isSpace(*pchIn)) return 0;
  *plAddress = strtol(chVal, NULL, 16);
  
  /* skip more whitespace */
  while (isSpace(*pchIn)) pchIn++;
  if (!isNum(*pchIn)) return 0;
  
  /* parse decimal sample count value */
  pchOut = chVal;
  while (isNum(*pchIn)) *pchOut++ = *pchIn++;
  *pchOut = 0;
  if (!isSpace(*pchIn)) return 0;
  *piSamples = atoi(chVal);
  
  /* skip more whitespace */
  while (isSpace(*pchIn)) pchIn++;
  if (!isFloat(*pchIn)) return 0;
  
  /* parse floating-point percentage value */
  pchOut = chVal;
  while (isFloat(*pchIn)) *pchOut++ = *pchIn++;
  *pchOut = 0;
  if (!isSpace(*pchIn) && *pchIn != '\r' && *pchIn != '\n' && *pchIn != 0) return 0;
  *pfPercentage = atof(chVal);

  /* if this isn't the end of the line, it's not a valid sample point */
  while (isSpace(*pchIn)) pchIn++;
  if (*pchIn != '\r' && *pchIn != '\n' && *pchIn != 0) return 0;
 
  return 1;
}
コード例 #16
0
void OSCServerThread::run()
{
        oscpkt::UdpSocket server;
        server.bindTo(this->port);
        if (!server.isOk()) {
                std::cerr << "Error opening OSC server at " << port
                          << std::endl;
                return;
        }

        std::cout << "Started OSC Server at " << port << std::endl;

        oscpkt::PacketReader reader;
        oscpkt::PacketWriter writer;
        while (server.isOk() && !mustQuit) {
                if (server.receiveNextPacket(30)) {
                        reader.init(server.packetData(), server.packetSize());
                        oscpkt::Message *msg;
                        while (reader.isOk() &&
                               (msg = reader.popMessage()) != 0) {
                                QVariantList message;
                                message.append(QString::fromStdString(
                                    msg->addressPattern()));
                                auto args = msg->arg();
                                while (!args.isOkNoMoreArgs()) {
                                        if (args.isInt32()) {
                                                int32_t i;
                                                args = args.popInt32(i);
                                                message.append(i);
                                        } else if (args.isInt64()) {
                                                int64_t i;
                                                args = args.popInt64(i);
                                                message.append(
                                                    static_cast<qlonglong>(i));
                                        } else if (args.isFloat()) {
                                                float f;
                                                args = args.popFloat(f);
                                                message.append(f);
                                        } else if (args.isDouble()) {
                                                double d;
                                                args = args.popDouble(d);
                                                message.append(d);
                                        } else if (args.isStr()) {
                                                std::string s;
                                                args = args.popStr(s);
                                                message.append(
                                                    QString::fromStdString(s));
                                        }
                                }
                                emit messageIn(message);
                        }
                }
        }
}
コード例 #17
0
void Waifu2x_Process_Base::process_core_rgb()
{
    FLType *dstYd = nullptr, *dstUd = nullptr, *dstVd = nullptr;
    FLType *srcYd = nullptr, *srcUd = nullptr, *srcVd = nullptr;

    // Get write/read pointer
    auto dstR = reinterpret_cast<_Ty *>(vsapi->getWritePtr(dst, 0));
    auto dstG = reinterpret_cast<_Ty *>(vsapi->getWritePtr(dst, 1));
    auto dstB = reinterpret_cast<_Ty *>(vsapi->getWritePtr(dst, 2));

    auto srcR = reinterpret_cast<const _Ty *>(vsapi->getReadPtr(src, 0));
    auto srcG = reinterpret_cast<const _Ty *>(vsapi->getReadPtr(src, 1));
    auto srcB = reinterpret_cast<const _Ty *>(vsapi->getReadPtr(src, 2));

    // Allocate memory for floating point YUV data
    AlignedMalloc(dstYd, dst_pcount[0]);
    if (d.chroma) AlignedMalloc(dstUd, dst_pcount[1]);
    if (d.chroma) AlignedMalloc(dstVd, dst_pcount[2]);

    AlignedMalloc(srcYd, src_pcount[0]);
    AlignedMalloc(srcUd, src_pcount[1]);
    AlignedMalloc(srcVd, src_pcount[2]);

    // Convert src and ref from RGB data to floating point YUV data
    RGB2FloatYUV(srcYd, srcUd, srcVd, srcR, srcG, srcB,
        src_height[0], src_width[0], src_stride[0], src_stride[0],
        d.para.matrix, d.para.full, false);

    // Execute kernel
    if (d.chroma)
    {
        Kernel(dstYd, dstUd, dstVd, srcYd, srcUd, srcVd);
    }
    else
    {
        Kernel(dstYd, srcYd);
        dstUd = srcUd;
        dstVd = srcVd;
    }

    // Convert dst from floating point YUV data to RGB data
    FloatYUV2RGB(dstR, dstG, dstB, dstYd, dstUd, dstVd,
        dst_height[0], dst_width[0], dst_stride[0], dst_stride[0],
        d.para.matrix, d.para.full, !isFloat(_Ty));

    // Free memory for floating point YUV data
    AlignedFree(dstYd);
    if (d.chroma) AlignedFree(dstUd);
    if (d.chroma) AlignedFree(dstVd);

    AlignedFree(srcYd);
    AlignedFree(srcUd);
    AlignedFree(srcVd);
}
コード例 #18
0
ファイル: varstorage.c プロジェクト: BraXi/CoD4X18-Server
qboolean HStorage_StringToValue(varType_t type, char* string, vsValue_t* value)
{
    switch(type)
    {
        default:
            memset(value, 0, sizeof(vsValue_t));
            return qfalse;

        case VSVAR_STRING:
            value->string = string;
            return qtrue;

        case VSVAR_BOOLEAN:
            if(!isInteger(string, 0))
            {
                value->boolean = 0;
                return qfalse;
            }
            value->boolean = atoi(string);
            if(value->boolean != 0 && value->boolean != 1)
            {
                return qfalse;
            }
            return qtrue;

        case VSVAR_INTEGER:
            if(!isInteger(string, 0))
            {
                value->integer = 0;
                return qfalse;
            }
            value->integer = atoi(string);
            return qtrue;

        case VSVAR_FLOAT:
            if(!isFloat(string, 0))
            {
                value->floatVar = 0.0;
                return qfalse;
            }
            value->floatVar = atof(string);
            return qtrue;

        case VSVAR_VECTOR:
            if(!isVector(string, 0, 3))
            {
                memset(value, 0, sizeof(vsValue_t));
                return qfalse;
            }
            strToVect(string, value->vector, 3);
            return qtrue;
    }

}
コード例 #19
0
ファイル: parse.c プロジェクト: BaJIeK/brltty
int
validateFloat (float *value, const char *string, const float *minimum, const float *maximum) {
  if (*string) {
    float f;
    if (!isFloat(&f, string)) return 0;
    if (minimum && (f < *minimum)) return 0;
    if (maximum && (f > *maximum)) return 0;
    *value = f;
  }
  return 1;
}
コード例 #20
0
ファイル: Valid.Number.cpp プロジェクト: alsofly/Interview-Qs
 bool isNumber(const char *s) {
     // Start typing your C/C++ solution below
     // DO NOT write int main() function
     int l = 0, r = strlen(s);
     while (l < r && s[l] == ' ') l++;
     while (l < r && s[r - 1] == ' ') r--;
     if (l >= r) return false;
     if (isInteger(s, l, r)) return true;
     if (isFloat(s, l, r)) return true;
     if (isScitific(s, l, r)) return true;
     return false;
 }
コード例 #21
0
ファイル: SpatialInterface.cpp プロジェクト: esheldon/misc
// get an integer out of the command string
float64 htmInterface::getFloat() {

  if(!t_)
    throw SpatialFailure("htmInterface:getFloat: No command to parse");

  // parse incoming string. expect to have an integer.
  const VarStr &token = t_->next();
  if(!isFloat(token))
    throw SpatialInterfaceError("htmInterface:getFloat: Expected float at first position of Command. ",cmd_.data());

  return atof(token.data());
}
コード例 #22
0
ファイル: Value.cpp プロジェクト: TigreFramework/DataBase
Value::operator double() const {
    if(isString()){
        return Math::toDouble(this->sValue);
    } else if(isInteger()) {
        return (double)(this->iValue);
    } else if(isFloat()) {
        return (double)(this->fValue);
    } else if(isDouble()) {
        return this->dValue;
    }
    throw Exception("Value not found, the type is (" + std::to_string(this->type) + ")");
}
コード例 #23
0
ファイル: codeGenUtils.c プロジェクト: moisesjbc/pl_practicas
void genOperation(FILE* yyout, Symbol* leftSide, Symbol* rightSide, char* op )
{
	int r0, r1;
	r0 = ((ExtraInfo*)(leftSide->info))->nRegister;
	r1 = ((ExtraInfo*)(rightSide->info))->nRegister;
	int isFloat_ = isFloat( leftSide );

	if( !isFloat_ ){
		if(r0 == 7){
			r0 = assignRegisters(0);
			if (r0 == -1){
				r0 = checkOverflow(yyout, r0, TYPE_INTEGER);
			}
			((ExtraInfo*)(leftSide->info))->nRegister = r0;
			extraInfoPerRegister[r0] = ((ExtraInfo*)(leftSide->info));
			fprintf(yyout, "\tR%d = I(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r0);
		}
		if(r1 == 7){
			r1 = assignRegisters(0);
			if (r1 == -1){
				r1 = checkOverflow(yyout, r1, TYPE_INTEGER);
			}
			((ExtraInfo*)(leftSide->info))->nRegister = r1;
			extraInfoPerRegister[r1] = ((ExtraInfo*)(rightSide->info));
			fprintf(yyout, "\tR%d = I(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r1);
		}
		fprintf(yyout, "\tR%d = R%d %s R%d;\n", r0, r0,op, r1);
	}else{
		if(r0 == 77){
			r0 = assignRegisters(1);
			if (r0 == -1){
				r0 = checkOverflow(yyout, r0, TYPE_FLOAT);
			}
			((ExtraInfo*)(leftSide->info))->nRegister = r0;
			extraInfoPerDoubleRegister[r0] = ((ExtraInfo*)(leftSide->info));
			fprintf(yyout, "\tRR%d = F(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r0);
		}
		if(r1 == 77){
			r1 = assignRegisters(1);
			if (r1 == -1){
				r1 = checkOverflow(yyout, r1, TYPE_FLOAT);
			}
			((ExtraInfo*)(leftSide->info))->nRegister = r1;
			extraInfoPerDoubleRegister[r1] = ((ExtraInfo*)(rightSide->info));
			fprintf(yyout, "\tRR%d = F(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r1);
		}
		fprintf(yyout, "\tRR%d = RR%d %s RR%d;\n", r0, r0,op, r1);
	}
	
	freeRegister( r1, isFloat_ );
	freeSymbol(rightSide);
}
コード例 #24
0
bool FunctionsFactory::isXFunction(string source){
	string temp = source.substr(0, source.length()-1 );
	if(source[source.length()-1] == 'x'){
		if(source.length() > 1){
			if(isFloat(temp)){
				return true;
			}
		}else{
			return true;
		}
	}
	return false;
}
コード例 #25
0
ファイル: codeGenUtils.c プロジェクト: moisesjbc/pl_practicas
// Generate the code for a parameter pass. Arguments:
// - iRegister - index of register with the argument's value.
// - method - called method symbol.
// - iArgument - argument index.
void genArgumentPass( FILE* yyout, Symbol* argumentSymbol, Symbol* method, int iArgument )
{
	Symbol* argument = getMethodArgument( method, iArgument );
	int iRegister = ((ExtraInfo*)(argumentSymbol->info))->nRegister;
	int address = ((Variable*)( argument->info ) )->address;

	int isFloat_ = isFloat( argumentSymbol );
	cstr regStr = getRegStr( isFloat_ );

	// Get parameter.
	fprintf( yyout,"\t%c(R7+%d) = %s%d;\t// %iº Argument\n", pointerType( argument ), address, regStr, iRegister, iArgument+1 );
	freeRegister( iRegister, isFloat_ );
	freeSymbol(argumentSymbol);
}
コード例 #26
0
void AddStock::validate()
{
    // Check of syntax of quantities
    QRegExp regex("^-?[0-9]+$");
    QString tmpString;
    for(unsigned i =0 ; i < numberOfLines ; i++)
    {
        tmpString = lines[i]->quantity.text();
        if(!tmpString.contains(regex))
        {
            error->showMessage("La quantité rentrée à la ligne " + QString::number(i+1) + " ("+lines[i]->product.currentText() +") n'est pas valide. Ce doit être un entier relatif.");
            return;
        }
    }

    // Generating the queue to send to controller
    view_productQueue queue;
    view_productTuple tuple;
    for (unsigned i =0 ; i <numberOfLines ; i++)
    {
        tuple.setProductCategory(lines[i]->consoType.currentIndex() + 1); // 0 is reserved for +/-
        tuple.setProductId(lines[i]->productID[lines[i]->product.currentIndex()]);
        tuple.setProductName(lines[i]->product.currentText());
        tuple.setProductStock(lines[i]->quantity.text().toInt());
        queue.push(tuple);
        delete[] lines[i]->productID;
    }
    if(!isFloat(tvaTotal->text()) || !isFloat(ttcTotal->text()))
        return;
    float tva = tvaTotal->text().toFloat();
    float ttc = ttcTotal->text().toFloat();
    controller->receiveNewStocks(queue,tva, ttc, infos->text());
    this->reset();
    this->hide();

}
コード例 #27
0
ファイル: LogicAnalyzerDisplay.cpp プロジェクト: m0x72/pothos
void LogicAnalyzerDisplay::updateData(const int channel, const Pothos::Packet &packet)
{
    //column count changed? new labels
    const size_t numElems = packet.payload.elements();
    const bool changed = _tableView->columnCount() != int(numElems);
    _tableView->setColumnCount(numElems);
    if (changed) this->updateHeaders();

    const auto dtype = packet.payload.dtype;
    if (dtype.isComplex()) this->populateChannel<std::complex<qreal>>(channel, packet);
    else if (dtype.isFloat()) this->populateChannel<qreal>(channel, packet);
    else if (dtype.isInteger()) this->populateChannel<qlonglong>(channel, packet);

    if (changed) _tableView->resizeColumnsToContents();
}
コード例 #28
0
ファイル: Uniform.cpp プロジェクト: 4og/avango
/* virtual */ void
av::osg::Uniform::getValuesCB(const av::MFFloat::GetValueEvent& event)
{
  av::MFFloat::ContainerType& container(*event.getValuePtr());
  container.clear();
  unsigned int size = mOsgUniform->getTypeNumComponents(mOsgUniform->getType());
  if (isFloat(mOsgUniform->getType())) {
    ::osg::FloatArray* fa = mOsgUniform->getFloatArray();
    for (unsigned int i = 0; i < size; ++i) {
      container.push_back((*fa)[i]);
    }
  } else {
    ::osg::IntArray* ia = mOsgUniform->getIntArray();
    for (unsigned int i = 0; i < size; ++i) {
      container.push_back((float)(*ia)[i]);
    }
  }
}
コード例 #29
0
bool Token::appendStr(char c){
	if(is_partial){
		if(c == '@') return false;//It's a function
		if(token_type == ID_NUMBER){
			//Does adding the char to this make it a number? If so, add the char to the token string and return true
			if(isFloat(token_string + c)){
				token_string += c;
				return true;
			}
			else{
				return false;
			}
		}
		token_string += c;
		setType();
	}
	return false;
}
コード例 #30
0
ファイル: PdTypes.cpp プロジェクト: Apolotary/libpd
std::string List::toString() const {

	std::string line;
	std::stringstream itoa;

	for(int i = 0; i < objects.size(); ++i) {
		if(isFloat(i)) {
			itoa << getFloat(i);
			line += itoa.str();
			itoa.str("");
		}
		else
			line += getSymbol(i);
		line += " ";
	}

	return line;
}