public override bool ExpectIt(ref IWordWalker ww, object currentSingaRule = null)
{
if (currentSingaRule is null)
{
throw new ArgumentNullException();
}
List <string> sigNames = new List <string>();
var andExpector = new CExactWordExpector("&&");
var existingSigNameExpector = new CExistingSigNameExpector();
var spaceSkipper = new CWhiteSpaceSkipper();
do
{
if (!existingSigNameExpector.ExpectIt(ref ww, currentSingaRule))
{
error = existingSigNameExpector.error;
return(false);
}
sigNames.Add(existingSigNameExpector.result);
spaceSkipper.ExpectIt(ref ww);
} while (andExpector.ExpectIt(ref ww) && spaceSkipper.ExpectIt(ref ww));
result = new CAndExpression();
result.Expressions = sigNames.Select(x => new CStateExpression(((SingaRule)currentSingaRule).sigs[x])).ToList <ISingaExpression>();
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
//if (!ExpectString(ref ww))
//{
// return false;
//}
StringBuilder resultName = new StringBuilder("");
CLetterExpector letterExpector = new CLetterExpector();
if (!letterExpector.ExpectIt(ref ww))
{
error = letterExpector.error;
return(false);
}
resultName.Append(letterExpector.result);
CCharExpector charExpector = new CCharExpector();
while (charExpector.ExpectIt(ref ww))
{
resultName.Append(charExpector.result);
}
result = resultName.ToString();
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
var headExpector = new CExactWordExpector("str(\"");
if (!headExpector.ExpectIt(ref ww))
{
error = headExpector.error;
return(false);
}
StringBuilder stringSig = new StringBuilder();
var characterExpector = new CCharExpector();
while (characterExpector.ExpectIt(ref ww))
{
stringSig.Append(characterExpector.result);
}
var tailExpector = new CExactWordExpector("\");");
if (!tailExpector.ExpectIt(ref ww))
{
error = tailExpector.error;
return(false);
}
result = Encoding.UTF8.GetBytes(stringSig.ToString());
return(true);
}
public bool ExpectItLockable(ref IWordWalker ww, object additionalParam = null)
{
ww.LockLockableMoves = true;
bool result = ExpectIt(ref ww, additionalParam);
ww.LockLockableMoves = false;
return(result);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
result = new SingaState();
var sigNameExpector = new CNameExpector();
if (!sigNameExpector.ExpectIt(ref ww))
{
error = sigNameExpector.error;
return(false);
}
result.Name = sigNameExpector.result;
var colonExpector = new CExactWordExpector(":");
if (!colonExpector.ExpectIt(ref ww) || !colonExpector.HasNoErrors())
{
error = colonExpector.error;
return(false);
}
new CWhiteSpaceSkipper().ExpectIt(ref ww);
ww.LockLockableMoves = true;
if (new CExactWordExpector("str").ExpectIt(ref ww))
{
ww.LockLockableMoves = false;
var stringSigExpector = new CStringSignatureExpector();
if (!stringSigExpector.ExpectIt(ref ww))
{
error = stringSigExpector.error;
return(false);
}
result.Signature = stringSigExpector.result;
}
else if (new CExactWordExpector("hex").ExpectIt(ref ww))
{
ww.LockLockableMoves = false;
var hexSigExpector = new CHexSignatureExpector();
if (!hexSigExpector.ExpectIt(ref ww))
{
error = hexSigExpector.error;
return(false);
}
result.Signature = hexSigExpector.result;
}
else
{
ww.LockLockableMoves = false;
error = BuildExpectedError(string.Join("`, `", "str", "hex"), ww.GetConcatedNWords(3).GetValue());
return(false);
}
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
SingaWord currentWord = ww.GetCurrentWord();
if (!currentWord.IsEof())
{
error = BuildExpectedError(currentWord.GetValue());
return(false);
}
return(true);
}
protected bool ExpectString(ref IWordWalker ww)
{
var currentWord = ww.GetCurrentWord();
if (currentWord.IsEof())
{
error = BuildExpectedError("EOF");
return(false);
}
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
var currentWord = ww.GetCurrentWord();
while (currentWord.IsEof() == false &&
Regex.IsMatch(currentWord.GetValue(), _rePattern)
)
{
ww.Move();
currentWord = ww.GetCurrentWord();
}
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
var headExpector = new CExactWordExpector("hex(");
if (!headExpector.ExpectIt(ref ww))
{
error = headExpector.error;
return(false);
}
List <string> stringBytes = new List <string>();
var hexDigitExpector = new CHexDigitExpector();
var spaceSkipper = new CWhiteSpaceSkipper();
var closedBracketExpector = new CExactWordExpector(")");
while (!closedBracketExpector.ExpectItLockable(ref ww))
{
spaceSkipper.ExpectIt(ref ww);
var currentByte = "";
for (int i = 0; i < 2; i++)
{
if (!hexDigitExpector.ExpectIt(ref ww))
{
error = hexDigitExpector.error;
return(false);
}
currentByte += hexDigitExpector.result;
}
stringBytes.Add(currentByte);
spaceSkipper.ExpectIt(ref ww);
}
var tailExpector = new CExactWordExpector(");");
if (!tailExpector.ExpectIt(ref ww))
{
error = tailExpector.error;
return(false);
}
result = stringBytes.Select(x => Convert.ToByte(x, 16)).ToArray();
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object currentSingaRule = null)
{
if (currentSingaRule is null)
{
throw new ArgumentNullException();
}
if (!base.ExpectIt(ref ww))
{
return(false);
}
if (!((SingaRule)currentSingaRule).sigs.ContainsKey(result))
{
error = BuildExpectedError(Localization.ExistingSignatureName.ToLower(), result);
return(false);
}
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
if (!ExpectString(ref ww))
{
return(false);
}
string expectedLongWord = ExpectedWords.First().GetValue();
string currentWordValue = ww.GetConcatedNWords(expectedLongWord.Length).GetValue();
if (!currentWordValue.Equals(expectedLongWord))
{
error = BuildExpectedError(currentWordValue);
return(false);
}
result = currentWordValue;
ww.LockableMove(expectedLongWord.Length);
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
if (!ExpectString(ref ww))
{
return(false);
}
var currentWordValue = ww.GetCurrentWord().GetValue();
foreach (var w in ExpectedWords)
{
if (currentWordValue.Equals(w.GetValue()))
{
result = currentWordValue;
ww.LockableMove();
return(true);
}
}
error = BuildExpectedError(currentWordValue);
return(false);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
List <SingaState> metaSigs = new List <SingaState>();
var sigExpector = new CSingleSigExpector();
var spaceSkipper = new CWhiteSpaceSkipper();
var closedBraceExpector = new CExactWordExpector("}");
while (!closedBraceExpector.ExpectItLockable(ref ww))
{
if (!sigExpector.ExpectIt(ref ww))
{
error = sigExpector.error;
return(false);
}
metaSigs.Add(sigExpector.result);
spaceSkipper.ExpectIt(ref ww);
}
result = metaSigs;
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object currentSingaRule = null)
{
if (currentSingaRule is null)
{
throw new ArgumentNullException();
}
result = new COrExpression();
var orExpector = new CExactWordExpector("||");
var andsExpector = new CAndsExpector();
var spaceSkipper = new CWhiteSpaceSkipper();
do
{
if (!andsExpector.ExpectIt(ref ww, currentSingaRule))
{
error = andsExpector.error;
return(false);
}
result.Expressions.Add(andsExpector.result);
spaceSkipper.ExpectIt(ref ww);
} while (orExpector.ExpectIt(ref ww) && spaceSkipper.ExpectIt(ref ww));
spaceSkipper.ExpectIt(ref ww);
var semicolonExpector = new CExactWordExpector(";");
if (!semicolonExpector.ExpectIt(ref ww))
{
error = semicolonExpector.error;
return(false);
}
return(true);
}
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
if (additionalParam is null)
{
throw new ArgumentNullException();
}
result = (SingaRule)additionalParam;
var metaStringExpector = new CExactWordExpector("meta");
if (!metaStringExpector.ExpectIt(ref ww))
{
error = metaStringExpector.error;
return(false);
}
var spaceSkipper = new CWhiteSpaceSkipper();
spaceSkipper.ExpectIt(ref ww);
var openBraceExpector = new CExactWordExpector("{");
if (!openBraceExpector.ExpectIt(ref ww))
{
error = openBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var metaExpector = new CMetaExpector();
if (!metaExpector.ExpectIt(ref ww))
{
error = metaExpector.error;
return(false);
}
result.meta = metaExpector.result.ToDictionary(x => x.Name, x => (SingaSig)x);
spaceSkipper.ExpectIt(ref ww);
var closeBraceExpector = new CExactWordExpector("}");
if (!closeBraceExpector.ExpectIt(ref ww))
{
error = closeBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var sigsStringExpector = new CExactWordExpector("sigs");
if (!sigsStringExpector.ExpectIt(ref ww))
{
error = sigsStringExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
if (!openBraceExpector.ExpectIt(ref ww))
{
error = openBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var sigsExpector = new CSigsExpector();
if (!sigsExpector.ExpectIt(ref ww))
{
error = sigsExpector.error;
return(false);
}
result.sigs = sigsExpector.result.ToDictionary(x => x.Name, x => x);
spaceSkipper.ExpectIt(ref ww);
if (!closeBraceExpector.ExpectIt(ref ww))
{
error = closeBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var condStringExpector = new CExactWordExpector("cond");
if (!condStringExpector.ExpectIt(ref ww))
{
error = condStringExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
if (!openBraceExpector.ExpectIt(ref ww))
{
error = openBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var conditionExpector = new CConditionExpector();
if (!conditionExpector.ExpectIt(ref ww, result))
{
error = conditionExpector.error;
return(false);
}
result.condition = conditionExpector.result;
spaceSkipper.ExpectIt(ref ww);
if (!closeBraceExpector.ExpectIt(ref ww))
{
error = closeBraceExpector.error;
return(false);
}
return(true);
}
// times = -1 means infinity abstract public bool ExpectIt(ref IWordWalker ww, object additionalParam = null);
public override bool ExpectIt(ref IWordWalker ww, object additionalParam = null)
{
result = new SingaRule();
var spaceSkipper = new CWhiteSpaceSkipper();
spaceSkipper.ExpectIt(ref ww);
var rExpector = new CExactWordExpector("r");
if (!rExpector.ExpectIt(ref ww))
{
error = rExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var genericNameExpector = new CNameExpector();
if (!genericNameExpector.ExpectIt(ref ww))
{
error = genericNameExpector.error;
return(false);
}
result.name = genericNameExpector.result.ToString();
spaceSkipper.ExpectIt(ref ww);
var openBraceExpector = new CExactWordExpector("{");
if (!openBraceExpector.ExpectIt(ref ww))
{
error = openBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var ruleExpector = new CRuleExpector();
if (!ruleExpector.ExpectIt(ref ww, result))
{
error = ruleExpector.error;
return(false);
}
result = ruleExpector.result;
spaceSkipper.ExpectIt(ref ww);
var closeBraceExpector = new CExactWordExpector("}");
if (!closeBraceExpector.ExpectIt(ref ww))
{
error = closeBraceExpector.error;
return(false);
}
spaceSkipper.ExpectIt(ref ww);
var eofExpector = new CEOFExpector();
if (!eofExpector.ExpectIt(ref ww))
{
error = closeBraceExpector.error;
return(false);
}
return(true);
}
