void Start18K6CRequest(uint tagStopCount, SelectFlags flags)
{
// Set up the rest of the HST_INV_CFG register. First, we have to read its
// current value
UInt32 registerValue = 0;
MacReadRegister(MACREGISTER.HST_INV_CFG, ref registerValue);
registerValue &= ~0x0000FFC0U; // reserver bit 0:5 ~ 16:31
// TBD - an optimization could be to only write back the register if
// the value changes
// Set the tag stop count and enabled flags and then write the register
// back
if ((flags & SelectFlags.SELECT) != 0)
{
registerValue |= (1 << 14);
}
if ((flags & SelectFlags.DISABLE_INVENTORY) != 0)
{
registerValue |= (1 << 15);
}
registerValue |= tagStopCount << 6;
MacWriteRegister(MACREGISTER.HST_INV_CFG, registerValue);
// Set the enabled flag in the HST_INV_EPC_MATCH_CFG register properly. To
// do so, have to read the register value first. Then set the bit properly
// and then write the register value back to the MAC.
MacReadRegister(MACREGISTER.HST_INV_EPC_MATCH_CFG, ref registerValue);
if ((flags & SelectFlags.POST_MATCH) != 0)
{
registerValue |= 0x01;
}
else
{
registerValue &= ~(uint)0x01;;
}
MacWriteRegister(MACREGISTER.HST_INV_EPC_MATCH_CFG, registerValue);
} // Radio::Start18K6CRequest
public int Start18K6CRead(uint bank, uint offset, uint count, UInt16[] data, uint accessPassword, uint retry, SelectFlags flags)
{
// Perform the common 18K6C tag operation setup
Start18K6CRequest(retry, flags);
Setup18K6CReadRegisters(bank, offset, count);
// Set up the access password register
MacWriteRegister(MACREGISTER.HST_TAGACC_ACCPWD, accessPassword);
// Issue the read command
_deviceHandler.SendAsync(0, 0, DOWNLINKCMD.RFIDCMD, PacketData(0xf000, (UInt32)HST_CMD.READ), (UInt32)SENDREMARK.INVENTORY);
return(0);
} // Start18K6CRead
public SelectStatement ParseSelect(string input, int offset, Context context, SelectFlags flags, SelectStatement parent)
{
int originalOffset = offset;
var statement = new SelectStatement();
if (parent != null)
{
statement.Parent = parent;
}
statement.UsedFlags = flags;
Token next = NextToken(input, offset);
if (next.Kind != TokenKind.Keyword || next.KeywordValue != Keyword.Select)
{
throw new Exception("Failed initial check");
}
offset += next.InputLength;
var exprFlags = new ExpressionFlags {
GeneralWildcardAllowed = true, IdentifierAllowed = true, WildcardAllowed = true, SingleValueSubSelectAllowed = true
};
do
{
next = NextToken(input, offset);
if (next.Kind == TokenKind.Keyword && next.KeywordValue == Keyword.From)
{
offset += next.InputLength;
break;
}
else if (next.Kind == TokenKind.None)
{
throw new Exception("Unexpected end of input");
}
else if (next.Kind == TokenKind.Comma)
{
offset += next.InputLength;
}
var expr = ParseExpression(input, offset, context, statement, exprFlags, false, false);
if (statement.OutputColumns.Count > 0 && expr.IsWildcard() && !expr.IsOnlyReference())
{
throw new Exception("Unexpected token *");
}
statement.OutputColumns.Add(expr);
offset += expr.FullText.Length;
// Disallow general wildflags after first column
exprFlags.GeneralWildcardAllowed = false;
} while (true);
var source = ParseReference(input, offset, context, statement, new ReferenceFlags()
{
TableOnly = true
});
statement.MainSource = source;
offset += source.InputLength;
// If we have a parent, they're going to resolve our references for us
if (parent == null)
{
ResolveSelectReferences(statement, context);
}
// Prepare flags for WHERE and ORDER BY expressions
exprFlags.GeneralWildcardAllowed = false;
exprFlags.WildcardAllowed = false;
exprFlags.IdentifierAllowed = false;
do
{
next = NextToken(input, offset);
offset += next.InputLength;
if (next.Kind == TokenKind.Keyword)
{
if (next.KeywordValue == Keyword.Where)
{
if (statement.FilterConditions != null)
{
throw new Exception("Unexpected WHERE when filter has already been set");
}
statement.FilterConditions = ParseExpression(input, offset, context, statement, exprFlags, parent == null, false);
offset += statement.FilterConditions.FullText.Length;
}
else if (next.KeywordValue == Keyword.Order)
{
next = NextToken(input, offset);
if (next.Kind != TokenKind.Keyword || next.KeywordValue != Keyword.By)
{
throw new Exception("Unexpected token after ORDER");
}
offset += next.InputLength;
bool firstOrder = true;
while (true)
{
next = NextToken(input, offset);
if (next.Kind == TokenKind.Comma)
{
if (!firstOrder)
{
offset += next.InputLength;
}
else
{
throw new Exception("Order by clause cannot start with a comma");
}
}
else if (next.Kind == TokenKind.Operator && next.OperatorValue == Operator.ParenthesisRight)
{
if (flags.StopOnUnmatchedParenthesis)
{
offset += next.InputLength;
break;
}
else
{
throw new Exception("Missing left parenthesis");
}
}
else if (next.Kind == TokenKind.Keyword || next.Kind == TokenKind.None)
{
break;
}
firstOrder = false;
var ordering = new Ordering
{
OrderExpression = ParseExpression(input, offset, context, statement, exprFlags, parent == null, false)
};
offset += ordering.OrderExpression.FullText.Length;
next = NextToken(input, offset);
if (next.Kind == TokenKind.Keyword && (next.KeywordValue == Keyword.Asc || next.KeywordValue == Keyword.Desc))
{
ordering.Kind = next.KeywordValue == Keyword.Asc ? OrderingKind.Ascending : OrderingKind.Descending;
offset += next.InputLength;
}
statement.OutputOrder.Add(ordering);
}
}
}
else if (next.Kind == TokenKind.Operator && next.OperatorValue == Operator.ParenthesisRight)
{
if (!flags.StopOnUnmatchedParenthesis)
{
offset += next.InputLength;
break;
}
else
{
throw new Exception("Missing left parenthesis");
}
}
else if (next.Kind != TokenKind.None)
{
throw new Exception($"Unexpected token in query at offset {offset}");
}
} while (next.Kind != TokenKind.None && next.Kind != TokenKind.SemiColon);
offset = Math.Min(input.Length, offset);
statement.OriginalText = input[originalOffset..offset];
