protected override Term Exec_RELOP_EQUAL(PacketFilterCallStack cs, Term term_sub)
{
if (term_sub is Term_Text term_sub_c)
{
return(new Term_Bool(value_.IsMatch(term_sub_c.Value)));
}
return(null);
}
protected override Term Exec_RELOP_EQUAL(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_Binary === */
if (term_sub is Term_Binary term_sub_c)
{
return(new Term_Bool(value_.SequenceEqual(term_sub_c.Value)));
}
return(null);
}
protected override Term Exec_ARMOP_ADD(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_DateTimeOffset === */
if (term_sub is Term_DateTimeOffset term_sub_dto)
{
return(new Term_DateTime(value_ + term_sub_dto.Value));
}
return(null);
}
protected override Term Exec_ARMOP_REM(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_Number === */
if (term_sub is Term_Number term_sub_num)
{
return(new Term_Number(value_ % term_sub_num.Value));
}
return(null);
}
protected override Term Exec_ARMOP_ADD(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_Text === */
if (term_sub is Term_Text term_sub_text)
{
return(new Term_Text(value_ + term_sub_text.Value));
}
return(null);
}
protected override Term Exec_RELOP_EQUAL(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_Number === */
if (term_sub is Term_Number term_sub_num)
{
return(new Term_Bool(value_ == term_sub_num.Value));
}
return(null);
}
protected override Term Exec_RELOP_LESSEQUAL(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_DateTime === */
if (term_sub is Term_DateTime term_sub_dt)
{
return(new Term_Bool(value_ <= term_sub_dt.Value));
}
return(null);
}
public override Term Exec(PacketFilterCallStack cs, Tokens token, Term term_sub)
{
var term_new = GetStatusTerm(cs, value_);
if (term_new == null)
{
return(null);
}
return(term_new.Exec(cs, token, term_sub));
}
protected override Term Exec_ARMOP_SUB(PacketFilterCallStack cs, Term right)
{
/* === Term_DateTimeOffset === */
if (right is Term_DateTimeOffset right_dto)
{
return(new Term_DateTimeOffset(value_ - right_dto.Value));
}
/* === Term_DateTime === */
if (right is Term_DateTime right_dt)
{
return(new Term_DateTime(right_dt.Value.Subtract(Value)));
}
return(null);
}
protected override Term Exec_RELOP_LESSEQUAL(PacketFilterCallStack cs, Term right)
{
/* === Term_DateTimeOffset === */
if (right is Term_DateTimeOffset right_dto)
{
return(new Term_Bool(value_ <= right_dto.Value));
}
/* === Term_Number === */
if (right is Term_Number right_num)
{
return(new Term_Bool(value_ <= right_num.ToTimeSpan()));
}
return(null);
}
protected override Term Exec_RELOP_EQUAL(PacketFilterCallStack cs, Term term_sub)
{
/* === Term_Text === */
if (term_sub is Term_Text term_sub_text)
{
return(new Term_Bool(value_ == term_sub_text.Value));
}
/* === Term_Regex === */
if (term_sub is Term_Regex term_sub_reg)
{
return(term_sub_reg.Exec(cs, Tokens.RELOP_EQUAL, this));
}
return(null);
}
public virtual Term Exec(PacketFilterCallStack cs, Tokens token, Term term_sub)
{
var term_main = this;
switch (token)
{
case Tokens.ARMOP_SET: return(term_main.Exec_ARMOP_SET(cs, term_sub));
case Tokens.ARMOP_ADD: return(term_main.Exec_ARMOP_ADD(cs, term_sub));
case Tokens.ARMOP_SUB: return(term_main.Exec_ARMOP_SUB(cs, term_sub));
case Tokens.ARMOP_MUL: return(term_main.Exec_ARMOP_MUL(cs, term_sub));
case Tokens.ARMOP_DIV: return(term_main.Exec_ARMOP_DIV(cs, term_sub));
case Tokens.ARMOP_REM: return(term_main.Exec_ARMOP_REM(cs, term_sub));
case Tokens.ARMOP_NEG: return(term_main.Exec_ARMOP_NEG(cs));
case Tokens.RELOP_GREATER: return(term_main.Exec_RELOP_GREATER(cs, term_sub));
case Tokens.RELOP_LESS: return(term_main.Exec_RELOP_LESS(cs, term_sub));
case Tokens.RELOP_GREATEREQUAL: return(term_main.Exec_RELOP_GREATEREQUAL(cs, term_sub));
case Tokens.RELOP_LESSEQUAL: return(term_main.Exec_RELOP_LESSEQUAL(cs, term_sub));
case Tokens.RELOP_EQUAL: return(term_main.Exec_RELOP_EQUAL(cs, term_sub));
case Tokens.RELOP_UNEQUAL: return(term_main.Exec_RELOP_UNEQUAL(cs, term_sub));
case Tokens.LOGOP_AND: return(term_main.Exec_LOGOP_AND(cs, term_sub));
case Tokens.LOGOP_OR: return(term_main.Exec_LOGOP_OR(cs, term_sub));
default: return(new Term_Bool(ToBool(cs)));
}
}
protected virtual Term Exec_ARMOP_NEG(PacketFilterCallStack cs)
{
return(new Term_Bool(!ToBool(cs)));
}
protected virtual Term Exec_ARMOP_REM(PacketFilterCallStack cs, Term term_sub)
{
return(null);
}
protected virtual Term Exec_LOGOP_OR(PacketFilterCallStack cs, Term term_sub)
{
return(new Term_Bool(ToBool(cs) || term_sub.ToBool(cs)));
}
protected virtual Term Exec_RELOP_UNEQUAL(PacketFilterCallStack cs, Term term_sub)
{
return(new Term_Bool(!Exec_RELOP_EQUAL(cs, term_sub).ToBool(cs)));
}
public override bool ToBool(PacketFilterCallStack cs)
{
return((value_ != null) && (value_.Length > 0));
}
protected virtual Term Exec_RELOP_LESS(PacketFilterCallStack cs, Term term_sub)
{
return(null);
}
public override bool ToBool(PacketFilterCallStack cs)
{
var term = GetStatusTerm(cs, value_);
return((term != null) ? (term.ToBool(cs)) : (false));
}
public override bool ToBool(PacketFilterCallStack cs)
{
return(value_ != DateTime.MinValue);
}
private Term GetStatusTerm(PacketFilterCallStack cs, StatusType type)
{
switch (type)
{
case StatusType.PacketCount: {
return(new Term_Number(cs.PacketCount));
}
case StatusType.LastPacketDelta: {
return(new Term_DateTimeOffset(cs.LastPacket.MakeTime - cs.PrevPacket.MakeTime));
}
case StatusType.Packet_IsControl: {
return(new Term_Bool(cs.LastPacket.Attribute == PacketAttribute.Control));
}
case StatusType.Packet_IsMessage: {
return(new Term_Bool(cs.LastPacket.Attribute == PacketAttribute.Message));
}
case StatusType.Packet_IsData: {
return(new Term_Bool(cs.LastPacket.Attribute == PacketAttribute.Data));
}
case StatusType.Packet_Alias: {
return(new Term_Text(cs.LastPacket.Alias));
}
case StatusType.Packet_MakeTime: {
return(new Term_DateTime(cs.LastPacket.MakeTime));
}
case StatusType.Packet_Class: {
return(new Term_Text(cs.LastPacket.Class));
}
case StatusType.Packet_Information: {
return(new Term_Text(cs.LastPacket.Information));
}
case StatusType.Packet_Mark: {
return(new Term_Number(cs.LastPacket.UserMark));
}
case StatusType.Packet_Data_IsSend: {
return(new Term_Bool(cs.LastPacket.Direction == PacketDirection.Send));
}
case StatusType.Packet_Data_IsRecv: {
return(new Term_Bool(cs.LastPacket.Direction == PacketDirection.Recv));
}
case StatusType.Packet_Data_Source: {
return(new Term_Text(cs.LastPacket.Source));
}
case StatusType.Packet_Data_Destination: {
return(new Term_Text(cs.LastPacket.Destination));
}
case StatusType.Packet_Data_Length: {
return(new Term_Number(cs.LastPacket.DataLength));
}
case StatusType.Packet_Data_BitString: {
return(new Term_Text(cs.LastPacket.DataToBitString()));
}
case StatusType.Packet_Data_HexString: {
return(new Term_Text(cs.LastPacket.DataToHexString()));
}
case StatusType.Packet_Data_AsciiText: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.ASCII)));
}
case StatusType.Packet_Data_Utf8Text: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.UTF8)));
}
case StatusType.Packet_Data_Utf16BeText: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.BigEndianUnicode)));
}
case StatusType.Packet_Data_Utf16LeText: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.Unicode)));
}
case StatusType.Packet_Data_ShiftJisText: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.GetEncoding(932))));
}
case StatusType.Packet_Data_EucJpText: {
return(new Term_Text(cs.LastPacket.DataToText(Encoding.GetEncoding(20932))));
}
default: return(null);
}
}
protected override Term Exec_RELOP_EQUAL(PacketFilterCallStack cs, Term term_sub)
{
return(new Term_Bool(value_ == term_sub.ToBool(cs)));
}
protected virtual Term Exec_RELOP_GREATEREQUAL(PacketFilterCallStack cs, Term term_sub)
{
return(null);
}
public virtual bool ToBool(PacketFilterCallStack cs)
{
return(false);
}
public override bool ToBool(PacketFilterCallStack cs)
{
return(value_ != 0);
}
