/**
* Virtual function to calculate a point for this fucntion.
* @param x (input) x input value for this function.
* @return Y value corresponding to the x input.
*/
TMathResult
TrigFunction::CalculateY(
double x,
double *y)
{
TMathResult status = MATH_SUCCESS;
double result = 0;
double angle = x;
if(GetAngleMode() == MATH_ANGLES_IN_DEGREES)
{
angle = DegreesToRadians(x);
}
switch(GetOperatorType())
{
case MATH_SIN:
result = sin(angle);
break;
case MATH_COS:
result = cos(angle);
break;
case MATH_TAN:
result = tan(angle);
break;
case MATH_COT:
result = tan(angle);
if(!IsEqual(result, 0))
result = 1/result;
else
status = MATH_UNDEFINED;
break;
case MATH_SEC:
result = cos(angle);
if(!IsEqual(result, 0))
result = 1/result;
else
status = MATH_UNDEFINED;
break;
case MATH_CSC:
result = sin(angle);
if(!IsEqual(result, 0))
result = 1/result;
else
status = MATH_UNDEFINED;
break;
}
if(status == MATH_SUCCESS)
*y = result;
return status;
}
static LAYER7_MATCHING_EXPR_STACK_CTX *GetMatchingProgramFromFilterExpression(const char *filter, const size_t filter_size) {
LAYER7_MATCHING_EXPR_STACK_CTX *sta = NULL, *stb = NULL, *top = NULL;
char *infix_filter_expr = (char *) WinDivertAlloc(filter_size + 4);
char token[255];
size_t t;
int neg = 0;
const char *fp = NULL;
const char *fp_end = NULL;
memset(infix_filter_expr, 0, filter_size + 3);
memcpy(infix_filter_expr, filter, filter_size);
strcat(infix_filter_expr, " )");
fp = &infix_filter_expr[0];
fp_end = fp + filter_size + 2;
sta = PushTokenToLayer7MatchingExprStackCtx(sta, "(", 1, WINDIVERT_LAYER7_MATCHING_TOKEN_TYPE_ALIEN);
while (fp != fp_end) {
switch (*fp) {
case '"':
t = 0;
memset(token, 0, sizeof(token));
token[t++] = *fp;
fp++;
while (fp != fp_end && *fp != '"' && t < sizeof(token)) {
if (*fp == '\\') {
fp++;
}
token[t++] = *fp;
fp++;
}
if (*fp == '"' && t != sizeof(token)) {
fp++;
stb = PushTokenToLayer7MatchingExprStackCtx(stb, &token[1], t - 1, WINDIVERT_LAYER7_MATCHING_TOKEN_TYPE_STRING);
} else {
DelLayer7MatchingExprStackCtx(sta);
DelLayer7MatchingExprStackCtx(stb);
return NULL;
}
t = 0;
break;
case '(':
if (neg) {
DelLayer7MatchingExprStackCtx(sta);
DelLayer7MatchingExprStackCtx(stb);
return NULL;
}
sta = PushTokenToLayer7MatchingExprStackCtx(sta, fp, 1, WINDIVERT_LAYER7_MATCHING_TOKEN_TYPE_ALIEN);
fp++;
break;
case ')':
top = TopOfLayer7MatchingExprStackCtx(sta);
while (top != NULL && *top->token != '(') {
stb = PushTokenToLayer7MatchingExprStackCtx(stb, top->token, strlen(top->token), top->type);
sta = PopTokenFromLayer7MatchingExprStackCtx(sta);
top = TopOfLayer7MatchingExprStackCtx(sta);
}
fp++;
break;
case ' ':
case '\n':
case '\r':
case '\t':
token[t] = 0;
neg = 0;
if (t > 0) {
if (IsKnownOperator(token)) {
if (strcmp(token, "not") == 0 || strcmp(token, "!") == 0) {
neg = 1;
}
top = TopOfLayer7MatchingExprStackCtx(sta);
while (IsKnownOperator(top->token)) {
stb = PushTokenToLayer7MatchingExprStackCtx(stb, top->token, strlen(top->token), top->type);
sta = PopTokenFromLayer7MatchingExprStackCtx(sta);
top = TopOfLayer7MatchingExprStackCtx(sta);
}
sta = PushTokenToLayer7MatchingExprStackCtx(sta, token, strlen(token), GetOperatorType(token));
} else {
DelLayer7MatchingExprStackCtx(sta);
DelLayer7MatchingExprStackCtx(stb);
return NULL;
}
t = 0;
}
fp++;
break;
default:
token[t++] = *fp;
fp++;
break;
}
}
DelLayer7MatchingExprStackCtx(sta);
sta = NULL;
while (!IsEmptyLayer7MatchingExprStackCtx(stb)) {
top = TopOfLayer7MatchingExprStackCtx(stb);
sta = PushTokenToLayer7MatchingExprStackCtx(sta, top->token, strlen(top->token), top->type);
stb = PopTokenFromLayer7MatchingExprStackCtx(stb);
}
DelLayer7MatchingExprStackCtx(stb);
free(infix_filter_expr);
return sta;
}
/**
* Pure virtual function to calculate a point for this fucntion.
* @param x (input) x input value for this function.
* @return Y value corresponding to the x input.
*/
TMathResult
SimpleOperator::CalculateY(
double x,
double *y)
{
TMathResult status = MATH_SUCCESS;
double result = 0;
double left = 0, right = 0;
//------------------------------------------------
// Determine the left hand side of the operation.
//------------------------------------------------
if(m_Lhs)
{
status = m_Lhs->CalculateY(x, &left);
}
else if(m_LeftConstant)
{
left = *m_LeftConstant;
}
//------------------------------------------------
// Determine the right hand side of the operation.
//------------------------------------------------
if(status == MATH_SUCCESS)
{
if(m_Rhs)
status = m_Rhs->CalculateY(x, &right);
else if(m_RightConstant)
right = *m_RightConstant;
}
if(status != MATH_SUCCESS) return status;
//----------------------
// Apply the operator.
//----------------------
switch(GetOperatorType())
{
case MATH_ADD:
result = left + right;
break;
case MATH_SUBTRACT:
result = left - right;
break;
case MATH_MULTIPLY:
result = left * right;
break;
case MATH_DIVIDE:
if(!IsEqual(right, 0))
result = left / right;
else
status = MATH_UNDEFINED;
break;
case MATH_POWER:
//------------------------------------------------
// In the case of the power, left hand side will
// be the base, and right hand side the exponent.
//------------------------------------------------
result = pow(left, right);
break;
}
if(status == MATH_SUCCESS)
*y = result;
return status;
}
