Value* Builder::createNot(Value* value) {
if (value->isConstant()) {
Value* dest = cloneValue(value);
dest->doNot();
return dest;
}
Instruction* i = appendInstr(OPCODE_NOT, 0, allocValue(value->type));
i->src1.setValue(value);
return i->dest;
}
Value* Builder::createTrunc(Value* value, Type type) {
if (value->type == type) {
return value;
} else if (value->isConstant()) {
Value* dest = cloneValue(value);
dest->doTrunc(type);
return dest;
}
Instruction* i = appendInstr(OPCODE_TRUNC, 0, allocValue(type));
i->src1.setValue(value);
return i->dest;
}
Value* Builder::createNeg(Value* value) {
ASSERT_TYPE_INTEGER(value);
if (value->isConstant()) {
Value* dest = cloneValue(value);
dest->doNeg();
return dest;
}
Instruction* i = appendInstr(OPCODE_NEG, 0, allocValue(value->type));
i->src1.setValue(value);
return i->dest;
}
Value* Builder::createFNeg(Value* value) {
ASSERT_TYPE_FLOAT(value);
if (value->isConstant()) {
Value* dest = cloneValue(value);
assert_always("Unimplemented");
//dest->doFNeg();
return dest;
}
Instruction* i = appendInstr(OPCODE_FNEG, 0, allocValue(value->type));
i->src1.setValue(value);
return i->dest;
}
// Comparison operations
Value* Builder::createCmp(Value* lhs, Value* rhs, CompareFlags flags) {
ASSERT_TYPE_EQUAL(lhs, rhs);
if (lhs->isConstant() && rhs->isConstant()) {
Value* dest = cloneValue(lhs);
dest->doCompare(rhs, flags);
return dest;
}
Instruction* i = appendInstr(OPCODE_CMP, flags, allocValue(TYPE_I8));
i->src1.setValue(lhs);
i->src2.setValue(rhs);
return i->dest;
}
Value* Builder::createConvert(Value* value, Type type) {
if (value->type == type) {
return value;
}
if (value->isConstant()) {
Value* dest = cloneValue(value);
dest->doConvert(type);
return dest;
}
Instruction* i = appendInstr(OPCODE_CONVERT, 0, allocValue(type));
i->src1.setValue(value);
return i->dest;
}
Value* Builder::createDiv(Value* lhs, Value* rhs, ArithmeticFlags flags) {
ASSERT_TYPE_INTEGER(lhs);
ASSERT_TYPE_EQUAL(lhs, rhs);
if (lhs->isConstant() && rhs->isConstant()) {
Value* dest = cloneValue(lhs);
dest->doDiv(rhs, flags);
return dest;
}
Instruction* i = appendInstr(OPCODE_DIV, flags, allocValue(lhs->type));
i->src1.setValue(lhs);
i->src2.setValue(rhs);
return i->dest;
}
/******************************************************************************************
*
* Description :
* Memovery Value에 값을 복제하여 삽입한다.
*
* void *aValue, - [IN] 삽입하려고하는 값의 포인터 (타입별 Raw Format)
*******************************************************************************************/
IDE_RC idpBase::insertMemoryRawValue(void *aValue) /* called by build() */
{
void *sValue = NULL;
// Multiple Flag Check
IDE_TEST_RAISE( ((mAttr & IDP_ATTR_ML_MASK) == IDP_ATTR_ML_JUSTONE) &&
mMemVal.mCount == 1, only_one_error);
// Store Count Check
IDE_TEST_RAISE(mMemVal.mCount >= IDP_MAX_VALUE_COUNT,
no_more_insert);
cloneValue(this, aValue, &sValue);
/* Value Range Validation */
IDE_TEST(checkRange(sValue) != IDE_SUCCESS);
mMemVal.mVal[mMemVal.mCount++] = sValue;
return IDE_SUCCESS;
IDE_EXCEPTION(only_one_error);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insert() Error : "
"Property [%s] Can't Store Multiple Values.",
getName());
}
IDE_EXCEPTION(no_more_insert);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insert() Error : "
"Property [%s] Can't Store more than %"ID_UINT32_FMT
" Values.",
getName(),
(UInt)IDP_MAX_VALUE_COUNT);
}
IDE_EXCEPTION_END;
if (sValue != NULL)
{
iduMemMgr::freeRaw(sValue);
}
return IDE_FAILURE;
}
Value* Builder::createFDiv(Value* lhs, Value* rhs) {
ASSERT_TYPE_FLOAT(lhs);
ASSERT_TYPE_EQUAL(lhs, rhs);
if (lhs->isConstant() && rhs->isConstant()) {
Value* dest = cloneValue(lhs);
assert_always("Unimplemented");
//dest->doDiv(rhs);
return dest;
}
Instruction* i = appendInstr(OPCODE_FDIV, 0, allocValue(lhs->type));
i->src1.setValue(lhs);
i->src2.setValue(rhs);
return i->dest;
}
Value* Builder::createSub(Value* lhs, Value* rhs) {
ASSERT_TYPE_INTEGER(lhs);
ASSERT_TYPE_EQUAL(lhs, rhs);
if (rhs->isConstantZero()) {
return lhs;
} else if (lhs->isConstant() && rhs->isConstant()) {
Value* dest = cloneValue(lhs);
dest->doSub(rhs);
return dest;
}
Instruction* i = appendInstr(OPCODE_SUB, 0, allocValue(lhs->type));
i->src1.setValue(lhs);
i->src2.setValue(rhs);
return i->dest;
}
Value* Builder::createXor(Value* lhs, Value* rhs) {
ASSERT_TYPE_EQUAL(lhs, rhs);
if (lhs == rhs) {
// TODO
} else if (lhs->isConstantZero()) {
return lhs;
} else if (rhs->isConstantZero()) {
return rhs;
} else if (lhs->isConstant() && rhs->isConstant()) {
Value* dest = cloneValue(lhs);
dest->doXor(rhs);
return dest;
}
Instruction* i = appendInstr(OPCODE_XOR, 0, allocValue(lhs->type));
i->src1.setValue(lhs);
i->src2.setValue(rhs);
return i->dest;
}
Value* Builder::createShrA(Value* value, Value* amount) {
ASSERT_TYPE_INTEGER(value);
ASSERT_TYPE_INTEGER(amount);
if (amount->isConstantZero()) {
return value;
}
if (value->isConstant() && amount->isConstant()) {
Value* dest = cloneValue(value);
dest->doShrA(amount);
return dest;
}
if (amount->type != TYPE_I8) {
amount = createTrunc(amount, TYPE_I8);
}
Instruction* i = appendInstr(OPCODE_SHRA, 0, allocValue(value->type));
i->src1.setValue(value);
i->src2.setValue(amount);
return i->dest;
}
/******************************************************************************************
*
* Description :
* aSrc로 들어온 value source 위치에 Raw 형태의 aValue
* 값을 복제하여 삽입한다.
*
* SChar *aValue, - [IN] 삽입하려고하는 값의 포인터 (타입별 Raw Format)
* idpValueSource aSrc - [IN] 값을 삽입할 Source 위치
* (default/env/pfile/spfile by asterisk, spfile by sid)
*******************************************************************************************/
IDE_RC idpBase::insertRawBySrc(void *aValue, idpValueSource aSrc)
{
void *sValue = NULL;
UInt sValueIdx;
// Multiple Flag Check
IDE_TEST_RAISE(((mAttr & IDP_ATTR_ML_MASK) == IDP_ATTR_ML_JUSTONE) &&
mSrcValArr[aSrc].mCount == 1, only_one_error);
// Store Count Check
IDE_TEST_RAISE(mSrcValArr[aSrc].mCount >= IDP_MAX_VALUE_COUNT,
no_more_insert);
switch(aSrc)
{
case IDP_VALUE_FROM_PFILE:
IDE_TEST_RAISE((mAttr & IDP_ATTR_SL_PFILE) != IDP_ATTR_SL_PFILE,
err_cannot_set_from_pfile);
break;
case IDP_VALUE_FROM_SPFILE_BY_ASTERISK:
IDE_TEST_RAISE((mAttr & IDP_ATTR_SL_SPFILE) != IDP_ATTR_SL_SPFILE,
err_cannot_set_from_spfile);
break;
case IDP_VALUE_FROM_SPFILE_BY_SID:
IDE_TEST_RAISE((mAttr & IDP_ATTR_SL_SPFILE) != IDP_ATTR_SL_SPFILE,
err_cannot_set_from_spfile);
break;
case IDP_VALUE_FROM_ENV:
IDE_TEST_RAISE((mAttr & IDP_ATTR_SL_ENV) != IDP_ATTR_SL_ENV,
err_cannot_set_from_env);
break;
default:
//IDP_VALUE_FROM_DEFAULT NO CHECK
break;
}
cloneValue(this, aValue, &sValue);
/* Value Range Validation */
IDE_TEST(checkRange(aValue) != IDE_SUCCESS);
sValueIdx = mSrcValArr[aSrc].mCount++;
mSrcValArr[aSrc].mVal[sValueIdx] = aValue;
return IDE_SUCCESS;
IDE_EXCEPTION(only_one_error);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insert() Error : "
"Property [%s] Can't Store Multiple Values.",
getName());
}
IDE_EXCEPTION(no_more_insert);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insert() Error : "
"Property [%s] Can't Store more than %"ID_UINT32_FMT" Values.",
getName(),
(UInt)IDP_MAX_VALUE_COUNT);
}
IDE_EXCEPTION(err_cannot_set_from_pfile);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insertBySrc() Error : "
"Property [%s] Can't set from PFILE.",
getName());
}
IDE_EXCEPTION(err_cannot_set_from_spfile);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insertBySrc() Error : "
"Property [%s] Can't set from SPFILE.",
getName());
}
IDE_EXCEPTION(err_cannot_set_from_env);
{
idlOS::snprintf(mErrorBuf,
IDP_ERROR_BUF_SIZE,
"idp insertBySrc() Error : "
"Property [%s] Can't set from ENV.",
getName());
}
IDE_EXCEPTION_END;
if (sValue != NULL)
{
iduMemMgr::freeRaw(sValue);
}
return IDE_FAILURE;
}
