public void NotFail()
{
NumberToken command = new NumberToken();
var result = command.Process(new InputStack());
Assert.Null(result);
}
public void EqualsNullTest()
{
var token = new NumberToken(1.1);
Assert.False(token.Equals(null));
Assert.NotEqual(null, token);
}
public IToken Combine(IToken other)
{
if (other is NumberToken)
{
NumberToken otherNumber = other as NumberToken;
if (HasDot && otherNumber.HasDot)
{
return(new ErrorToken(Text + other.Text, "number can not have more than 1 dot"));
}
else
{
return(new NumberToken(Text + otherNumber.Text, HasDot || otherNumber.HasDot));
}
}
else if (other is DotToken)
{
if (HasDot)
{
return(new ErrorToken(Text + other.Text, "number can not have more than 1 dot"));
}
else
{
return(new NumberToken(Text + other.Text, true));
}
}
else
{
return(null);
}
}
private static IToken Resolve(LexerContext context)
{
if (CommentToken.IsCommentBegin(context))
{
return(ResolveComment(context));
}
else if (NumberToken.IsNumberBegin(context))
{
return(ResolveNumber(context));
}
else if (StringToken.IsStringBegin(context))
{
return(ResolveString(context));
}
else if (SpecialSymbolToken.IsSpecial(context))
{
return(ResolveSpecial(context));
}
else if (IdentifierToken.IsIdentifierBegin(context))
{
return(ResolveIdentifier(context));
}
else
{
throw new SyntaxErrorException();
}
}
public int Write(Placeholder location, string token, long size)
{
NumberToken lt = Sym(token, location, 16, 0, 0);
lt.SetValue(size);
return(entryCount - 1);
}
public void Visit(NumberToken numberToken)
{
mCurrent = new Constant {
Value = numberToken.Value
};
HandleNonParenthesesAndOperation();
}
public void EqualsDiffTypeTest()
{
var token = new NumberToken(1.1);
Assert.False(token.Equals(1));
Assert.NotEqual((object)1, token);
}
/**
* Evalutes all dice operators in the Token sequence.
*
* tokens - the token sequence that whose dice operators will be evaluated
*/
private void EvaluateBinaryOperator <T>(List <Token> tokens)
{
for (int i = 0; i < tokens.Count;)
{
Token token = tokens[i];
if (token.GetTokenType() == Token.Type.BINARY_OPERATOR)
{
if (token is T)
{
BinaryOperatorToken op = (BinaryOperatorToken)token;
int operand1Index = i - 1;
int operand2Index = i + 1;
NumberToken operand1 = (NumberToken)tokens[operand1Index];
NumberToken operand2 = (NumberToken)tokens[operand2Index];
tokens[operand1Index] = new NumberToken(op.Execute(operand1.Number, operand2.Number));
tokens.RemoveAt(operand2Index);
tokens.RemoveAt(i);
}
else
{
++i;
}
}
else
{
++i;
}
}
}
/**
* Evalutes the specified token sequence.
*
* tokens - the token sequence that whose dice operators will be evaluated
*/
public double Evaluate(List <Token> tokens)
{
RemoveEndOfEquationTokens(tokens);
EvaluateBinaryOperator <DiceOperatorToken>(tokens);
EvaluateBinaryOperator <MultiplicationOperatorToken>(tokens);
EvaluateBinaryOperator <DivisonOperatorToken>(tokens);
EvaluateBinaryOperator <AdditionOperatorToken>(tokens);
EvaluateBinaryOperator <SubtractionOperatorToken>(tokens);
if (tokens.Count == 1)
{
if (tokens[0].GetTokenType() == Token.Type.OPERAND)
{
if (tokens[0] is NumberToken)
{
NumberToken number = (NumberToken)tokens[0];
return(number.Number);
}
else
{
throw new EquationParsingException("Final token is not of a number");
}
}
else
{
throw new EquationParsingException("Final token is not an operand");
}
}
else
{
throw new EquationParsingException("Equation had more then one token after parsing");
}
}
public Boolean AllowLiteral(out LiteralToken literal)
{
var current = m_enumerator.Current;
switch (current.Type)
{
case ParseEventType.Null:
literal = new NullToken(m_fileId, current.Line, current.Column);
m_enumerator.MoveNext();
return(true);
case ParseEventType.Boolean:
literal = new BooleanToken(m_fileId, current.Line, current.Column, (Boolean)current.Value);
m_enumerator.MoveNext();
return(true);
case ParseEventType.Number:
literal = new NumberToken(m_fileId, current.Line, current.Column, (Double)current.Value);
m_enumerator.MoveNext();
return(true);
case ParseEventType.String:
literal = new StringToken(m_fileId, current.Line, current.Column, (String)current.Value);
m_enumerator.MoveNext();
return(true);
}
literal = null;
return(false);
}
private NumberToken Sym(string name, Placeholder location, byte info, byte other, short shndx)
{
output.WriteInt32(dynstr.Get(name));
if (output.Is64Bit)
{
output.WriteByte(info);
output.WriteByte(other);
output.WriteInt16(shndx);
}
if (location.IsNull)
{
output.WriteNumber(0);
}
else
{
output.WritePlaceholder(location);
}
NumberToken result = output.InsertNumberToken();
if (!output.Is64Bit)
{
output.WriteByte(info);
output.WriteByte(other);
output.WriteInt16(shndx);
}
hash[name] = entryCount;
entryCount++;
return(result);
}
public void EqualsSameObjectTest()
{
var token = new NumberToken(1.1);
Assert.True(token.Equals(token));
Assert.Equal(token, token);
}
public static bool IsLeadingZeroOmitted(NumberToken numberToken)
{
var numberText = numberToken.Text;
return(numberToken.HasSign
? numberToken.Text[1].ToString().Equals(numberToken.DecimalSeparator)
: numberText[0].ToString().Equals(numberToken.DecimalSeparator));
}
public void SignPrecedence()
{
var eq = new ImageFramework.Model.Equation.Equation("-1+2");
var hlsl = eq.GetHlslExpression();
var expected = $"(({NumberToken.ToHlsl(-1.0f)}*{NumberToken.ToHlsl(1.0f)})+{NumberToken.ToHlsl(2.0f)})";
Assert.AreEqual(expected, hlsl.Replace(" ", ""));
}
public void EqualsDiffVarTest()
{
var token1 = new NumberToken(1.1);
var token2 = new NumberToken(1.14);
Assert.False(token1.Equals(token2));
Assert.NotEqual(token1, token2);
}
public void SignOperatorAndBrackets()
{
var eq = new ImageFramework.Model.Equation.Equation("1+0.4*-2");
var hlsl = eq.GetHlslExpression();
var expected =
$"({NumberToken.ToHlsl(1.0f)}+({NumberToken.ToHlsl(0.4f)}*({NumberToken.ToHlsl(-1.0f)}*{NumberToken.ToHlsl(2.0f)})))";
Assert.AreEqual(expected, hlsl.Replace(" ", ""));
}
public void GivenTokenConverter_WhenHasRankOrHigherWithFiat_ThenFail()
{
var numberToken = new NumberToken("4");
var currencyToken = new CurrencyToken("EUR", "EUR", CurrencyType.Fiat);
var tokenConverter = CreateTokenConverter();
var result = tokenConverter.HasRankOrHigher(numberToken, currencyToken);
Assert.Fail();
}
public NumberExpr(NumberToken token, IEnv env)
: base(env)
{
if (token == null)
{
throw new ArgumentNullException(nameof(token));
}
base.Token = token;
}
public DynamicSymbols(Sections sections, StringTable dynstr)
{
this.dynstr = dynstr;
dynsym = sections.GetSection(".dynsym");
output = dynsym.AllocateRegion();
hashRegion = sections.GetSection(".hash").AllocateRegion();
NumberToken s = Sym("", Placeholder.Null, 0, 0, 0);
s.SetValue(0);
}
static Token MakeNumber(Scanner scanner)
{
NumberToken token = scanner.NumberBuilder.GetToken();
scanner.Position--;
scanner.NumberBuilder = null;
token.Line = scanner.Line;
token.Column = scanner.Column - token.Word.Length;
return(token);
}
public void ReturnNumberWithDigitInput(string text, int expectedResultValue)
{
NumberToken command = new NumberToken();
var stack = new InputStack(text);
var result = command.Process(stack);
Assert.NotNull(result);
Assert.Equal(expectedResultValue, result.Value);
Assert.Equal(0, result.Score);
}
public void NumberTokenCtor()
{
string value = "1";
int position = 22;
string tokenValue = $@"[number:{position}]";
NumberToken token = new NumberToken(position, value);
Assert.AreEqual(tokenValue, token.TokenValue);
Assert.AreEqual(value, token.Value);
Assert.AreEqual(position, token.Position);
}
private bool numberReader(InputStream str, out Token outtok)
{
Match match = numberRegex.Match(str.InputString);
if (match.Success)
{
outtok = new NumberToken(match.Value.Replace(" ", ""), str.Position);
str.MoveForward(match.Length);
return(true);
}
outtok = null;
return(false);
}
public static string Normalize(this NumberToken numberToken)
{
var normalized = "";
var beforeDecimal = true;
var previousWasSign = false;
foreach (var part in numberToken.NumberParts)
{
switch (part.Type)
{
case NumberPart.NumberType.Number:
var number = part.Value;
if (beforeDecimal && numberToken.NumberParts.All(p => p.Type != NumberPart.NumberType.GroupSeparator))
{
number = GetNumberWithThousandSeparatorsAdded(part.Value);
}
normalized += number;
break;
case NumberPart.NumberType.DecimalSeparator:
normalized += "d";
beforeDecimal = false;
break;
case NumberPart.NumberType.GroupSeparator:
if (!previousWasSign)
{
normalized += "t";
}
break;
case NumberPart.NumberType.Sign:
normalized += part.Value == "+" ? "p" : "n";
previousWasSign = true;
break;
}
if (part.Type != NumberPart.NumberType.Sign && previousWasSign)
{
previousWasSign = false;
}
}
if (IsLeadingZeroOmitted(numberToken))
{
normalized = normalized.AddLeadingZero(numberToken.HasSign);
}
return(normalized);
}
protected override Core.Tokenization.Token CreateToken(string s,
System.Text.RegularExpressions.GroupCollection groups)
{
string decimalPart = groups["sdec"].Value;
if (String.IsNullOrEmpty(decimalPart))
{
decimalPart = groups["gdec"].Value;
}
NumberToken value = new NumberToken(s,
groups["sign"].Value, decimalPart, groups["frac"].Value, _NumberFormat);
return(value);
}
public Importer(Sections sections)
{
relapltRegion = sections.GetSection(".rela.plt").AllocateRegion();
relocator = new Relocator(relapltRegion);
mainRegion = sections.GetSection(".dynamic").AllocateRegion();
dynstrRegion = sections.GetSection(".dynstr").AllocateRegion();
dynstr = new StringTable();
plt = sections.GetSection(".plt").AllocateRegion();
pltgot = sections.GetSection(".got.plt").AllocateRegion();
dynsym = new DynamicSymbols(sections, dynstr);
dynamicTokenSize = dynsym.Write(mainRegion.CurrentLocation, "_DYNAMIC");
mainRegion.WriteNumber(3); // dt_pltgot
mainRegion.WritePlaceholder(pltgot.BaseLocation);
mainRegion.WriteNumber(4); // dt_hash
mainRegion.WritePlaceholder(dynsym.HashRegion.BaseLocation);
mainRegion.WriteNumber(5); // dt_strtab
mainRegion.WritePlaceholder(dynstrRegion.BaseLocation);
mainRegion.WriteNumber(6); // dt_symtab
mainRegion.WritePlaceholder(dynsym.SymbolRegion.BaseLocation);
mainRegion.WriteNumber(11); // dt_syment
mainRegion.WriteNumber(dynsym.ElementSize);
// mainRegion.WriteNumber(15); // dt_rpath
// mainRegion.WriteNumber(dynstr.Get(".:/lib64:/lib"));
plt0 = plt.CurrentLocation;
pltgot.WriteNumber(0);
if (plt.Is64Bit)
{
plt.Write(new byte[] { 0xff, 0x35 }); // push [rip+imm32]
plt.WritePlaceholderDisplacement32(pltgot.CurrentLocation);
pltgot.WriteNumber(0);
plt.Write(new byte[] { 0xff, 0x25 }); // jmp [rip+imm32]
plt.WritePlaceholderDisplacement32(pltgot.CurrentLocation);
pltgot.WriteNumber(0);
}
else
{
plt.WriteByte(0x68); // push IMM32
plt.WritePlaceholder(pltgot.CurrentLocation);
pltgot.WriteNumber(0);
plt.Write(new byte[] { 0xff, 0x25 }); // jmp [imm32]
plt.WritePlaceholder(pltgot.CurrentLocation);
pltgot.WriteNumber(0);
}
plt.Align(16, 0x90); // nop
}
protected T Visit(IToken token, T state = default)
{
return(token switch
{
AddToken addToken => Visit(addToken, state),
SubtractToken subtractToken => Visit(subtractToken, state),
MultiplyToken multiplyToken => Visit(multiplyToken, state),
DivideToken divideToken => Visit(divideToken, state),
NegateToken negateToken => Visit(negateToken, state),
NumberToken numberToken => Visit(numberToken, state),
FactorialToken factorialToken => Visit(factorialToken, state),
PowerToken powerToken => Visit(powerToken, state),
VariableToken variableToken => Visit(variableToken, state),
AssignmentToken assignmentToken => Visit(assignmentToken, state),
_ => throw new ArgumentOutOfRangeException(nameof(token))
});
/// <summary>
/// Parse number value from <param name="text"/>
/// Convention: [ws] [$] [sign][integral-digits,]integral-digits[.[fractional-digits]][E[sign]exponential-digits][ws]
/// </summary>
/// <param name="text"></param>
/// <param name="omitLeadingZero"></param>
/// <returns>Returns a list of <see cref="NumberToken">NumberToken</see></returns>
public NumberToken Parse(string text, bool?omitLeadingZero = null)
{
var originalText = text;
if (string.IsNullOrEmpty(text))
{
return(null);
}
// parse out the currency symbol
// [ws] [$]
var currencyParts = GetCurrencyParts(text);
if (currencyParts != null)
{
var value = currencyParts.Aggregate(string.Empty, (current, numberPart) => current + numberPart.Value);
text = text.Substring(value.Length);
}
// parse out the sign
// [sign]
var signParts = GetSignParts(text);
if (signParts != null)
{
var value = signParts.Aggregate(string.Empty, (current, numberPart) => current + numberPart.Value);
text = text.Substring(value.Length);
}
// parse out the exponents
//[E[sign]exponential-digits]
var exponentialPart = GetExponentialPart(text);
if (exponentialPart != null)
{
text = text.Substring(0, text.Length - exponentialPart.Value.Length);
}
// [integral-digits,]integral-digits[.[fractional-digits]]
var integralAndFractionalParts = GetIntegralAndFractionalParts(text);
// combine the individual number parts
var numberParts = CombineParts(currencyParts, signParts, integralAndFractionalParts, exponentialPart);
var numberToken = new NumberToken(originalText, numberParts, omitLeadingZero);
return(numberToken);
}
public void ReturnMultipleResultsNumberWithDigitInput(string text, params int[] expectedResultValues)
{
NumberToken command = new NumberToken();
var stack = new InputStack(text);
Assert.Equal(expectedResultValues.Length, stack.Count);
for (int i = 0; i < stack.Count; i++)
{
var result = command.Process(stack);
stack.Pop();
Assert.NotNull(result);
Assert.Equal(expectedResultValues[i], result.Value);
Assert.Equal(0, result.Score);
}
}
public void OperatorPrecedence()
{
var eq = new ImageFramework.Model.Equation.Equation("(3-1)*0.4+1");
var hlsl = eq.GetHlslExpression();
var expected =
$"((({NumberToken.ToHlsl(3.0f)}-{NumberToken.ToHlsl(1.0f)})*{NumberToken.ToHlsl(0.4f)})+{NumberToken.ToHlsl(1.0f)})";
Assert.AreEqual(expected, hlsl.Replace(" ", ""));
eq = new ImageFramework.Model.Equation.Equation("1+0.4*(3-1)");
hlsl = eq.GetHlslExpression();
expected =
$"({NumberToken.ToHlsl(1.0f)}+({NumberToken.ToHlsl(0.4f)}*({NumberToken.ToHlsl(3.0f)}-{NumberToken.ToHlsl(1.0f)})))";
Assert.AreEqual(expected, hlsl.Replace(" ", ""));
}
private static Token[] GetInfixTokens(string term)
{
//Leerzeichen entfernen und in Kleinbuchstaben konvertieren
term = term.Replace(" ", string.Empty).ToLowerInvariant();
var tokens = new List<Token>();
//mit RegEx alle Zahlen aussortieren
var numbers = parserRegEx.Matches(term);
term = parserRegEx.Replace(term, "1");
var sb = new StringBuilder(term);
//Term in Tokens teilen
var numberIndex = 0;
while (sb.Length > 0)
{
var validToken = false;
//Zahlen prüfen
if (sb.StartsWith("1"))
{
var t = new NumberToken();
t.ParseFromString(numbers[numberIndex].Groups["number"].Value);
tokens.Add(t);
numberIndex++;
//term = ReduceString(term, 1);
sb.Remove(0, 1);
validToken = true;
}
//Operatoren prüfen
if (!validToken)
for (int i = 0; i < operators.Length; i++)
{
var token = operators[i];
if (sb.StartsWith(token))
{
var t = new OperatorToken();
if ((token == '+' || token == '-') && (tokens.Count == 0 || tokens.Last().GetName() == "(")) //Vorzeichen
{
if (token == '-')
t.ParseFromString("!");
}
else
t.ParseFromString(token.ToString());
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
validToken = true;
break;
}
}
//Funktionen prüfen
if (!validToken)
for (int i = 0; i < functions.Length; i++)
{
var token = functions[i];
if (sb.StartsWith(token))
{
var t = new FunctionToken();
t.ParseFromString(token);
tokens.Add(t);
//term = ReduceString(term, token.Length);
sb.Remove(0, token.Length);
validToken = true;
break;
}
}
//Rest prüfen
if (!validToken)
{
if (sb.StartsWith("pi")) //Pi
{
var t = new NumberToken();
t.ParseFromString(System.Math.PI.ToString());
tokens.Add(t);
//term = ReduceString(term, 2);
sb.Remove(0, 2);
}
else if (sb.StartsWith("e")) //e
{
var t = new NumberToken();
t.ParseFromString(System.Math.E.ToString());
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith("(")) //öffnende Klammer
{
var t = new SpecialToken();
t.ParseFromString("(");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith(")")) //schließende Klammer
{
var t = new SpecialToken();
t.ParseFromString(")");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else if (sb.StartsWith(";")) //Argumenttrennzeichen
{
var t = new SpecialToken();
t.ParseFromString(";");
tokens.Add(t);
//term = ReduceString(term, 1);
sb.Remove(0, 1);
}
else //Token nicht bekannt
throw new ArgumentException("Dieser Term enthält einen ungültigen Token.");
}
}
return tokens.ToArray();
}