int csllbc_LibConfig_Log_DefaultFileLogPattern(sint64 pattern, int patternLen)
{
const int writable = MIN(LLBC_StrLenA(LLBC_CFG_LOG_DEFAULT_FILE_LOG_PATTERN), patternLen);
LLBC_MemCpy(reinterpret_cast<char *>(pattern), LLBC_CFG_LOG_DEFAULT_FILE_LOG_PATTERN, writable);
return writable;
}
int csllbc_LibConfig_Log_DefaultLogFileName(sint64 name, int nameLen)
{
const int writable = MIN(LLBC_StrLenA(LLBC_CFG_LOG_DEFAULT_LOG_FILE_NAME), nameLen);
LLBC_MemCpy(reinterpret_cast<char *>(name), LLBC_CFG_LOG_DEFAULT_LOG_FILE_NAME, writable);
return writable;
}
int csllbc_LibConfig_Comm_PollerModel(sint64 model, int modelLen)
{
const int writable = MIN(LLBC_StrLenA(LLBC_CFG_COMM_POLLER_MODEL), modelLen);
LLBC_MemCpy(reinterpret_cast<char *>(model), LLBC_CFG_COMM_POLLER_MODEL, writable);
return writable;
}
LLBC_String LLBC_TrimRight(const LLBC_String &str, const char *targets)
{
if (UNLIKELY(!targets))
{
return str;
}
LLBC_String retStr = str;
const uint32 len = LLBC_StrLenA(targets);
for (register uint32 i = 0; i < len; i ++)
{
retStr = LLBC_TrimRight(retStr, targets[i]);
}
return retStr;
}
int LLBC_HashString(const char *str, size_t strLen)
{
if (UNLIKELY(str == NULL || strLen == 0))
return 0;
if (strLen == static_cast<size_t>(-1))
strLen = LLBC_StrLenA(str);
int hashVal = 0;
for (size_t i = 0; i < strLen; i++)
hashVal += i * 0x31 * str[i];
hashVal += static_cast<int>(strLen) * str[0];
hashVal *= str[strLen - 1];
return hashVal;
}
int LLBC_LogTokenChain::Build(const LLBC_String &pattern)
{
if (_head)
{
LLBC_SetLastError(LLBC_ERROR_REENTRY);
return LLBC_RTN_FAILED;
}
char ch = '\0';
const char *curPattern = NULL;
LLBC_String::size_type patternLength = 0;
int state = LLBC_INTERNAL_NS __g_literal_state;
LLBC_ILogToken *token = NULL;
LLBC_LogFormattingInfo *formatter = NULL;
LLBC_String buf;
if (pattern.empty())
{
curPattern = LLBC_INTERNAL_NS __g_default_pattern;
patternLength = LLBC_StrLenA(LLBC_INTERNAL_NS __g_default_pattern);
}
else
{
curPattern = pattern.data();
patternLength = pattern.size();
}
for (size_t i = 0; i < patternLength;)
{
ch = curPattern[i ++];
switch(state)
{
case LLBC_INTERNAL_NS __g_literal_state:
if (i == patternLength)
{
buf.append(1, ch);
break;
}
if (ch == LLBC_LogTokenType::EscapeToken)
{
if (curPattern[i] == LLBC_LogTokenType::EscapeToken)
{
buf.append(1, ch);
i ++;
}
else
{
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(formatter, buf);
this->AppendToken(token);
buf.clear();
formatter = NULL;
}
buf.append(1, ch);
LLBC_XDelete(formatter);
state = LLBC_INTERNAL_NS __g_converter_state;
}
}
else
{
buf.append(1, ch);
}
break;
case LLBC_INTERNAL_NS __g_converter_state:
buf.append(1, ch);
if ((ch >= 0x30 && ch <= 0x39) || ch == '-')
{
state = LLBC_INTERNAL_NS __g_number_state;
break;
}
buf.erase(buf.rfind(LLBC_LogTokenType::EscapeToken));
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(ch);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo;
}
token->Initialize(formatter, "");
this->AppendToken(token);
formatter = NULL;
state = LLBC_INTERNAL_NS __g_literal_state;
break;
case LLBC_INTERNAL_NS __g_number_state:
if ((ch < 0x30 || ch > 0x39) && ch != '-')
{
int minLength = LLBC_Str2Int32(&buf[buf.rfind(LLBC_LogTokenType::EscapeToken) + 1]);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo(minLength < 0 ? true : false, ::abs(minLength), INT_MAX);
}
else
{
formatter->SetLeftAligh(minLength < 0 ? true : false);
formatter->SetMinLen(minLength);
formatter->SetMaxLen(INT_MAX);
}
i --;
state = LLBC_INTERNAL_NS __g_converter_state;
break;
}
buf.append(1, ch);
break;
default:
LLBC_XDelete(formatter);
this->Cleanup();
LLBC_SetLastError(LLBC_ERROR_FORMAT);
return LLBC_RTN_FAILED;
break;
}
}
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(NULL, buf);
this->AppendToken(token);
}
return LLBC_RTN_OK;
}
