public override void Get(IInputBuffer buffer)
{
char ch; // current character
StringBuilder tokenBuilder = new StringBuilder();
tokenBuilder.Append('\''); // opening quote
//--Get the string.
ch = buffer.GetChar(); // first char after opening quote
while (ch != 0x7f)
{
if (ch == '\'')
{ // look for another quote
//--Fetched a quote. Now check for an adjacent quote,
//--since two consecutive quotes represent a single
//--quote in the string.
ch = buffer.GetChar();
if (ch != '\'') break; // not another quote, so previous
// quote ended the string
}
//--Replace the end of line character with a blank.
else if (ch == '\0') ch = ' ';
//--Append current char to string, then get the next char.
tokenBuilder.Append(ch);
ch = buffer.GetChar();
}
tokenBuilder.Append('\''); // closing quote
tokenString = tokenBuilder.ToString();
code = TTokenCode.String;
}
public override void InitializeImpl()
{
_inputBuffer = new InputBuffer();
_controller = new MenuController();
_name = Factories.RFactory.CreateMenuItem(Name);
_race = Factories.RFactory.CreateMenuItem(Race);
_archeType = Factories.RFactory.CreateMenuItem(ArcheType);
_skillSet = Factories.RFactory.CreateMenuItem(SkillSet);
_signatureSpell = Factories.RFactory.CreateMenuItem(SignatureSpell);
_normalAttack = Factories.RFactory.CreateMenuItem(NormalAttack);
_FIR = Factories.RFactory.CreateMenuItem(FIR);
_WAT = Factories.RFactory.CreateMenuItem(WAT);
_ICE = Factories.RFactory.CreateMenuItem(ICE);
_ARC = Factories.RFactory.CreateMenuItem(ARC);
_WND = Factories.RFactory.CreateMenuItem(WND);
_HOL = Factories.RFactory.CreateMenuItem(HOL);
_DRK = Factories.RFactory.CreateMenuItem(DRK);
_GRN = Factories.RFactory.CreateMenuItem(GRN);
_LGT = Factories.RFactory.CreateMenuItem(LGT);
_createChar = Factories.RFactory.CreateMenuItem(CreateChar, () =>
{
Model.Party.AddCharacter(Model.PreGameModel.Character);
Model.OverworldModel.GenerateNewMap(Model.PreGameModel.Character.CurrentLevel);
Master.Next();
});
_controller.NoInputUpdate(true);
}
public ScientificCalculator(
IInputBuffer buffer,
IOperatorLookup lookup,
IUnitConverter unitConverter,
IOperatorConverter operatorConverter,
IExpressionBuilder builder,
IExpressionParser parser,
IEvaluate evaluator,
IMemoryStorage memory
) : base(
buffer,
lookup,
unitConverter,
operatorConverter,
builder,
parser,
evaluator,
memory
)
{
}
public override void Get(IInputBuffer buffer)
{
StringBuilder tokenBuilder = new StringBuilder();
tokenBuilder.Append(buffer.CurrentChar);
tokenString = tokenBuilder.ToString();
buffer.GetChar();
code = TTokenCode.Error;
}
private void getIOBuffers(out IInputBuffer[] inputBuffers, out IOutputBuffer[] outputBuffers,
int numberOfBuffers)
{
inputBuffers = new IInputBuffer[numberOfBuffers];
outputBuffers = new IOutputBuffer[numberOfBuffers];
for (var i = 0; i < numberOfBuffers; i++)
{
inputBuffers[i] = Substitute.For <IInputBuffer>();
outputBuffers[i] = Substitute.For <IOutputBuffer>();
}
}
public TestConverterPanel(
IInputBuffer buffer,
IKeyChecker checker,
IFormatter formatter,
IUnitConverter converter,
IConverterDisplay display,
string[] units
) : base(buffer, checker, formatter, converter, display, units)
{
}
public override void Get(IInputBuffer buffer)
{
StringBuilder tokenBuilder = new StringBuilder();
char ch = buffer.CurrentChar; // char fetched from input
do
{
tokenBuilder.Append(ch);
ch = buffer.GetChar();
} while (characterMap[ch] == CharCode.Letter ||
characterMap[ch] == CharCode.Digit);
tokenString = tokenBuilder.ToString();
checkForReservedWord();
}
public T Parse(IInputBuffer buffer)
{
if (buffer.Length >= int.MaxValue / 2)
{
throw new ArgumentOutOfRangeException("Buffer must be <= 1GB in size.");
}
if (buffer.Length <= 2 * sizeof(uint))
{
throw new ArgumentException("Buffer is too small to be valid!");
}
buffer.SharedStringReader = this.settings?.SharedStringReaderFactory?.Invoke();
return(buffer.InvokeParse(this.innerSerializer, 0));
}
public StandardCalculator(
IInputBuffer buffer,
IOperatorLookup lookup,
IUnitConverter unitConverter,
IOperatorConverter operatorConverter,
IExpressionBuilder builder,
IExpressionParser parser,
IEvaluate evaluator,
IMemoryStorage memory
) : base(buffer)
{
Lookup = lookup;
UnitConverter = unitConverter;
OperatorConverter = operatorConverter;
Builder = builder;
Parser = parser;
Evaluator = evaluator;
Memory = memory;
}
public ConverterPanel(
IInputBuffer buffer,
IKeyChecker checker,
IFormatter formatter,
IUnitConverter converter,
IConverterDisplay display,
string[] units
)
{
InitializeComponent();
Buffer = buffer;
Checker = checker;
NumberFormatter = formatter;
UnitConverter = converter;
Helper = new UIHelper();
Units = units.ToArray();
SetupDisplay(display, units);
SetupKeypad();
}
public static bool CheckAssignmentTypeCompatible(DataType targetType, DataType valueType, IInputBuffer buffer)
{
//--Two identical types.
if (targetType.Code == valueType.Code) return true;
//--real := integer
if ((targetType.Code == TypeCode.Double || targetType.Code == TypeCode.Single)
&& IsIntegerType(valueType.Code))
{
return true;
}
// integer := real
if (IsIntegerType(targetType.Code)
&& (targetType.Code == TypeCode.Double || targetType.Code == TypeCode.Single))
{
return true;
}
return false;
}
public void Setup()
{
buffer = new InputBuffer();
lookup = new OperatorLookup();
unitConverter = new AngleConverter();
operatorConverter = new OperatorConverter(lookup.Operators, lookup.Unary);
parenthesizer = new Parenthesizer(lookup.Precedence);
builder = new ExpressionBuilder(parenthesizer);
parser = new ExpressionParser(operatorConverter);
evaluator = new Evaluator(unitConverter, operatorConverter, lookup);
memory = new MemoryStorage();
calculator = new ScientificCalculator(
buffer,
lookup,
unitConverter,
operatorConverter,
builder,
parser,
evaluator,
memory
);
}
public void getNextRecordValueFromSourceInputBuffer()
{
var goodRecord = new Record(new double[] { 1, 1, 1, });
var badRecord = new Record(new double[] { 0, 0, 0 });
var sourceInputBuffer = Substitute.For <IInputBuffer>();
sourceInputBuffer.GetNextRecord().Returns(goodRecord);
sourceInputBuffer.HasNext().Returns(true);
sourceInputBuffer.RemoveDummyRecord().Throws(new Exception("No dummy records should be removed here!"));
var sourceOutputBuffer = Substitute.For <IOutputBuffer>();
sourceOutputBuffer.LastAppendedRecord.Returns(goodRecord);
var tempInputBuffers = new IInputBuffer[4];
var tempOutputBuffers = new IOutputBuffer[4];
for (var i = 0; i < 3; i++)
{
tempInputBuffers[i] = Substitute.For <IInputBuffer>();
tempInputBuffers[i].GetNextRecord().Returns(badRecord);
tempInputBuffers[i].HasNext().Returns(true);
tempOutputBuffers[i] = Substitute.For <IOutputBuffer>();
tempOutputBuffers[i].LastAppendedRecord.Returns(badRecord);
}
tempInputBuffers[3] = sourceInputBuffer;
tempOutputBuffers[3] = sourceOutputBuffer;
var fileBufferIO = new DistributionBufferingIO(ref tempInputBuffers, ref tempOutputBuffers, 3);
var actualRecord = fileBufferIO.GetNextFromCurrentInputBuffer();
Assert.AreEqual(false, actualRecord.IsDummy);
Assert.AreEqual(goodRecord.Value, actualRecord.Value);
}
private void InputBufferTest(IInputBuffer ib)
{
var mem = new Memory <byte>(Input);
Assert.False(ib.ReadBool(0));
Assert.True(ib.ReadBool(1));
this.CompareEqual <byte>(sizeof(byte), i => mem.Span[i], i => ib.ReadByte(i));
this.CompareEqual <sbyte>(sizeof(sbyte), i => (sbyte)mem.Span[i], i => ib.ReadSByte(i));
this.CompareEqual <ushort>(sizeof(ushort), i => BinaryPrimitives.ReadUInt16LittleEndian(mem.Span.Slice(i)), i => ib.ReadUShort(i));
this.CompareEqual <short>(sizeof(short), i => BinaryPrimitives.ReadInt16LittleEndian(mem.Span.Slice(i)), i => ib.ReadShort(i));
this.CompareEqual <uint>(sizeof(uint), i => BinaryPrimitives.ReadUInt32LittleEndian(mem.Span.Slice(i)), i => ib.ReadUInt(i));
this.CompareEqual <int>(sizeof(int), i => BinaryPrimitives.ReadInt32LittleEndian(mem.Span.Slice(i)), i => ib.ReadInt(i));
#if NETCOREAPP2_1_OR_GREATER
this.CompareEqual <float>(sizeof(float), i => BitConverter.ToSingle(mem.Span.Slice(i)), i => ib.ReadFloat(i));
#endif
this.CompareEqual <ulong>(sizeof(ulong), i => BinaryPrimitives.ReadUInt64LittleEndian(mem.Span.Slice(i)), i => ib.ReadULong(i));
this.CompareEqual <long>(sizeof(long), i => BinaryPrimitives.ReadInt64LittleEndian(mem.Span.Slice(i)), i => ib.ReadLong(i));
this.CompareEqual <double>(sizeof(double), i => BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64LittleEndian(mem.Span.Slice(i))), i => ib.ReadDouble(i));
}
public override void Get(IInputBuffer buffer)
{
char ch = buffer.CurrentChar;
StringBuilder tokenBuilder = new StringBuilder();
tokenBuilder.Append(ch);
switch (ch)
{
case '^': code = TTokenCode.UpArrow; buffer.GetChar(); break;
case '*': code = TTokenCode.Star; buffer.GetChar(); break;
case '(': code = TTokenCode.LParen; buffer.GetChar(); break;
case ')': code = TTokenCode.RParen; buffer.GetChar(); break;
case '-': code = TTokenCode.Minus; buffer.GetChar(); break;
case '+': code = TTokenCode.Plus; buffer.GetChar(); break;
case '=': code = TTokenCode.Equal; buffer.GetChar(); break;
case '[': code = TTokenCode.LBracket; buffer.GetChar(); break;
case ']': code = TTokenCode.RBracket; buffer.GetChar(); break;
case ';': code = TTokenCode.Semicolon; buffer.GetChar(); break;
case ',': code = TTokenCode.Comma; buffer.GetChar(); break;
case '/': code = TTokenCode.Slash; buffer.GetChar(); break;
case ':': // : or :=
ch = buffer.GetChar();
if (ch == '=')
{
tokenBuilder.Append(ch);
code = TTokenCode.ColonEqual;
buffer.GetChar();
}
else
{
code = TTokenCode.Colon;
}
break;
case '<':
ch = buffer.GetChar(); // < or <= or <>
if (ch == '=')
{
tokenBuilder.Append('=');
code = TTokenCode.Le;
buffer.GetChar();
}
else if (ch == '>')
{
tokenBuilder.Append(ch);
code = TTokenCode.Ne;
buffer.GetChar();
}
else
{
code = TTokenCode.Lt;
}
break;
case '>':
ch = buffer.GetChar(); // > or >=
if (ch == '=')
{
tokenBuilder.Append('=');
code = TTokenCode.Ge;
buffer.GetChar();
}
else
{
code = TTokenCode.Gt;
}
break;
case '.':
ch = buffer.GetChar(); // . or ..
if (ch == '.')
{
tokenBuilder.Append(ch);
code = TTokenCode.DotDot;
buffer.GetChar();
}
else
{
code = TTokenCode.Period;
}
break;
default:
code = TTokenCode.Error; // error
buffer.GetChar();
break;
}
tokenString = tokenBuilder.ToString();
}
private void StringInputBufferTest(IInputBuffer ib)
{
Assert.Equal(StringData, ib.ReadString(0));
}
private bool accumulateValue(IInputBuffer buffer, StringBuilder tokenBuilder, ref float value)
{
char ch = buffer.CurrentChar;
Dictionary<int, CharCode> charCodeMap = CharCodeMapManager.Instance.GetCharacterMap();
//--Error if the first character is not a digit.
if (charCodeMap[ch] != CharCode.Digit)
{
return false; // failure
}
//--Accumulate the value as long as the total allowable
//--number of digits has not been exceeded.
do
{
tokenBuilder.Append(ch);
if (++digitCount <= maxDigitCount)
{
value = 10 * value + (ch - '0'); // shift left and add
}
else countError = true; // too many digits, but keep reading anyway
ch = buffer.GetChar();
} while (charCodeMap[ch] == CharCode.Digit);
return true; // success
}
public override void Get(IInputBuffer buffer)
{
StringBuilder tokenBuilder = new StringBuilder();
char ch;
float numValue = 0; // value of number ignoring
// the decimal point
int wholePlaces = 0; // no. digits before the decimal point
int decimalPlaces = 0; // no. digits after the decimal point
char exponentSign = '+';
float eValue = 0; // value of number after 'E'
int exponent = 0; // final value of exponent
bool sawDotDotFlag = false; // true if encountered '..',
// else false
ch = buffer.CurrentChar;
digitCount = 0;
countError = false;
code = TTokenCode.Error; // we don't know what it is yet, but
type = TDataType.tyInteger; // assume it'll be an integer
//--Get the whole part of the number by accumulating
//--the values of its digits into numValue. wholePlaces keeps
//--track of the number of digits in this part.
if (accumulateValue(buffer, tokenBuilder, ref numValue))
{
wholePlaces = digitCount;
ch = buffer.CurrentChar;
////--If the current character is a dot, then either we have a
////--fraction part or we are seeing the first character of a '..'
////--token. To find out, we must fetch the next character.
if (ch == '.')
{
ch = buffer.GetChar();
if (ch == '.')
{
//--We have a .. token. Back up bufferp so that the
//--token can be extracted next.
sawDotDotFlag = true;
buffer.PutBackChar();
}
else
{
type = TDataType.tyReal;
tokenBuilder.Append(".");
//--We have a fraction part. Accumulate it into numValue.
if (!accumulateValue(buffer, tokenBuilder, ref numValue)) return;
// get the current character
ch = buffer.CurrentChar;
decimalPlaces = digitCount - wholePlaces;
}
}
//--Get the exponent part, if any. There cannot be an
//--exponent part if we already saw the '..' token.
if (!sawDotDotFlag && ((ch == 'E') || (ch == 'e')))
{
type = TDataType.tyReal;
tokenBuilder.Append(ch);
ch = buffer.GetChar();
//--Fetch the exponent's sign, if any.
if ((ch == '+') || (ch == '-'))
{
exponentSign = ch;
tokenBuilder.Append(ch);
ch = buffer.GetChar();
}
//--Accumulate the value of the number after 'E' into eValue.
digitCount = 0;
if (!accumulateValue(buffer, tokenBuilder, ref eValue)) return;
ch = buffer.CurrentChar;
if (exponentSign == '-') eValue = -eValue;
}
//--Were there too many digits?
if (countError)
{
return;
}
//--Calculate and check the final exponent value,
//--and then use it to adjust the number's value.
exponent = (int)eValue - decimalPlaces;
if ((exponent + wholePlaces < -maxExponent) ||
(exponent + wholePlaces > maxExponent))
{
return;
}
if (exponent != 0)
{
numValue *= (float)Math.Pow(10.0, exponent);
}
//--Check and set the numeric value.
if (type == TDataType.tyInteger)
{
if ((numValue < -maxInteger) || (numValue > maxInteger))
{
return;
}
value.integerValue = (int)numValue;
}
else
{
value.realValue = numValue;
}
tokenString = tokenBuilder.ToString();
code = TTokenCode.Number;
}
}
public override void Get(IInputBuffer buffer)
{
code = TTokenCode.EndOfFile;
}
/// <summary>
/// Parses the given input buffer as an instance of <typeparamref name="T"/>.
/// </summary>
public T Parse <T>(IInputBuffer buffer)
where T : class
{
return(this.GetOrCreateSerializer <T>().Parse(buffer));
}
public abstract void Get(IInputBuffer buffer);
public Calculator(IInputBuffer buffer)
{
Buffer = buffer;
}
internal BufferFilledEventArgs(IInputBuffer buffer)
{
Buffer = buffer;
}
public TestCalculator(IInputBuffer buffer) : base(buffer)
{
}
