string RadomFormula::GetFormula()
{
p1 = rand() % 30;
p2 = rand() % 30;
op1 = rand() % OpArr.size();
int pi = Operate(op1, p1, p2);
int s1 = -pi;
int s2 = 30 - pi;
if (s1 < -30)
{
s1 = -30;
}
if (s2 > 30)
{
s2 = 30;
}
p3 = s1 + rand() % (s2 - s1);
if (p3 >= 0)
{
op2 = 0;
}
else
{
op2 = 1; p3 = -p3;
}
return Transport(p1) + OpArr[op1] + Transport(p2) + OpArr[op2] + Transport(p3) + "=";
}
/*************************************************************
* Que 3. Post fix expression evaluation
*
* Comment : 1) prepare stack for holding operands only.
* 2) Push when numbers are read.
* 3) Pop two numbers when ever operand is encountered.
*
* Parameters : expression array
* Returns : int (eval result)
*************************************************************/
int PostFixEval(char A[])
{
LinkedListStack stack;
int tokenType = EMPTY,num,i=0;;
char token;
while((tokenType = ReadToken(A,i,token,num)) != EMPTY)
{
if(tokenType == OPERAND) //Numbers
{
stack.Push(token - '0');
}
else if(tokenType == OPERATOR) //Mathematical operator
{
int A = stack.Pop();
int B = stack.Pop();
stack.Push(Operate(A,B,token));
}
else
{
//Should not reach here
assert(1 == 0);
}
}
if(stack.IsEmpty())
return -1;
return stack.Pop();
}
int EvaluateExpression()
{
char ch; type e,theta,a,b;
SqStack OPTR,OPND; //OPTR为运算符栈，OPND为运算数栈
StackInit(&OPTR); StackInit(&OPND);
Push(&OPTR,'#');
ch=getchar();
while(ch!='#' || GetTop(&OPTR)!='#')
{
if(!In(ch))
{
Push(&OPND,ch);
ch=getchar();
}
else
{
switch(Precede(GetTop(&OPTR),ch))
{
case '<':Push(&OPTR,ch); ch=getchar(); break;
case '=':Pop(&OPTR,&e); ch=getchar(); break;
case '>':Pop(&OPTR,&theta);Pop(&OPND,&b);Pop(&OPND,&a);
Push(&OPND,Operate(a,theta,b)); break;
}
}
}
return GetTop(&OPND);
}
//***************************************************************
EVENT_TYPE TUsartGSM::OnEvent(TEvent* Event)
{uint16_t msgMsg = msgEmpty ;
strRcv = GetS(RcvBuf,LenBF) ;// есть принятые строки?
cntRcv = (strRcv && *strRcv)? strlen(strRcv) : 0 ;// сколько их?
if(strRcv && cntRcv){ msgMsg = Parse(strRcv,cntRcv) ; strRcv = 0 ;}
if(!msgMsg) msgMsg = OnEventGSM() ;
if(!timOut && !msgMsg){ msgMsg = msgTimeOut ; timOut = -1 ;}
if(msgMsg != msgEmpty){ timOut = Operate(msgMsg) ;}// !!!!!!!!!!!!!!!!!
if(timOut <= 0) timOut = TIM_IDLE ;
if(prStateTrg != StateTrg || prSttPhase != SttPhase){
prStateTrg = StateTrg ; prSttPhase = SttPhase ;
sprintf(StrStt,"%s, %d",strStat[StateTrg],SttPhase) ; strStt = StrStt ;}
switch(Event->Type){
case evGetEvent:
if(strDbg) { Event->Type = evDbgMsg1 ; Event->strData[0] = strDbg ; strDbg = 0 ;}
else if(strMsg){ Event->Type = evDbgMsg2 ; Event->strData[0] = (char*)strMsg ; strMsg = 0 ;}
else if(flEventNeed){ Event->Type = flEventNeed ; Event->Value = flValueNeed; flEventNeed=0 ;}
else if(strStt){ Event->Type = evStat1 ; Event->strData[0] = strStt ; strStt = 0 ;}
else if(flInitOK){Event->Type = evGsmInitOK ; flInitOK = 0 ;}
break ;
// case evClearPswGSM : PswGSM = 0 ; if(FnSetPswGSM ) FnSetPswGSM(PswGSM) ; break ;
// если произошло событие по которому необходимо отправить инфоСМС, то
case evEventSMS : strncpy(PhoneNmbrSMS,GetMasterNmbr(),16) ;// отправить инф. СМС на MasterNmbr
if(!StrCmp(PhoneNmbrSMS,strValidNmbr)){ // если он валидный
NeedSendSMS = 1 ; timGuardSMS = 0 ;}
else{ *PhoneNmbrSMS = 0 ; SetMasterNmbr(PhoneNmbrSMS) ;}// иначе, стереть его
break ;
}
return Event->Type ;}
WORD direct_read(WORD pos, WORD size, char *buf)
{
DiscReq req;
#ifdef debug
IOdebug("msdosfs : direct_read - pos %d, size %d", pos, size);
#endif
req.DevReq.Request = FG_Read;
req.DevReq.Action = Action;
req.DevReq.SubDevice = DEFAULTPART;
req.Pos = pos/Sector_size;
req.Size = size/Sector_size;
if(size % Sector_size)
req.Size++;
req.Buf = buf;
#ifdef debugE
IOdebug("msdosfs : direct_read %d %d", req.Pos, req.Size);
#endif
Operate(dcb, &req);
if( req.DevReq.Result == 0)
{
#ifdef debugE
IOdebug("msdosfs : read %d bytes", req.Actual);
#endif
return size;
}
#ifdef debugE
IOdebug("msdosfs ERROR : flop_read : can't read");
#endif
return 0;
}
ElemType OperaType(void){
//全数据为整型操作
SqStack OPTR,OPND;//OPTR运算符栈，OPND运算栈
InitStack(OPTR);
Push(OPTR,'#');
InitStack(OPND);
int ch,x,a,b,theta;
ch=getche();
while(ch!='#' || GetTop(OPTR)!='#'){
if(!In(ch)){
Push(OPND,ch-48);
ch=getche();
}else{
switch(Precede(GetTop(OPTR),ch)){
case '<':
Push(OPTR,ch);
ch=getche();
break;
case '=':
Pop(OPTR,x);
ch=getche();
break;
case '>':
Pop(OPTR,theta);
Pop(OPND,b);
Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
}//switch
}//if else
}//while
return GetTop(OPND);
}// OperaTyp
void CTrigger::Countdown (bool bObjTrigger)
{
if ((m_info.tOperated > 0) && !Delay ()) {
Operate (m_info.nObject, m_info.nPlayer, m_info.bShot, bObjTrigger);
if (m_info.flags & TF_PERMANENT)
m_info.tOperated = -1;
else
m_info.time = 0;
}
}
void makeStack(OPNDType *top1, OPTRType *top2)
{
OPNDType *Np, *Nq;
OPTRType *Tp, *Tq;
char ch, operator;
char save[20] = {0};
int i, f, k = 0, k1;
double a, b;
PushStack2(top2, '#'); //先给运算栈低存入 # 起始标识符
ch = getchar();
while( 1 ){
if( !decide(ch) ) //若 非运算符运算数 则转换成 # 结束标识符
ch = '#';
i = 0, f = 0, k1 = 0; //i和f辅助存入 n 位数字 k1 辅助存入负数
if( (ch >= '0' && ch <= '9') || ch == '.') f = 1;
if( (k == '#' || k == '(') && !f && ch == '-'){ //判断减号是否为负号
ch = getchar(), k1 = 1;
if( ch >= '0' && ch <= '9' ) f = 1;
}
while( (ch >= '0' && ch <= '9') || ch == '.')
save[i++] = ch, ch = getchar(); //将字符型数字存到数组中
if( f ){
save[i] = '\0';
if( k1 )
PushStack1(top1, atof(save)*-1); //将字符串转换成双精度
else
PushStack1(top1, atof(save));
continue ;
}
k = ch; //辅助存入负数
switch(Precede(GetTop(top2), ch)){
case 1 : return ; //运算完毕
case '<' :
PushStack2(top2, ch); ch = getchar(); break; //进栈继续接收
case '=' :
PopStack2(top2, &operator); ch = getchar(); break; //出栈继续接收
case '>' : //运算 不接收
PopStack2(top2, &operator);
PopStack1(top1, &a), PopStack1(top1, &b);
PushStack1(top1, Operate(b, operator, a));
break ;
}
if( ch == '#' && !top2->next)
return ;
}
}
int EvaluateExpression(){
int n;
int flag;
int c;
char x,theta;
int a,b;
char OP[]="+-*/()#";
SqStack OPTR;
SqStack OPND;
init_stack(&OPTR);
push(&OPTR,'#');
init_stack(&OPND);
flag=getNext(&c);
get_top(OPTR, &x);
while(c!='#' || x != '#')
{
if(flag == 0)
{
push(&OPND,c);
flag = getNext(&c);
} else
{
get_top(OPTR, &x);
switch(Precede(x, c))
{
case '<'://栈顶元素优先级低
push(&OPTR,c);
flag = getNext(&c);
break;
case '='://脱括号并接受下一字符
pop(&OPTR,&x);
flag = getNext(&c);
break;
case '>'：// 退栈并将运算结果入栈
pop(&OPTR, &theta);
pop(&OPND,&b);
pop(&OPND,&a);
push(&OPND, Operate(a, theta, b));
break;
}
}
get_top(OPTR, &x);
}
get_top(OPND, &c);
return c;
}
int EvalExpres(void) /* 表达式求解函数*/
{
int a,b,i=0,s=0;
char c[80],r;
InitStack(&StackR);
Push(&StackR,'#');
InitStack(&StackD);
printf(" 请输入表达式并以‘#’结束：");
gets(c);
while(c[i]!='#' || GetTop(&StackR)!='#')
{
if(!In(c[i])) /* 判断读入的字符不是运算符 是则进栈*/
{ if(c[i] >= '0' && c[i] <= '9')
{
s += c[i]-'0';
while(!In(c[++i])) /*此处实现的功能为当输入的数字为多位数时*/
{ s*=10;
s += c[i]-'0';
}
Push(&StackD,s+'0');
s = 0;
}
else
{
printf("你输入的表达式有误!\n");
return 0;
}
}
else
switch(Proceed(GetTop(&StackR),c[i])) /* 此函数用来比较读取的运算符和栈顶运算符的优先级*/
{
case '<': /* 栈顶的元素优先级高*/
Push(&StackR,c[i]);
i++;
break;
case '=': /* 遇到匹配的小括号时则去掉他*/
Pop(&StackR);
i++;
break;
case '>': /* 栈顶的优先级低则出栈并将结果写入栈内*/
r = Pop(&StackR);
a = Pop(&StackD)-'0';
b = Pop(&StackD)-'0';
Push(&StackD,Operate(a,r,b)) ;
break;
}
}
return (GetTop(&StackD)-'0'); /* 返回运算结果*/
}
int EvaluateExpression(){
// P53 算法3.4
// 算术表达式求值的算符优先算法，设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合
SqStack OPTR, OPND;
InitStack(OPTR);
bool judgePre=0; // 判断输入的前一个字符是否为数字，用于多位数的运算
Push(OPTR, '#');
InitStack(OPND);
int c, x, medi;
OperandType theta;
int a, b;
c = getchar();
while (c!='#' || GetTop(OPTR)!='#'){
if (!In(c)){ //不是运算符则进栈
c = c - '0';
if (!In(GetTop(OPND)) && judgePre){
Pop(OPND, medi);
c += medi * 10;
}
Push(OPND, c);
judgePre = 1;
c = getchar();
} else {
switch (Precede(GetTop(OPTR),c)){
case '<':
Push(OPTR, c);
c = getchar();
break;
case '=':
Pop(OPTR, x);
c = getchar();
break;
case '>':
Pop(OPTR, theta);
Pop(OPND, b);
Pop(OPND, a);
Push(OPND, Operate(a, theta, b));
break;
default:
break;
}
judgePre = 0;
}
}
return GetTop(OPND);
}// EvaluateExpression
float EvaluateExpression(char* MyExpression) {
// 算术表达式求值的算符优先算法
// 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合
SC *OPTR = NULL; // 运算符栈，字符元素
SF *OPND = NULL; // 运算数栈，实数元素
char TempData[20];
float Data, a, b;
char theta, *c, Dr[] = { '#', '\0' };
OPTR = Push(OPTR, '#');
c = strcat(MyExpression, Dr);
strcpy(TempData, "\0"); //字符串拷贝函数
while (*c != '#' || OPTR->c != '#') {
if (!In(*c, OPSET)) {
Dr[0] = *c;
strcat(TempData, Dr); //字符串连接函数
c++;
if (In(*c, OPSET)) {
Data = atof(TempData); //字符串转换函数(double)
OPND = Push(OPND, Data);
strcpy(TempData, "\0");
}
} else // 不是运算符则进栈
{
switch (precede(OPTR->c, *c)) {
case '<': // 栈顶元素优先级低
OPTR = Push(OPTR, *c);
c++;
break;
case '=': // 脱括号并接收下一字符
OPTR = Pop(OPTR);
c++;
break;
case '>': // 退栈并将运算结果入栈
theta = OPTR->c;
OPTR = Pop(OPTR);
b = OPND->f;
OPND = Pop(OPND);
a = OPND->f;
OPND = Pop(OPND);
OPND = Push(OPND, Operate(a, theta, b));
break;
} //switch
}
} //while
return OPND->f;
} //EvaluateExpression
float EvaluateExpression(char* MyExpression) { // 算法3.4
// 算术表达式求值的算符优先算法。
// 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合。
StackChar OPTR; // 运算符栈，字符元素
StackFloat OPND; // 运算数栈，实数元素
char TempData[20];
float Data,a,b;
char theta,*c,x,Dr[2];
InitStack (OPTR);
Push (OPTR, '#');
InitStack (OPND);
c = MyExpression;
strcpy(TempData,"\0");
while (*c!= '#' || GetTop(OPTR)!= '#') {
if (!In(*c, OPSET)) {
Dr[0]=*c;
Dr[1]='\0';
strcat(TempData,Dr);
c++;
if(In(*c,OPSET)) {
Data=(float)atof(TempData);
Push(OPND, Data);
strcpy(TempData,"\0");
}
} else { // 不是运算符则进栈
switch (precede(GetTop(OPTR), *c)) {
case '<': // 栈顶元素优先权低
Push(OPTR, *c);
c++;
break;
case '=': // 脱括号并接收下一字符
Pop(OPTR, x);
c++;
break;
case '>': // 退栈并将运算结果入栈
Pop(OPTR, theta);
Pop(OPND, b);
Pop(OPND, a);
Push(OPND, Operate(a, theta, b));
break;
} // switch
}
} // while
return GetTop(OPND);
} // EvaluateExpression
int CTrigger::OperateD1 (short nObject, int nPlayer, int bShot)
{
int h = 1;
int nTrigger = TRIGGERS.Index (this);
for (int i = 0; i < int (sizeofa (xlatTriggers)); i++)
if (m_info.flagsD1 & xlatTriggers [i].nFlag) {
m_info.nType = xlatTriggers [i].nType;
gameData.trigs.delay [nTrigger] = -1;
if (!Operate (nObject, nPlayer, bShot, false))
h = 0;
}
m_info.nType = TT_DESCENT1;
if (!h)
gameData.trigs.delay [nTrigger] = gameStates.app.nSDLTicks;
return h;
}
SElemType EvaluateExpression() /* 算法3.4 */
{ /* 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈 */
SqStack OPTR,OPND;
SElemType a,b,c,x,theta;
InitStack(&OPTR);
Push(&OPTR,'#');
InitStack(&OPND);
c=getchar();
GetTop(OPTR,&x);
while(c!='#'||x!='#')
{
if(In(c)) /* 是7种运算符之一 */
switch(Precede(x,c))
{
case'<':
Push(&OPTR,c); /* 栈顶元素优先权低 */
c=getchar();
break;
case'=':
Pop(&OPTR,&x); /* 脱括号并接收下一字符 */
c=getchar();
break;
case'>':
Pop(&OPTR,&theta); /* 退栈并将运算结果入栈 */
Pop(&OPND,&b);
Pop(&OPND,&a);
Push(&OPND,Operate(a,theta,b));
break;
}
else if(c>='0'&&c<='9') /* c是操作数 */
{
Push(&OPND,c);
c=getchar();
}
else /* c是非法字符 */
{
printf("ERROR4\n");
exit(ERROR);
}
GetTop(OPTR,&x);
}
GetTop(OPND,&x);
return x;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 枚举版本并操作
BOOL CVSTool::Operate(BOOL bDotNet, INT iCommand)
{
DWORD i;
HKEY hKey;
BOOL bResult;
LONG lResult;
DWORD dwSize;
HKEY hToolKey;
FILETIME ftTime;
TCHAR tzName[MAX_PATH];
TCHAR tzToolKey[MAX_PATH];
// 打开键值
lResult = RegOpenKeyEx(HKEY_CURRENT_USER, bDotNet ? TEXT("Software\\Microsoft\\VisualStudio") : TEXT("Software\\Microsoft\\Devstudio"), 0, KEY_ALL_ACCESS, &hKey);
if (lResult != ERROR_SUCCESS)
{
return FALSE;
}
// 枚举版本循环
for (i = 0, bResult = FALSE; (bResult == FALSE) || (iCommand != 0); i++)
{
// 枚举版本
dwSize = MAX_PATH;
lResult = RegEnumKeyEx(hKey, i, tzName, &dwSize, NULL, NULL, NULL, &ftTime);
if (lResult != ERROR_SUCCESS)
{
break;
}
// 打开工具菜单键值
wsprintf(tzToolKey, TEXT("%s\\%s"), tzName, bDotNet ? TEXT("External Tools") : TEXT("Tools"));
lResult = RegOpenKeyEx(hKey, tzToolKey, 0, KEY_ALL_ACCESS, &hToolKey);
if (lResult == ERROR_SUCCESS)
{
_ExIf(Operate(hToolKey, bDotNet, iCommand), bResult = TRUE);
RegCloseKey(hToolKey);
}
}
RegCloseKey(hKey);
return bResult;
}
double EvaExpression()
{
SqStack<int> OPTR;
SqStack<double> OPND;
int buffer;
bool preIsDigit = false;
bool hasDot = false;
int exp;
double ans = 0;
OPTR.Push(Index('#'));
buffer = mGetchar();
if (buffer == INPUT_VALID) return EvaExpression();
while (buffer!='#' || OPTR.GetTop()!=Index('#'))
{
if (buffer == '.')
{
if (hasDot)
{
char tmp_s[1024];
printf("您的输入有误，请确保输入的算术表达式合法！\n");
if (buffer != '\n') gets(tmp_s);
return EvaExpression();
}
hasDot = true;
exp = 0;
buffer = mGetchar();
if (buffer == INPUT_VALID) return EvaExpression();
}
else if (In(buffer, DIGIT))
{
if (preIsDigit)
{
double number;
OPND.Pop(&number);
if (hasDot)
{
exp--;
number += E(buffer-'0', exp);
}
else
{
number *= 10;
number += buffer-'0';
}
OPND.Push(number);
}
else
{
OPND.Push(buffer-'0');
preIsDigit = true;
}
buffer = mGetchar();
if (buffer == INPUT_VALID) return EvaExpression();
}
else
{
int toOperate, top;
preIsDigit = false;
hasDot = false;
toOperate = Index(buffer);
top = OPTR.GetTop();
switch(cmp[top][toOperate])
{
case -1:
OPTR.Push(toOperate);
buffer = mGetchar();
if (buffer == INPUT_VALID) return EvaExpression();
break;
case 0:
int tmp;
OPTR.Pop(&tmp);
buffer = mGetchar();
if (buffer == INPUT_VALID) return EvaExpression();
break;
case 1:
int op;
double a, b;
if (OPTR.Pop(&op) != OK || OPND.Pop(&b) != OK || OPND.Pop(&a) != OK)
{
char tmp_s[1024];
printf("您的输入有误，请确保输入的算术表达式合法！\n");
if (buffer != '\n') gets(tmp_s);
return EvaExpression();
}
ans = Operate(a, op, b);
OPND.Push(ans);
break;
case ERROR:
char tmp_s[1024];
printf("您的输入有误，请确保输入的算术表达式合法！\n");
if (buffer != '\n') gets(tmp_s);
return EvaExpression();
default:
exit(ERROR);
}
}
}
OPND.Pop(&ans);
if (OPTR.IsEmpty() || OPND.IsEmpty() ) return ans;
char tmp_s[1024];
printf("您的输入有误，请确保输入的算术表达式合法！\n");
if (buffer != '\n') gets(tmp_s);
return EvaExpression();
}
void main( )
{
char express[30], num[10], theta, tp , d;//express[30]用来读入一个表达式
double a ,b , result, tps; //num[10]用来存放表达式中连接着的数字字符
int t, i, j;
int position = 0;//表达式读到的当前字符
Initstack(OPND);
Initstack(OPTR); Push(OPTR , '=');
printf("input 'b' to run the calc:\n");
scanf("%c" , &d);
getchar();
while(d == 'b')
{
printf( "请输入表达式( 可使用+、-、*、/、(、)、= ): " ) ;
gets(express);
while(express[position] != '='||Gettop(OPTR , tp) != '=' )
{
if(!Is_op(express[position]))
{ //用两个计数器t和j实现浮点数的读取
t = position;j=0;
while(!Is_op(express[position]))
{
position++;
}
for(i = t; i<position ; i++ )
{//把表达式中第t到position-1个字符赋给num[10]
num[j] = express[i];
j++;
}
Push(OPND , atof(num));
memset(num,0,sizeof(num));//将num[10]清空
}
else
{
switch(Precede(isp(Gettop(OPTR , tp)),icp(express[position])))
{
case '<':
Push(OPTR,express[position]);position++;break;
case '=':
Pop(OPTR , tp) ;position++;break;
case '>':
{
Pop(OPTR , theta) ;
Pop(OPND , b) ;
Pop(OPND , a) ;
result = Operate(a, theta ,b);
Push(OPND , result);break;
}//end sase
}//end switch
}//end else
}//end while
printf("%s%8.4f\n",express,Pop(OPND,tps));
memset(express , 0 , sizeof(express));
position = 0;
printf("input 'b' to run the calc again:\n");
scanf("%c" , &d);
getchar();
}//end while
}
/**
* @brief 程序入口
* @param 无
* @return 返回
*/
int main(void)
{
int nOperRole = 0xff;
char szOper[OPERCODELEN + 1];
PubInitUiParam();
ASSERT_QUIT(Ums_CheckMcVer()); /*重要:判断主控版本*/
PubLuaOpen();
PubLuaDisplay("LuaSetUIStyle"); /*设置系统风格*/
RecordVersion(); /*记录版本信息*/
PubKbHit(); /*清除按键缓*/
/**
* 版本校验(首次运行检测)
*/
FirstRunChk();
/**
* 模块初始化,重要!!!
*/
AppInit();
#if defined(USE_TMS)
/**<检查是否有应用或者参数的更新*/
DoTmsTask(TMS_POS_CHKUPDATA);
GetTmsParamDown();
#endif
Cup_InitScrLed();
SetControlChkPinpad(YES);
/*
* 运行任务
*/
while(1)
{
/**
* 设备检查
*/
ChkPdAndRF();
/**
* 通讯初始化
*/
CommInit();
memset(szOper, 0, sizeof(szOper));
GetWaterOper(szOper);/**<取做过交易的(有流水)操作员号码*/
SetOperLimit(szOper);
GetVarLastOperInfo(szOper, &nOperRole);/**<取最后登陆的操作员信息(保存的)*/
SetCurrentOper(szOper, NULL, nOperRole);/**<将最后登陆的操作员信息设置给操作员模块*/
if (ChkIsMCReturn() == APP_SUCC || nOperRole != NORMALOPER || YES != GetVarIsLogin())
{
if (OperLogon() != APP_SUCC)
{
/*取消已设置的系统风格*/
PubLuaDisplay("LuaUnSetUIStyle");
PubLuaClose();
CommDump();
Cup_ExitScrLed();
return APP_QUIT;
}
}
GetCurrentOper(szOper, NULL, &nOperRole);/**<从操作员模块获取当前的操作员信息*/
SetVarLastOperInfo(szOper, (char)nOperRole);/**<保存最后登陆的操作员信息*/
/**
* 系统管理员
*/
if (nOperRole == ADMINOPER)
{
Manage();
ParamSave();
PubClearAll();
}
else if(nOperRole == HIDEMENUOPER)
{
HideManage();
}
else if(nOperRole == MANAGEROPER)
{
Operate();
}
else
{
if (APP_SUCC != AppTrans())
{
PubLuaDisplay("LuaUnSetUIStyle");
PubLuaClose();
CommDump();
Cup_ExitScrLed();
return APP_QUIT;
}
}
}
}
int CAmazonWraper::ChangePayType(AmazonOrderStru& objStr)
{
objStr.iOpFlag = 3;
return Operate(objStr);
}
int CAmazonWraper::Query(AmazonOrderStru& objStr)
{
objStr.iOpFlag = 1;
return Operate(objStr);
}
int CAmazonWraper::Order(AmazonOrderStru& objStr)
{
objStr.iOpFlag = 2;
return Operate(objStr);
}
CommandStatus OutstationSBOHandler::Operate(const AnalogOutputDouble64& arCommand, size_t aIndex, uint8_t aSequence, QualifierCode aCode)
{
return Operate(arCommand, aIndex, aSequence, aCode, mAnalogDoubleSelectMap);
}
void CFrobLever::Event_Operate()
{
Operate();
}
BOOL CMatrixDoc::GetResult(const CString &data,CArrayMatrix & matrix)
{
//在这可以通过修改data字符串和m_VariablePtrList变量链表来实现
//具体方法是首先假如data是包含多个运算符的
CString sDataString=data;
sDataString.TrimLeft("\n");
sDataString.TrimRight("\n");
CString *pVar;
CArrayMatrix result;
bool ok;
int VarNum=GetVariableNum(sDataString,pVar);
if(VarNum==0) return FALSE;
CTypedPtrList<CObList,CArrayMatrix *> tpVarList;
if(!StringsToMatrixs(pVar,tpVarList,VarNum))
{
if(pVar!=NULL) delete []pVar;
return FALSE;
}
TurnString(sDataString);
//表达式求值
{
sDataString=sDataString+"#";
CStack<TCHAR> OPTR;
CStack<CArrayMatrix *> OPND;
OPTR.Push('#');
int index=0;
TCHAR c=sDataString[index];
int nVarIndex=0;
while(c!=TCHAR('#')||OPTR.GetTop()!=TCHAR('#'))
{
if(!IsOperator(c))
{
POSITION pos=tpVarList.GetHeadPosition();
CArrayMatrix * pt=NULL;
for(int i=0;i<=nVarIndex&&i<tpVarList.GetCount();i++)
{
pt=tpVarList.GetAt(pos);
tpVarList.GetNext(pos);
}
if(pt==NULL) return FALSE;
OPND.Push(pt);
nVarIndex++;
index++;
c=sDataString[index];
}
else
{
switch(Precede(OPTR.GetTop(),c))
{
case -1:
{
OPTR.Push(c);
index++;
c=sDataString[index];
break;
}
case 0:
{
TCHAR x;
OPTR.Pop(x);
index++;
c=sDataString[index];
break;
}
case 1:
{
TCHAR theta;
OPTR.Pop(theta);
CArrayMatrix * b=NULL;
CArrayMatrix * a=NULL;
OPND.Pop(b);
OPND.Pop(a);
OPND.Push(Operate(a,theta,b,ok));
break;
}
}
}
}
result=*(OPND.GetTop());
}
//销毁tpvarlist变量里面的东西
{
POSITION pos=tpVarList.GetHeadPosition();
int len=tpVarList.GetCount();
for(int i=0;i<len;i++)
{
CArrayMatrix * tp=tpVarList.GetAt(pos);
delete tp;
tpVarList.GetNext(pos);
}
tpVarList.RemoveAll();
}
if(pVar!=NULL) delete []pVar;
if(!ok) return FALSE;
matrix=result;
return TRUE;
}
CommandStatus OutstationSBOHandler::Operate(const ControlRelayOutputBlock& arCommand, size_t aIndex, uint8_t aSequence, QualifierCode aCode)
{
return Operate(arCommand, aIndex, aSequence, aCode, mCROBSelectMap);
}
int hd_open(dev_t dev, int flags, int fmt)
{
u_int major, unit, part;
struct disk *du;
struct hd_devices *hdev;
DCB *dcb;
DiscOpenCloseReq openreq;
DiscParameterReq dpreq;
struct buf *bp;
int error = 0;
int wasold = FALSE;
#ifdef MONITOR
printf("hd_open: Called with dev=%d, flags=%d, fmt=%d by %s\n",
dev,flags,fmt,myprocname(returnlink_(dev)));
#endif
/* Get the unit info */
major = major(dev);
unit = dkunit(dev);
part = dkpart(dev);
hdev = &hd[major];
dcb = hd[major].dcb;
if (unit >= MAXDISKS) return(ENXIO);
du = &(hdev->disk[unit]);
#ifdef DEBUG
printf("hd_open: major %d unit %d part %d\n",major,unit,part);
#endif
/* Has the disk already been opened. */
if (du->dk_state != CLOSED) {
/* Already open, so don't mess with it. */
goto getpart;
}
/* Undefined device OR Trap old device driver compatibility */
if ((dcb == NULL) || hdev->old) {
/* Old style only supports 1 disk */
return(ENODEV);
}
/* Open the actual disk */
openreq.DevReq.Request = FG_Open;
openreq.DevReq.Action = dev_openaction;
openreq.DevReq.SubDevice = unit;
openreq.DevReq.Timeout = -1;
openreq.DevReq.Result = MYSPECCODE; /* Special Code */
InitSemaphore(&(openreq.WaitLock),0);
Operate(dcb,&openreq);
Wait(&(openreq.WaitLock));
/* Old style device driver was opened */
if ((openreq.DevReq.Result == MYSPECCODE) ||
((openreq.DevReq.Result & EG_Mask) == EG_WrongFn)) {
wasold = TRUE;
} else if (openreq.DevReq.Result) {
/* Error in opening device */
return(ENODEV);
}
/* Get the disk label using device driver defaults */
du->dk_lab = dflt_sizes;
du->dk_state = READLABEL;
bp = geteblk(DEV_BSIZE);
bp->b_dev = dev & 0xFFFFFFF8; /* Force to boot partition (a) */
bp->b_blkno = LABELSECTOR;
bp->b_flags = B_READ;
hd_strategy(bp); /* Start the operation. */
biowait(bp); /* Wait until complete */
if (bp->b_flags & B_ERROR) {
error = ENXIO;
du->dk_state = CLOSED;
goto done;
}
/* Is label there, otherwise open as raw. */
if (((struct disklabel *)
(bp->b_un.b_addr + LABELOFFSET))->d_magic == DISKMAGIC) {
du->dk_lab = *(struct disklabel *)
(bp->b_un.b_addr + LABELOFFSET);
du->dk_state = OPEN;
/* Pass disk information back to device driver */
/* Standard Request */
dpreq.DevReq.Request = FG_SetInfo;
dpreq.DevReq.Result = MYSPECCODE;
dpreq.DevReq.Action = dev_openaction;
dpreq.DevReq.SubDevice = unit;
dpreq.DevReq.Timeout = -1;
InitSemaphore(&dpreq.WaitLock,0);
/* Setup SetInfo parameters */
dpreq.DriveType = 0; /* Fixed Disk ? */
dpreq.SectorSize = du->dk_lab.d_secsize;
dpreq.SectorsPerTrack = du->dk_lab.d_nsectors;
dpreq.TracksPerCyl = du->dk_lab.d_ntracks;
dpreq.Cylinders = du->dk_lab.d_ncylinders;
/* Make it */
Operate(dcb,&dpreq);
Wait(&(dpreq.WaitLock));
if (dpreq.DevReq.Result)
printf("hd_open: Warning; Fault 0x%x on major dev %d FG_SetInfo\n",
(dpreq.DevReq.Result==MYSPECCODE) ?
(SS_Device|EC_Error|EG_WrongFn|EO_Medium):
dpreq.DevReq.Result,
major);
} else {
printf("hd (dev %d): Bad disk label (%x)\n",bp->b_dev,
((struct disklabel *)(bp->b_un.b_addr + LABELOFFSET))->d_magic);
du->dk_state = RAWOPEN;
}
done:
/* Release buffer. */
bp->b_flags = B_INVAL | B_AGE;
brelse(bp);
getpart:
#ifdef DEBUG
printf("hd_open: device %d get part %d\n",dev,part);
#endif
/* Get and set the partition info */
if (part >= MAXPARTITIONS) return(ENXIO);
if (du->dk_pstatus[part] != CLOSED) {
/* Partition is already open, don't mess with it. */
#ifdef DEBUG
printf("hd_open: device %d part %d already open\n",dev,part);
#endif
return(0);
}
if (du->dk_state == RAWOPEN) {
#ifdef DEBUG
printf("hd_open: device %d open as raw part %d\n",dev,part);
#endif
/* If no label, then only allow raw */
if (part == (RAWPARTITION - 'a')) {
#ifdef DEBUG
printf("hd_open: device %d opened as raw\n",dev);
#endif
du->dk_pstatus[part] = RAWOPEN;
} else {
du->dk_state = CLOSED;
#ifdef DEBUG
printf("hd_open: device %d refused opening partition %d as raw\n",dev,part);
#endif
return(ENXIO);
}
} else {
/* Label found, so check overlap with other open partitions */
struct partition *pp;
int start,end,i;
if (part >= du->dk_lab.d_npartitions) return(ENXIO);
pp = &du->dk_lab.d_partitions[part];
start = pp->p_offset;
end = start + pp->p_size;
for (pp = du->dk_lab.d_partitions, i=0;
i < du->dk_lab.d_npartitions;
pp++, i++) {
/* Ends before this starts or starts before this ends */
if (pp->p_offset + pp->p_size <= start ||
pp->p_offset >= end)
continue;
if (du->dk_pstatus[i]) {
printf("hd%d%c: overlaps open partition (%c)\n",
unit,part+'a',i+'a');
}
}
du->dk_pstatus[part] = OPEN;
}
#ifdef DEBUG
printf("hd_open: device %d opened error=%d\n",dev,error);
#endif
if (!error && wasold) hdev->old = TRUE;
return(error);
}
static void hd_intr_server(int major)
{
struct hd_devices *hdev = &hd[major];
Semaphore *numbufs = &(hdev->numbufs);
Semaphore *abort = &(hdev->abort);
DCB *dcb = hdev->dcb;
struct disk *this_hd = &(hdev->disk[0]); /* Start at 0 */
struct disk *last_hd = &(hdev->disk[MAXDISKS]); /* Terminate check */
int searched;
DiscReq req;
struct partition *pp;
struct buf *dp, *bp;
#ifdef DEBUG
printf("hd_intr_server: Helios Major device %d running\n",major);
#endif
/* Loop until ordered to shut down and no more buffers to work on. */
for (;;) {
/* Wait for a block to work on. */
Wait(numbufs);
if (TestWait(abort)) {
/* Forget anything else */
return;
}
/* Look for a disk to work on */
searched = 0;
while (!TestWait(&this_hd->dk_numq) && searched != MAXDISKS) {
this_hd++;
searched++;
if (this_hd >= last_hd)
this_hd = &(hdev->disk[0]);
}
if (searched == MAXDISKS) {
printf("hd_intr: PANIC %d, Failed to find buffer\n",major);
continue;
}
/* Extract the buffer */
dp = &(this_hd->dk_queue);
bp = dp->b_actf;
/* Get the partition (offset) */
pp = &(this_hd->dk_lab.d_partitions[dkpart(bp->b_dev)]);
/* Perform the operation */
req.DevReq.Request = ((bp->b_flags & B_READ)?FG_Read:FG_Write);
req.DevReq.Action = hd_iodone;
req.DevReq.SubDevice = dkunit(bp->b_dev);
req.DevReq.Timeout = -1; /* No Timeout */
req.Size = bp->b_bcount;
req.Buf = bp->b_un.b_addr;
req.Pos = bp->b_blkno + pp->p_offset; /* Sector */
/* Check if we are writing a disk label */
if ((req.Pos <= LABELSECTOR) && (!this_hd->dk_wlabel) &&
(req.DevReq.Request == FG_Write)) {
bp->b_error = EACCES; /* Not writeable */
goto skip;
}
/* Adjust to byte location */
req.Pos *= this_hd->dk_lab.d_secsize;
#ifdef DEBUG
printf("hd_intr_server: Major %d performing %s on dev=%d buf=0x%x (dcb=0x%x)\n",
major,((bp->b_flags & B_READ)?"Read":"Write"),bp->b_dev,buf,dcb);
printf("hd_intr_server: Request=0x%x, SubDevice=%d, Timeout=%d, Size=%d\n",
req.DevReq.Request,req.DevReq.SubDevice,req.DevReq.Timeout,req.Size);
#endif
InitSemaphore(&(req.WaitLock),0);
Operate(dcb,&req);
Wait(&(req.WaitLock)); /* XXX Implement multiple ops
* later. (i.e.TestWait for
* each disk)
*/
hd_ops++;
#ifdef DEBUG
printf("hd_intr_server: Major%d Pos=%d, Buf=0x%x Actual=%d %s\n",
major,req.Pos,req.Buf,req.Actual,
(req.Size==req.Actual)?"O.K.":"ERROR");
#endif
/* Any problems ? */
if (req.Size == req.Actual) {
bp->b_error = 0;
} else {
/* Error occurred */
bp->b_error = EIO;
bp->b_flags |= B_ERROR;
}
/* Operation complete, lock queue and remove bp */
skip:
Wait(&this_hd->dk_guard);
dp->b_actf = bp->av_forw;
bp->b_resid = 0;
bp->av_forw = NULL;
Signal(&this_hd->dk_guard);
/* Need to go into UNIX kernel to call biodone */
tokernel();
biodone(bp);
fromkernel();
/* Round robin scheduling */
this_hd++;
if (this_hd >= last_hd) this_hd = &(hdev->disk[0]);
}
}
/*
* Close a drive.
*/
int hd_close(dev_t dev, int flags, int fmt)
{
u_int major, unit, part;
struct disk *du;
struct hd_devices *hdev;
DCB *dcb;
#ifdef MONITOR
printf("hd_close: Called with dev=%d, flags=%d, fmt=%d by %s\n",
dev,flags,fmt,myprocname(returnlink_(dev)));
#endif
/* Get the unit info */
major = major(dev);
unit = dkunit(dev);
part = dkpart(dev);
hdev = &hd[major];
dcb = hdev->dcb;
if (unit >= MAXDISKS) return(ENXIO);
du = &(hdev->disk[unit]);
if (du->dk_state == CLOSED) return(0);
if (du->dk_state == RAWOPEN) {
du->dk_state = CLOSED;
for (part=0; part<MAXPARTITIONS; part++)
du->dk_pstatus[part] = CLOSED;
goto done;
}
part = dkpart(dev);
if (part >= du->dk_lab.d_npartitions) return(ENXIO);
du->dk_pstatus[part] = CLOSED;
for (part=0;
(part<MAXPARTITIONS) && (du->dk_pstatus[part] == CLOSED);
part++);
if (part == MAXPARTITIONS) du->dk_state = CLOSED;
done:
if (du->dk_state == CLOSED) {
if (hdev->old) {
hdev->old = FALSE; /* Only unit open now closed */
#ifdef DEBUG
printf("old unit dev %d was closed",dev);
#endif
} else {
DiscOpenCloseReq openreq;
openreq.DevReq.Request = FG_Close;
openreq.DevReq.Action = dev_openaction;
openreq.DevReq.SubDevice = unit;
openreq.DevReq.Timeout = -1;
openreq.DevReq.Result = MYSPECCODE; /* Special Code */
InitSemaphore(&(openreq.WaitLock),0);
Operate(dcb,&openreq);
Wait(&(openreq.WaitLock));
if (openreq.DevReq.Result)
printf("hd_close: Warning, Fault 0x%x on major dev %d\n",
(openreq.DevReq.Result==MYSPECCODE) ?
(SS_Device|EC_Error|EG_WrongFn|EO_Medium):
openreq.DevReq.Result,
major);
}
}
return(0);
}
