void CFilteringTable::LoadScript()
{
CMHFile file;
file.Init(
_T("system\\resource\\filterWord.bin"),
_T("rb"));
Type type = TypeNone;
while(FALSE == file.IsEOF())
{
TCHAR buffer[MAX_PATH] = {0};
file.GetLine(
buffer,
sizeof(buffer) / sizeof(*buffer));
if(0 == _tcslen(buffer))
{
continue;
}
LPCTSTR commentMark = _T("@");
if(0 == _tcsnicmp(buffer, commentMark, _tcslen(commentMark)))
{
continue;
}
else if(0 == _tcsicmp(buffer, _T("#GM")))
{
type = TypePartiallyBlockedName;
continue;
}
else if(0 == _tcsicmp(buffer, _T("#SLANG")))
{
type = TypePartiallyBlockedKeyword;
continue;
}
else if(0 == _tcsicmp(buffer, _T("#SYSTEM")))
{
type = TypeEntirelyBlockedName;
continue;
}
TCHAR text[MAX_PATH] = {0};
RemoveSpace(
buffer,
text,
sizeof(text) / sizeof(*text));
_tcsupr(
text);
KeywordContainer& keywordContainer = mFilterContainer[type];
keywordContainer.insert(
text);
}
}
bool ProcessIso2DB::Execute(char *send){
char bit[LEN_MAX_BIT];
char msgClass[4+1], procCode[6+1];
Iso8583 *iso = new Iso8583(ISO_IPIRANGA);
iso->Extract( m_read.c_str()+HEADER_LEN);
GatewayInProcessConfig* proc = GatewayInProperties::getInstance()->ProcessConfig();
memset(msgClass,0,sizeof(msgClass));
memset(procCode,0,sizeof(procCode));
strncpy(msgClass, m_read.c_str()+HEADER_LEN , 4 );
iso->Get(3,procCode );
ProcessConfig* process = proc->FindProcessConfig(msgClass , procCode );
if( process ) {
MssqlDB *db = new MssqlDB(GatewayInProperties::getInstance()->StrConnectionDB());
if( db->IsConnect() ) {
db->StoreProcedure(process->StoredProcedure().c_str());
list<BitRow*>::iterator it;
for ( it=process->LstBitRow().begin() ; it != process->LstBitRow().end(); it++ ){
memset(bit , 0 , sizeof(bit));
iso->Get(atoi((*it)->Bit().c_str()),bit );
db->InsertParameter((*it)->SqlRow().c_str() , bit, (ParameterDirectionEnum)atoi((*it)->SqlType().c_str()));
}
db->Execute();
{
char codProc[4+1];
memset(codProc,0,sizeof(codProc));
strncpy(codProc , m_read.c_str()+HEADER_LEN , 4 );
codProc[2]='1';
iso->CreateSend( send, codProc);
}
for ( it=process->LstBitRow().begin() ; it != process->LstBitRow().end(); it++ ){
string value = Variant2String(db->GetParameter((*it)->SqlRow().c_str()) );
RemoveSpace( value );
iso->Set( atoi( (*it)->Bit().c_str() ), value.c_str() );
}
delete db;
delete iso;
return true;
}
delete db;
}
delete iso;
return false;
}
/* =======================================================================
* Callback function processing each field of comma-delimited arg string
* ======================================================================= */
void cbProcessListElement (void *s, size_t len, void *data)
{
char buf[1024] = "";
char mddname[1024] = "";
LIST_DATA *ldata = (LIST_DATA*)data;
bool Not = false; // negation flag - set to true if ! preceeds the id
if (s)
{
strncpy(buf, (char*)s, len);
RemoveSpace(buf);
if (buf[0] == '!') // negation detected
{
sprintf(mddname, "ra%s%s", buf + 1, conf.suffix);
Not = true;
GetSignalInfo(ldata->nLn, buf + 1 , mddname);
}
else
{
sprintf(mddname, "ra%s%s", buf, conf.suffix);
GetSignalInfo(ldata->nLn, buf , mddname);
}
fprintf(stderr, "inputsLst(%d) = %s\n", InpCnt, buf);
strcpy(inputsLst[InpCnt], buf);
InpCnt++;
if ((signals + nSig - 1)->found)
fprintf(ldata->flp, "\t// Internal ID: %s External ID: %s\n", (signals + nSig - 1)->radiyname,
(signals + nSig - 1)->extID);
if (Not)
fprintf(ldata->flp, "\t%s.%s[%d] = !%s;\n", ldata->dataName, ldata->lp, ldata->cnt, mddname);
else
fprintf(ldata->flp, "\t%s.%s[%d] = %s;\n", ldata->dataName, ldata->lp, ldata->cnt, mddname);
ldata->cnt++;
}
}
BOOL CFilteringTable::IsInvalidText(Type type, LPCTSTR text) const
{
const FilterContainer::const_iterator filterIterator = mFilterContainer.find(
type);
if(mFilterContainer.end() == filterIterator)
{
return FALSE;
}
const KeywordContainer& keywordContainer = filterIterator->second;
TCHAR buffer[MAX_PATH] = {0};
RemoveSpace(
text,
buffer,
sizeof(buffer) / sizeof(*buffer));
_tcsupr(
buffer);
if(TypeEntirelyBlockedName == type)
{
return keywordContainer.end() != keywordContainer.find(
buffer);
}
const Text checkedText(buffer);
for(KeywordContainer::const_iterator iterator = keywordContainer.begin();
keywordContainer.end() != iterator;
++iterator)
{
if(FindPartially(checkedText, *iterator))
{
return TRUE;
}
}
return FALSE;
}
/* ========================================================================
* This function will analyze expression and fill in EXPRESSION structure
* holding:
* left part (lp)
* right part (rp)
* If right part isn't a signal name signal flag = false, number = true
* otherwise flags are assigned other way round
* If signal name is in MDD then set inMDD = true;
* If anything goes wrong set error = TRUE and give up
* IMPORTATNT: function assumes all blanks are stripped from expr arg
* UPD: however we call RemoveSpace again to sleep better
* ======================================================================== */
int ParseExpression(char *expr, EXPRESSION *exprData)
{
char *ch = NULL;
char buf[1024] = "";
if (!expr)
return -1;
// Do cleanup
memset(exprData, '\x0', sizeof(EXPRESSION));
strcpy(buf, expr);
// Strip spaces if any
RemoveSpace(buf);
ch = strstr(buf, "=");
if (ch) // There's equal sign, treat expr as an Y = X style expression
{
// Get right part, then terminate at '='
strcpy(exprData->rp, ch + 1);
*ch = '\x0';
// Get left part
strcpy(exprData->lp, buf);
// Check if the right part is a list (for OR, AND etc)
// If it is not:
// 1. Check if the right part is numeric
// 2. If it is not then treat it as a signal name
if ((isList(exprData->rp)) == RP_LIST) // right part is comma-sep list
{
exprData->list = true;
exprData->signal = false;
exprData->number = false;
// That's it for the list - we already have it in rp member, no further processing needed
}
else // right part is an individual signal or number
{
if ((isNumeric(exprData->rp)) == RP_SIGNAL) // signal - we'll make MDD name of it
{
// make MDD point name and store it to mddname, separately from rp
memset(buf, '\x0', sizeof(buf));
// set flag if negation needed that is '!' stands in front of signal name
if (exprData->rp[0] == '!')
{
exprData->Not = true;
sprintf(buf, "ra%s%s", (exprData->rp) + 1, conf.suffix);
fprintf(stderr, "ParseExpression: negation found: rp = %s buf = %s\n", exprData->rp, buf);
}
else
{
exprData->Not = false;
sprintf(buf, "ra%s%s", exprData->rp, conf.suffix);
}
strcpy(exprData->mddname, buf);
exprData->list = false;
exprData->signal = true;
exprData->number = false;
} // number on the right part - set flags and that's it
else
{
exprData->signal = false;
exprData->list = false;
exprData->number = true;
}
}
return IAM_EXPRESSION;
}
// expr isn't an expression in fact
exprData->error = true;
return IAMNOT_EXPRESSION;
}
void main(void)
{
int i;
const int TC_MAX = 26;
char buf[BUF_MAX] = { 0, };
char exp[TC_MAX][BUF_MAX] =
{
"1+2+3",
"(1+2)+3",
"1+(2+3)",
"-(1+2)+3",
"-(-1+2)+3",
"(-2)*3",
"-3*(-3)",
"((1+2)*3)-2",
"(((1+2)*(2-3))/3)",
"-(-(2+3))",
"2+(-4*2-(2+3))",
"-((1+(-2)+(3+(4+(-5)+6+(-7))+8)+9)+(-10))",
"(((1+2)*(2-3))/3) % 7 + (-34*7-98/2*(-2))",
"-( 28 * (( -23 - 7 % 9 )-( 22 / 3 - 9 * 4 -( -8 + 6 * 3 )))) ",
"(-(28*((-44 -7%5) - (22/3645-977*4 -(8+654*3)))) -(28*((-23 -7%9) - (22/3-9*4 -(-8+6*3))))) * 6-45",
"-123456789 + 123456789 + 4 * 596 % 10 -87 /14",
"1*2*3*4*5*6*7*8*9",
"-(1*((-2)*(3*(-4)*5*(-6)*7)))*(-8*9)",
"1234567890/24444/21/2",
"1234567890/((-24444)/21)/(-2)",
"1*+3",
"11231*-324",
"1+(+1)",
"1-(-1)",
"-5*-4-5*4+5*4+5*-4",
// "1+-+1",
// "1-+-1",
// "1+-+-1",
// "1-+-+1",
// "1*+-+-1",
// "1*+-+1",
// "-+-+1-+1", // +/- 의 배치에 따라 안되는 경우 잔존함
// "+-+1-+1",
// "-341*-(+-+-+-+1)",
// "-341+(-(+-+-+-+12))",
// "-+-+-+(-+-34)*-+-(32/-+-+-5)"
// "(-(28*((-44*1*1 -7%5 -341*-(+1)) - (22/3645-977*4 -(8+1-1+654*3)))) -(28*((-23 -7%9) - (22/3-9*4 -(-8+6*3))))) * 6-45 +1-+1"
"(-(28*((-44*1*-1 -7%5 -341*-(+1)) - (22/3645-977*4 -(8+1+1+654*3)))) -(28*((-23 -7%9) - (22/3-9*4 -(-8+6*3))))) * 6-45 -1-+1"
};
// Expresion Test
i = -((1+(-2)+(3+(4+(-5)+6+(-7))+8)+9)+(-10));
i = -(1*((-2)*(3*(-4)*5*(-6)*7)))*(-8*9);
i = 1*+-+-1;
i = 1+-+1;
i = 1+-+-+1;
i = 1-+-+-+1;
i = 1-+-+-+-+1;
i = 1-+-+-+-+-1;
for (i = 0; i < TC_MAX; i++)
{
RemoveSpace(buf, exp[i]);
while (HasBrase(buf))
{
ParseBrace(buf);
}
CalcExpresion(buf);
PutS(buf);
PutS(" \t");
PutS(exp[i]);
PutS("\n");
}
return;
}
