void ExProcessIdsOfFrag::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
ex_assert(objType == ESP_PROCESS_IDS_OF_FRAG AND
objVersion == CurrProcessIdsOfFragVersion AND
sameEndianness AND
objSize >= baseClassPackedLength() +
sizeof(fragmentId_) + sizeof(CollIndex),
"Received invalid ProcessIdsOfFrag object");
unpackBaseClass(buffer);
// unpack fragment id and number of entries
Int32 np;
buffer += sizeof(spare_);
str_cpy_all((char *) &fragmentId_, buffer, sizeof(fragmentId_));
buffer += sizeof(fragmentId_);
str_cpy_all((char *) &np, buffer, sizeof(np));
buffer += sizeof(np);
// unpack the process ids
for (CollIndex i = 0; i < (CollIndex) np; i++)
{
alignBufferForNextObj(buffer);
processIds_.insert(IpcProcessId());
processIds_[i].unpackDependentObjFromBuffer(buffer,sameEndianness);
}
}
// copy_chars(): create a copy of given chars on the specified heap.
// The C runtime heap is used if heap is NULL. Target string is null
// terminated if terminate is TRUE. A pointer to the copy is returned.
char *copy_chars(NAMemory *heap, const char *src, ComUInt32 len,
NABoolean terminate)
{
if (!src)
return NULL;
if (terminate)
len++;
char *tgt;
if (heap)
tgt = new (heap) char [len];
else
tgt = (char *) malloc(len);
LMCOMMON_ASSERT(tgt);
if (terminate)
{
str_cpy_all(tgt, src, (Lng32)len-1);
tgt[len-1] = '\0';
}
else
str_cpy_all(tgt, src, (Lng32)len);
return tgt;
}
IpcMessageObjSize ExProcessIdsOfFrag::packObjIntoMessage(
IpcMessageBufferPtr buffer)
{
IpcMessageObjSize result = packBaseClassIntoMessage(buffer);
Int32 np = processIds_.entries();
// pack fragment id and number of entries
str_cpy_all(buffer, (const char *) &spare_, sizeof(spare_));
result += sizeof(spare_);
buffer += sizeof(spare_);
str_cpy_all(buffer, (const char *) &fragmentId_, sizeof(fragmentId_));
result += sizeof(fragmentId_);
buffer += sizeof(fragmentId_);
str_cpy_all(buffer, (const char *) &np, sizeof(np));
result += sizeof(np);
buffer += sizeof(np);
// pack each process id, as an IpcMessageObj
for (CollIndex i = 0; i < (CollIndex) np; i++)
{
alignSizeForNextObj(result);
alignBufferForNextObj(buffer);
IpcMessageObjSize pidsize =
processIds_[i].packDependentObjIntoMessage(buffer);
result += pidsize;
buffer += pidsize;
}
return result;
}
void CmpCompileInfo::packVars(char * buffer, CmpCompileInfo *ci,
Lng32 &nextOffset)
{
if (sqltext_ && (sqlTextLen_ > 0))
{
str_cpy_all(&buffer[nextOffset], sqltext_, sqlTextLen_);
ci->sqltext_ = (char *)nextOffset;
nextOffset += ROUND8(sqlTextLen_);
}
if (rlnil_ && (rlnilLen_ > 0))
{
str_cpy_all(&buffer[nextOffset], (char *)rlnil_, rlnilLen_);
ci->rlnil_ = (RecompLateNameInfoList *)nextOffset;
nextOffset += ROUND8(rlnilLen_);
}
if (schemaName_ && (schemaNameLen_ > 0))
{
str_cpy_all(&buffer[nextOffset], (char *)schemaName_, schemaNameLen_);
ci->schemaName_ = (char *)nextOffset;
nextOffset += ROUND8(schemaNameLen_);
}
if (recompControlInfo_ && (recompControlInfoLen_ > 0))
{
str_cpy_all(&buffer[nextOffset], (char *)recompControlInfo_, recompControlInfoLen_);
ci->recompControlInfo_ = (char *)nextOffset;
nextOffset += ROUND8(recompControlInfoLen_);
}
}
void MdamColumn::completeKey(char *bktarget,
char *ektarget,
short bkexcl,
short ekexcl)
{
Int32 len = Int32(columnGenInfo_->getLength());
char *extremalValue;
bktarget = bktarget + columnGenInfo_->getOffset();
ektarget = ektarget + columnGenInfo_->getOffset();
if (bkexcl)
// use hi value if begin key is excluded
extremalValue = hi_.getDataPointer();
else
// use lo value if begin key is included
extremalValue = lo_.getDataPointer();
str_cpy_all(bktarget,extremalValue,len);
if (ekexcl)
// use lo value if end key is excluded
extremalValue = lo_.getDataPointer();
else
// use hi value if end key is included
extremalValue = hi_.getDataPointer();
str_cpy_all(ektarget,extremalValue,len);
};
short ex_tcb::moveRowToUpQueue(ex_queue_pair *qparent,
UInt16 tuppIndex,
const char * row, Lng32 len,
short * rc, NABoolean isVarchar)
{
if (qparent->up->isFull())
{
if (rc)
*rc = WORK_CALL_AGAIN;
return -1;
}
Lng32 length;
if (len <= 0)
length = strlen(row);
else
length = len;
tupp p;
if (pool_->get_free_tuple(p, (Lng32)
((isVarchar ? SQL_VARCHAR_HDR_SIZE : 0)
+ length)))
{
if (rc)
*rc = WORK_POOL_BLOCKED;
return -1;
}
char * dp = p.getDataPointer();
if (isVarchar)
{
*(short*)dp = (short)length;
str_cpy_all(&dp[SQL_VARCHAR_HDR_SIZE], row, length);
}
else
{
str_cpy_all(dp, row, length);
}
ex_queue_entry * pentry_down = qparent->down->getHeadEntry();
ex_queue_entry * up_entry = qparent->up->getTailEntry();
up_entry->copyAtp(pentry_down);
up_entry->getAtp()->getTupp((Lng32)tuppIndex) = p;
up_entry->upState.parentIndex =
pentry_down->downState.parentIndex;
up_entry->upState.setMatchNo(0);
up_entry->upState.status = ex_queue::Q_OK_MMORE;
// insert into parent
qparent->up->insert();
return 0;
}
IpcMessageObjSize ExMsgFragment::packObjIntoMessage(IpcMessageBufferPtr buffer)
{
// See description of packed format in packedLength() method
IpcMessageBufferPtr start = buffer;
// Pack the base class
packBaseClassIntoMessage(buffer);
alignBufferForNextObj(buffer);
// Pack the fixed length fields
str_cpy_all(buffer, (const char *) &f_, sizeof(f_));
buffer += sizeof(f_);
alignBufferForNextObj(buffer);
// Pack the query ID
if (f_.queryId_ != NULL)
{
str_cpy_all(buffer, f_.queryId_, f_.queryIdLen_);
buffer += f_.queryIdLen_;
alignBufferForNextObj(buffer);
}
// Pack the user name
if (f_.userName_ != NULL)
{
str_cpy_all(buffer, f_.userName_, f_.userNameLen_);
buffer += f_.userNameLen_;
alignBufferForNextObj(buffer);
}
// Pack the fragment itself
if (f_.compressedLength_ > 0 && f_.compressedLength_ < f_.fragmentLength_)
{
size_t cmprSize = str_compress(buffer,fragment_,f_.fragmentLength_);
ex_assert(cmprSize == f_.compressedLength_,
"Error during compress a fragment for download");
buffer += f_.compressedLength_;
}
else
{
#pragma nowarn(1506) // warning elimination
str_cpy_all(buffer,fragment_,f_.fragmentLength_);
#pragma warn(1506) // warning elimination
buffer += f_.fragmentLength_;
}
alignBufferForNextObj(buffer);
// Pack the fragment key (is an IpcMessageObj itself)
buffer += key_.packDependentObjIntoMessage(buffer);
return (IpcMessageObjSize) (buffer - start);
}
void SQLMXLoggingArea::logCompNQCretryEvent(char *stmt)
{
const char m[]="Statement was compiled as if query plan caching were off: ";
Int32 mLen = sizeof(m);
Int32 sLen = str_len(stmt);
char msg[8192];
str_cpy_all(msg, m, mLen);
str_cpy_all(msg+mLen, stmt, MINOF(sLen, 8192-mLen));
logSQLMXEventForError(SQEV_CMP_NQC_RETRY_OCCURED, "ADVANCED", "INFRM",
"LOGONLY", msg);
}
/////////////////////////////////////////////////
// class ex_aggr_min_max_clause
/////////////////////////////////////////////////
ex_expr::exp_return_type ex_aggr_min_max_clause::eval(char * op_data[],
CollHeap*,
ComDiagsArea **)
{
ex_expr::exp_return_type retcode = ex_expr::EXPR_OK;
// if the second expression is true, make child to be current
// aggregate.
if (*(Lng32 *)op_data[2] == 1)
{
if (getOperand(0)->getNullFlag())
{
// A pointer to the null indicators of the operands.
//
char **null_data = &op_data[-2 * ex_clause::MAX_OPERANDS];
if ((getOperand(1)->getNullFlag()) &&
(! null_data[1])) // missing value, indicates
// child is null. Keep the current result.
return ex_expr::EXPR_OK;
ExpTupleDesc::clearNullValue(null_data[0],
getOperand(0)->getNullBitIndex(),
getOperand(0)->getTupleFormat() );
}
if (getOperand(0)->getVCIndicatorLength() > 0)
{
// variable length operand. Note that first child (operand1)
// and result have the SAME attributes for min/max aggr.
#pragma nowarn(1506) // warning elimination
Lng32 src_length = getOperand(1)->getLength(op_data[-MAX_OPERANDS + 1]);
#pragma warn(1506) // warning elimination
Lng32 tgt_length = getOperand(0)->getLength(); // max varchar length
str_cpy_all(op_data[0], op_data[1], src_length);
// copy source length bytes to target length bytes.
// Note that the array index -MAX_OPERANDS will get to
// the corresponding varlen entry for that operand.
getOperand(0)->setVarLength(src_length, op_data[- MAX_OPERANDS]);
}
else
{
str_cpy_all(op_data[0], op_data[1], getOperand(0)->getLength());
}
}
return retcode;
}
IpcMessageObjSize ExMsgResourceInfo::packObjIntoMessage(
IpcMessageBufferPtr buffer)
{
IpcMessageBufferPtr start = buffer;
packBaseClassIntoMessage(buffer);
str_cpy_all(buffer,(char *) &totalNameLength_, sizeof(totalNameLength_));
buffer += sizeof(totalNameLength_);
str_cpy_all(buffer,(char *) &spare_, sizeof(spare_));
buffer += sizeof(spare_);
buffer += sfo_->ipcPackObjIntoMessage(buffer);
return (IpcMessageObjSize) (buffer - start);
}
ex_expr::exp_return_type ex_function_substring_doublebyte::eval(char *op_data[],
CollHeap* heap,
ComDiagsArea** diagsArea)
{
#pragma nowarn(1506) // warning elimination
Lng32 len1 = getOperand(1)->getLength(op_data[-MAX_OPERANDS+1]);
#pragma warn(1506) // warning elimination
len1 /= sizeof(NAWchar); // len1 now counts in terms of number of NCHARs.
// Get the starting position from operand 2.
Int64 start = *(Lng32 *)op_data[2];
// If operand 3 exists, get the length of substring from operand 3.
// Otherwise, length of the substring is (len1 - start + 1).
Int64 len = 0;
Int64 temp = 0;
if (getNumOperands() == 4)
{
len = *(Lng32 *)op_data[3];
temp = start + len;
}
else
{
if (start > (len1 + 1))
temp = start;
else
temp = len1 + 1;
}
// Check for error conditions.
if (temp < start)
{
ExRaiseSqlError(heap, diagsArea, EXE_SUBSTRING_ERROR);
return ex_expr::EXPR_ERROR;
}
Lng32 len0 = 0;
if ((start <= len1) && (temp > 0))
{
if (start < 1)
start = 1;
if (temp > (len1 + 1))
temp = len1 + 1;
len0 = int64ToInt32(temp - start);
}
len0 *= sizeof(NAWchar); // convert the length back into the number of octets.
// Result is always a varchar, so store the length of substring
// in the varlen indicator.
getOperand(0)->setVarLength(len0, op_data[-MAX_OPERANDS]);
// Now, copy the substring of operand 1 from the starting position into
// operand 0, if len0 is greater than 0.
if (len0 > 0)
str_cpy_all(op_data[0], &op_data[1][sizeof(NAWchar)*(int64ToInt32(start) - 1)], len0);
return ex_expr::EXPR_OK;
}
// Generates LOB handle that is stored in the SQL row.
// LOB handle len: 64 bytes
// <flags><LOBnum><objectUid><descKey><descTS><schNameLen><schName>
// <--4--><--4---><----8----><---8---><--8---><-----2----><--vc--->
void ExpLOBoper::genLOBhandle(Int64 uid,
Lng32 lobNum,
short lobType,
Int64 descKey,
Int64 descTS,
Lng32 flags,
short schNameLen,
char * schName,
Lng32 &handleLen,
char * ptr)
{
LOBHandle * lobHandle = (LOBHandle*)ptr;
lobHandle->flags_ = flags;
lobHandle->lobType_ = (char)lobType;
lobHandle->filler1_ = 0;
lobHandle->lobNum_ = lobNum;
lobHandle->objUID_ = uid;
lobHandle->descSyskey_ = descKey;
lobHandle->descPartnkey_ = descTS;
str_pad(lobHandle->filler_, 30, '\0');
lobHandle->schNameLen_ = schNameLen;
handleLen = sizeof(LOBHandle);
if (schNameLen > 0)
{
char * s = &lobHandle->schName_;
str_cpy_all(s, schName, schNameLen);
s[schNameLen] = 0;
handleLen += schNameLen;
}
// lobHandle->inlinedLOBlen_ = 0;
}
// Extracts values from the LOB handle stored at ptr
Lng32 ExpLOBoper::extractFromLOBhandle(Int16 *flags,
Lng32 *lobType,
Lng32 *lobNum,
Int64 *uid,
Int64 *descSyskey,
Int64 *descPartnKey,
short *schNameLen,
char * schName,
char * ptrToLobHandle,
Lng32 handleLen)
{
LOBHandle * lobHandle = (LOBHandle*)ptrToLobHandle;
if (flags)
*flags = lobHandle->flags_;
if (lobType)
*lobType = lobHandle->lobType_;
if (lobNum)
*lobNum = lobHandle->lobNum_;
if (uid)
*uid = lobHandle->objUID_;
if (descSyskey)
*descSyskey = lobHandle->descSyskey_;
if (descPartnKey)
*descPartnKey = lobHandle->descPartnkey_;
if (schNameLen)
*schNameLen = lobHandle->schNameLen_;
if ((schNameLen) && (*schNameLen > 0) && (schName != NULL))
{
str_cpy_all(schName, &lobHandle->schName_, *schNameLen);
schName[*schNameLen] = 0;
}
return 0;
}
/////////////////////////////////////////
// class Define
/////////////////////////////////////////
Define::Define(const char * name_, const char * value_)
{
if (name_)
{
name = new char[strlen(name_) + 1];
strcpy(name, name_);
defineNameInternal = new char[24];
str_pad(defineNameInternal, 24, ' ');
#pragma nowarn(1506) // warning elimination
short len = MINOF(strlen(name), 24);
#pragma warn(1506) // warning elimination
str_cpy_all(defineNameInternal, name, len);
}
else
name = 0;
if (value_)
{
value = new char[strlen(value_) + 1];
strcpy(value, value_);
}
else
value = 0;
}
ex_tcb::~ex_tcb()
{
ex_assert(!str_cmp((char *)&eyeCatcher_, (char *)(&tdb.eyeCatcher_), 4),
"TCB points to wrong TDB");
// Change the eye catcher
str_cpy_all((char *) &eyeCatcher_, eye_FREE, 4);
};
void ExMsgResourceInfo::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
ExScratchFileOptions *sfo;
IpcConstMessageBufferPtr start = buffer;
ex_assert(objType == ESP_RESOURCE_INFO AND
objVersion == 100 AND
sameEndianness AND
objSize > sizeof(IpcMessageObj),
"invalid type or version for ExMsgResourceInfo::unpackObj()");
unpackBaseClass(buffer);
str_cpy_all((char *) &totalNameLength_,buffer,sizeof(totalNameLength_));
buffer += sizeof(totalNameLength_);
buffer += sizeof(spare_);
if (bufferForDependentObjects_)
{
getHeap()->deallocateMemory(bufferForDependentObjects_);
bufferForDependentObjects_ = NULL;
}
sfo = new(getHeap()) ExScratchFileOptions;
// sfo_ is const
sfo_ = sfo;
sfo->ipcUnpackObj(objSize - (buffer-start),
buffer,
getHeap(),
totalNameLength_,
bufferForDependentObjects_);
}
void TupMsgBuffer::unpackObj(IpcMessageObjType objType,
IpcMessageObjVersion objVersion,
NABoolean sameEndianness,
IpcMessageObjSize objSize,
IpcConstMessageBufferPtr buffer)
{
ex_assert((objType == ESP_INPUT_SQL_BUFFER OR
objType == ESP_OUTPUT_SQL_BUFFER) AND
objVersion == 100 AND
sameEndianness AND
objSize > sizeof(IpcMessageObj),
"invalid type or version for TupMsgBuffer::unpackObj()");
unpackBaseClass(buffer);
IpcMessageObjSize sqlBufferSize = objSize - sizeof(IpcMessageObj);
ex_assert(allocSize_ >= (Lng32) sqlBufferSize,
"TupMsgBuffer too small for unpack");
#pragma nowarn(1506) // warning elimination
str_cpy_all((char *) theBuffer_, buffer, sqlBufferSize);
#pragma warn(1506) // warning elimination
// convert offsets in buffer to pointers
theBuffer_->driveUnpack();
// just checking whether we really got the right size info
ex_assert(sqlBufferSize == theBuffer_->get_buffer_size(),
"Buffer size mismatch");
}
void InputStmt::processInsert()
{
size_t command_len = getCommandLen();
if ((command_len > 0) && (text_maxlen > 0))
{
size_t j = text_maxlen - 1;
while (j >= text_pos)
{
text[j+command_len] = text[j];
if (j-- == 0) break;
}
#pragma nowarn(1506) // warning elimination
str_cpy_all(&text[text_pos], &command[command_pos], command_len);
#pragma warn(1506) // warning elimination
command_pos += command_len;
text_pos += 2 * command_len + 1;
text_maxlen += command_len;
if (text_pos > text_maxlen)
text_maxlen = text_pos;
}
} // processInsert()
ex_expr::exp_return_type ExpLOBselect::eval(char *op_data[],
CollHeap*h,
ComDiagsArea** diagsArea)
{
char * result = op_data[0];
Lng32 rc = 0;
Int64 uid;
Lng32 lobType;
Lng32 lobNum;
Int64 descKey;
Int16 flags;
Int64 descTS = -1;
short schNameLen = 0;
char schName[500];
LobsSubOper so;
Lng32 waitedOp = 0;
Int64 lobLen = 0;
char *lobData = NULL;
Lng32 cliError = 0;
Lng32 lobOperStatus = checkLobOperStatus();
if (lobOperStatus == DO_NOTHING_)
return ex_expr::EXPR_OK;
Int32 handleLen = getOperand(1)->getLength(op_data[-MAX_OPERANDS+1]);
char * lobHandle = op_data[1];
extractFromLOBhandle(&flags, &lobType, &lobNum, &uid,
&descKey, &descTS,
&schNameLen, schName,
lobHandle);
// select returns lobhandle only
str_pad(result, getOperand(0)->getLength());
str_cpy_all(result, lobHandle, strlen(lobHandle));
return ex_expr::EXPR_OK;
}
void MdamColumn::reportProbeResult(char *keyData)
{
ex_assert(sparseProbeNeeded_,
"MdamColumn::reportProbeResult called unexpectedly.");
sparseProbeNeeded_ = FALSE;
if (keyData)
{
// the sparse probe was successful -- save the key value
Int32 len = Int32(columnGenInfo_->getLength());
#pragma nowarn(1506) // warning elimination
Lng32 offset = columnGenInfo_->getOffset();
#pragma warn(1506) // warning elimination
char * cv = currentValue_.getDataPointer();
str_cpy_all(cv,keyData + offset,len);
sparseProbeSucceeded_ = TRUE;
}
else
{
// the sparse probe returned no data
sparseProbeFailed_ = TRUE;
}
}
ExSPInputOutput::ExSPInputOutput() : NAVersionedObject(-1)
{
str_cpy_all(eyeCatcher_, "SPIO", 4);
totalLen_ = 0;
tupleDesc_ = NULL;
caseIndexArray_ = (Int16Ptr) NULL;
flags_ = 0;
}
NA_EIDPROC ComTdb::~ComTdb()
{
// ---------------------------------------------------------------------
// Change the eye catcher
// ---------------------------------------------------------------------
str_cpy_all((char *) &eyeCatcher_, eye_FREE, 4);
}
inline static char *copyString(const NAString &s) // cf. readRealArk.cpp
{
#pragma nowarn(1506) // warning elimination
char *c = new(CmpCommon::statementHeap()) char[s.length()+1];
str_cpy_all(c, s.data(), s.length()+1);
return c;
#pragma warn(1506) // warning elimination
}
/*
DP2 Query Id Format:
Each of the part is in binary numeric format.
<segment><cpu><pin><processStartTS><queryNum>
<segment> : 1 byte
<cpu> : 1 byte
<pin> : 2 bytes(short)
<processStartTS> : 8 bytes (Int64)
<queryNum> : 4 bytes (Lng32)
*/
Lng32 ComSqlId::getDp2QueryIdString
(char * queryId, // IN
Lng32 queryIdLen, // IN
char * dp2QueryId, // INOUT
Lng32 &dp2QueryIdLen // OUT
)
{
if ((!queryId) ||
(queryIdLen < MAX_DP2_QUERY_ID_LEN))
return -1;
Int64 value;
Lng32 currOffset = 0;
// In case of Linux and NT, segment num and cpu num are same
// Copy them as short
// get cpu
getSqlQueryIdAttr(SQLQUERYID_CPUNUM, queryId, queryIdLen,
value, NULL);
*(short*)&dp2QueryId[currOffset] = (short)value;
currOffset += sizeof(short);
// get pin
getSqlQueryIdAttr(SQLQUERYID_PIN, queryId, queryIdLen,
value, NULL);
*(short*)&dp2QueryId[currOffset] = (short)value;
currOffset += sizeof(short);
// get process start time
getSqlQueryIdAttr(SQLQUERYID_EXESTARTTIME, queryId, queryIdLen,
value, NULL);
str_cpy_all(&dp2QueryId[currOffset], (char*)&value, sizeof(Int64));
currOffset += sizeof(Int64);
// get query num
getSqlQueryIdAttr(SQLQUERYID_QUERYNUM, queryId, queryIdLen,
value, NULL);
Lng32 qNum = (Lng32)value;
str_cpy_all(&dp2QueryId[currOffset], (char*)&qNum, sizeof(Lng32));
currOffset += sizeof(Lng32);
dp2QueryIdLen = currOffset;
return 0;
}
// log an ASSERTION FAILURE event
void
SQLMXLoggingArea::logSQLMXAssertionFailureEvent(const char* file, Int32 line, const char* msgTxt, const char* condition, const Lng32* tid)
{
bool lockedMutex = lockMutex();
Int32 LEN = 8192;
char msg[8192];
memset(msg, 0, LEN);
Int32 sLen = str_len(msgTxt);
Int32 sTotalLen = sLen;
str_cpy_all (msg, msgTxt, sLen);
char fileLineStr[200];
if (file)
{
str_sprintf(fileLineStr, ", FILE: %s, LINE: %d ",file, line);
sLen = str_len(fileLineStr);
str_cpy_all (msg+sTotalLen, fileLineStr, sLen);
sTotalLen += sLen;
}
if (tid && (*tid != -1))
{
char transId[100];
str_sprintf(transId, " TRANSACTION ID: %d ", *tid);
sLen = str_len(transId);
str_cpy_all (msg+sTotalLen, transId, sLen);
sTotalLen += sLen;
}
if (condition)
{
char condStr[100];
str_sprintf(condStr, " CONDITION: %s ", condition);
sLen = str_len(condStr);
str_cpy_all (msg+sTotalLen, condStr, sLen);
}
QRLogger::log(QRLogger::instance().getMyDefaultCat(), LL_FATAL, "%s", msg);
if (lockedMutex)
unlockMutex();
}
char *UDRCopyString ( const ComString &sourceString, CollHeap *heap )
{
char *string = new(heap)char [sourceString.length()+1];
str_cpy_all ( string
, sourceString.data()
, sourceString.length()+1
);
return string;
} // UDRCopyString
jint JNICALL LmJavaHooks::vfprintfHookJVM(FILE *stream, const char *fmt,
va_list printArgs)
{
if (!fmt || !stream)
{
return 0;
}
LM_DEBUG0("[BEGIN vfprintf hook]");
char tmpBuf[LMJ_HOOK_TEXT_BUF_SIZE] = "";
// 1. First make a temporary copy of the output message
ComSafePrinter safePrinter;
safePrinter.vsnPrintf(tmpBuf, LMJ_HOOK_TEXT_BUF_SIZE, fmt, printArgs);
// 2. Send the message to its intended FILE stream
// Do not know why but inside this hook, writing to the FILE pointer
// that was passed in seems to cause problems on Windows. Depending
// on how the FILE pointer is used we have seen crashes inside JVM
// code after hook returns, and inside fprintf. The JVM bug database
// says a few things about the JVM being compiled with a version of
// certain stdio structures such as va_list that may not be
// compatible with all IDEs. Have not tried to verify that
// though. For now on Windows we just write our temporary string to
// stderr. And our observation has been that all JVM messages go to
// stderr anyway, so this seems to serve the same purpose.
//
// For example the following line does not work
//
// vfprintf(stream, fmt, printArgs)
//
// And neither does this
//
// fprintf(stream, tmpBuf)
//
fprintf(stderr, tmpBuf);
// Write as much as possible into our textBuf_ area
Int32 currentLength = str_len(textBuf_);
Int32 tmpLen = str_len(tmpBuf);
if ((currentLength + 1) < LMJ_HOOK_TEXT_BUF_SIZE)
{
Int32 bytesToCopy =
MINOF(tmpLen + 1, LMJ_HOOK_TEXT_BUF_SIZE - currentLength);
str_cpy_all(&textBuf_[currentLength], tmpBuf, bytesToCopy);
textBuf_[LMJ_HOOK_TEXT_BUF_SIZE - 1] = 0;
}
else
{
LM_DEBUG0("*** WARNING: textBuf_ buffer is full");
}
LM_DEBUG0("[END vfprintf hook]");
return 0;
}
// ---------------------------------------------------------------------
// Constructor
//
// Note that imageSize_ and versionIDArray_ are only filled in at
// packing time. These values are not useful on the source platform
// where the objects are constructed. They are only useful at the
// destination while the objects are unpacked. Before the objects are
// packed, drivePack() will make sure their values are correctly set.
// This arrangement avoids the dependence on the constructors of sub-
// classes of NAVersionedObject on setting these values correctly.
// ---------------------------------------------------------------------
NA_EIDPROC NAVersionedObject::NAVersionedObject(Int16 classID)
: classID_(classID),
reallocatedAddress_(NULL),
imageSize_(0)
{
clearFillers();
initFlags(); // set to state of "not packed".
clearVersionIDArray();
str_cpy_all(eyeCatcher_,VOBJ_EYE_CATCHER,VOBJ_EYE_CATCHER_SIZE);
}
Module::Module(const char * module_name, Lng32 len, char * pathName,
Lng32 pathNameLen, NAHeap *heap)
: module_name_len_(len), path_name_len_(pathNameLen),
heap_(heap), statementCount_(0),
stmtCntrsSpace_(NULL),
vproc_(NULL)
{
module_name_ = (char *)
(heap->allocateMemory((size_t)(len+1)));
str_cpy_all(module_name_, module_name, len);
module_name_[len] = 0;
path_name_ = (char *)
(heap->allocateMemory((size_t)(pathNameLen+1)));
str_cpy_all(path_name_, pathName, pathNameLen);
path_name_[pathNameLen] = 0;
}
void CmpDDLwithStatusInfo::pack(char * buffer)
{
CmpDDLwithStatusInfo * ci = (CmpDDLwithStatusInfo *)buffer;
Lng32 classSize = getClassSize();
Lng32 nextOffset = 0;
str_cpy_all(buffer, (char *)this, classSize);
nextOffset += ROUND8(classSize);
packVars(buffer, ci, nextOffset);
if (blackBox_ && (blackBoxLen_ > 0))
{
str_cpy_all(&buffer[nextOffset], blackBox_, blackBoxLen_);
ci->blackBox_ = (char *)nextOffset;
nextOffset += ROUND8(blackBoxLen_);
}
}
