private void CheckHeader()
{
if (Unknown0x08 != 0x1)
{
throw new Exception("DDSHeaderV2: exception 0x08");
}
if (Unknown0x0C != 0x0)
{
throw new Exception("DDSHeaderV2: exception 0x0C");
}
if (HeaderSize != 0x80)
{
throw new Exception("DDSHeaderV2: exception 0x10");
}
if (Unknown0x1A != 0x02)
{
throw new Exception("DDSHeaderV2: exception 0x1A");
}
if (Unknown0x24 != 0x10000)
{
throw new Exception("DDSHeaderV2: exception 0x24");
}
if (Reserved.Contains <int>(0, new ReverseStructComparer <int>()))
{
throw new Exception("DDSHeaderV2: exception 0x28 array");
}
}
public byte[] GetData()
{
byte[] returned;
using (MemoryStream MS = new MemoryStream())
{
BinaryWriter writer = new BinaryWriter(MS);
Header.FileSize = 1 + Header.HeaderSize + Palette.Size + Reserved.Size + Compressed.Size();
Header.Get(writer);
Palette.Get(writer);
WidthTable.Get(writer);
Unknown.Get(writer);
Reserved.Get(writer);
Compressed.Get(writer);
if (Last != null)
{
Header.LastPosition = Last.Get(writer);
writer.BaseStream.Position = 0;
Header.Get(writer);
}
returned = MS.ToArray();
}
return(returned);
}
public int AddToCart(int ID, int prodID, int amount)
{
using (var context = new eshopContext())
{
var product = context.Products.FirstOrDefault(prod => prod.ProductId == prodID);
if (product != null && amount > 0 && amount <= product.ProductAmount)
{
product.ProductAmount -= amount;
context.SaveChanges();
Reserved reserved = new Reserved();
reserved.ProductId = prodID;
reserved.CategoryId = product.CategoryId;
reserved.UserId = ID;
reserved.CartId = context.Cart.FirstOrDefault(cart => cart.UserId == ID).CartId;
reserved.ReservedAmount = amount;
reserved.ReservedOrdered = false;
context.Reserved.Add(reserved);
}
return(context.SaveChanges());
}
}
private IEnumerable <SourceLine> GetSourceLines()
{
int currentline = 1;
IList <SourceLine> sourcelines = new List <SourceLine>();
foreach (string unprocessedline in _raw_input.Replace("\r", "").Split('\n'))
{
try
{
var line = new SourceLine(_reference_name, currentline, unprocessedline);
line.Parse(
token => Controller.IsInstruction(token) ||
Reserved.IsReserved(token) ||
(token.StartsWith(".") && Macro.IsValidMacroName(token.Substring(1))) ||
token == "="
);
sourcelines.Add(line);
}
catch (Exception ex)
{
Controller.Log.LogEntry(_reference_name, currentline, ex.Message);
}
currentline++;
}
sourcelines = _preprocessor.Preprocess(sourcelines).ToList();
return(sourcelines);
}
public override int GetHashCode()
{
int hash = 1;
if (BaseSupply != 0)
{
hash ^= BaseSupply.GetHashCode();
}
if (Available != 0)
{
hash ^= Available.GetHashCode();
}
if (Reserved != 0)
{
hash ^= Reserved.GetHashCode();
}
if (ManagementHolds != 0)
{
hash ^= ManagementHolds.GetHashCode();
}
if (MaintenanceHolds != 0)
{
hash ^= MaintenanceHolds.GetHashCode();
}
if (GroupBookingHoldsTotal != 0)
{
hash ^= GroupBookingHoldsTotal.GetHashCode();
}
if (GroupBookingHoldsUsed != 0)
{
hash ^= GroupBookingHoldsUsed.GetHashCode();
}
return(hash);
}
public override int GetHashCode()
{
int hash = 1;
if (Type != 0)
{
hash ^= Type.GetHashCode();
}
if (Version != 0)
{
hash ^= Version.GetHashCode();
}
if (CmdId != 0)
{
hash ^= CmdId.GetHashCode();
}
if (UserId != 0UL)
{
hash ^= UserId.GetHashCode();
}
if (Reserved != 0)
{
hash ^= Reserved.GetHashCode();
}
if (Message.Length != 0)
{
hash ^= Message.GetHashCode();
}
return(hash);
}
public FNTReserved(BinaryReader reader, uint size)
{
for (int i = 0; i < size; i++)
{
Reserved.Add(reader.ReadInt32());
}
}
/// <summary>
/// Creates a new instance of a page block processor.
/// </summary>
/// <param name="services">The shared <see cref="AssemblyServices"/> object.</param>
/// <param name="index">The index at which the block is defined.</param>
public PageBlockProcessor(AssemblyServices services,
int index)
: base(services, index, false)
{
Reserved.DefineType("Directives", ".page", ".endpage");
_page = GetPage();
}
/// <summary>
/// Initializes a new instance of the <see cref="T:DotNetAsm.ScopeBlockHandler"/> class.
/// </summary>
public ScopeBlockHandler()
{
Reserved.DefineType("Scoped", ConstStrings.OPEN_SCOPE, ConstStrings.CLOSE_SCOPE);
_scope = new Stack <string>();
_processedLines = new List <SourceLine>();
_anon = 0;
}
public List <Interfaces.ITask> GenerateTasks()
{
List <Interfaces.ITask> result = new List <Interfaces.ITask>();
Point v;
List <MapItem> items = ParentMap.GetObjects <MapItem>();
foreach (MapItem Item in items)
{
if (!Item.Reserved && ParentMap.FindStockpile(Item) == null)
{
v = GetFreeSpot();
if (v == new Point(-1, -1))
{
return(result);
}
Components.Tasks.Haul h = new Tasks.Haul(Item, v);
Item.Reserved = true;
Reserved.Add(v);
result.Add(h);
}
}
return(result);
}
/// <summary>
/// Constructs an instance of a <see cref="T:DotNetAsm.AssemblyController"/>, which controls the
/// assembly process.
/// </summary>
/// <param name="args">The array of <see cref="T:System.String"/> args passed by the commandline.</param>
public AssemblyController(string[] args)
{
Controller = this;
Options = new AsmCommandLineOptions();
Options.ProcessArgs(args);
Reserved.Comparer = Options.StringComparar;
Reserved.DefineType("Directives",
".cpu", ".endrelocate", ".equ", ".pseudopc", ".realpc", ".relocate", ".end",
".endrepeat", ".proff", ".pron", ".repeat", ConstStrings.VAR_DIRECTIVE
);
Reserved.DefineType("Functions",
"abs", "acos", "asin", "atan", "cbrt", "ceil", "cos", "cosh", "count", "deg",
"exp", "floor", "frac", "hypot", "ln", "log10", "pow", "rad", "random",
"round", "sgn", "sin", "sinh", "sizeof", "sqrt", "tan", "tanh", "trunc",
"str", "format"
);
Reserved.DefineType("UserDefined");
Log = new ErrorLog();
_processedLines = new List <SourceLine>();
Output = new Compilation(!Options.BigEndian);
_specialLabels = new Regex(@"^\*|\+|-$", RegexOptions.Compiled);
Encoding = new AsmEncoding(Options.CaseSensitive);
Evaluator = new Evaluator(Options.CaseSensitive);
Evaluator.DefineSymbolLookup(SymbolsToValues);
Symbols = new SymbolManager(this);
_localLabelScope = string.Empty;
_preprocessor = new Preprocessor(this, s => IsSymbolName(s.TrimEnd(':'), true, false));
_assemblers = new Stack <ILineAssembler>();
_assemblers.Push(new PseudoAssembler(this, arg =>
{
return(IsReserved(arg) || Symbols.Labels.IsScopedSymbol(arg, _currentLine.Scope));
}));
_assemblers.Push(new MiscAssembler(this));
_blockHandlers = new List <IBlockHandler>
{
new ConditionHandler(this),
new MacroHandler(this, IsInstruction),
new ForNextHandler(this),
new RepetitionHandler(this),
new ScopeBlockHandler(this)
};
Disassembler = new Disassembler(this);
}
void EvaluateCondition(SourceLine line)
{
if (Reserved.IsOneOf("Defs", line.Instruction.Name))
{
if (line.Operands.Count != 1)
{
throw new SyntaxException(line.Instruction.Position, "Expected expression");
}
if (!_ifDefEvaluations.TryGetValue((line.Filename, line.LineNumber), out _ifTrue))
{
if (line.Instruction.Name.ToString().EndsWith("ndef", Services.StringComparison))
{
_ifTrue = !Services.SymbolManager.SymbolExists(line.Operands[0].Name);
}
else
{
_ifTrue = Services.SymbolManager.SymbolExists(line.Operands[0].Name);
}
_ifDefEvaluations.Add((line.Filename, line.LineNumber), _ifTrue);
}
}
else
{
var iterator = line.Operands.GetIterator();
_ifTrue = Services.Evaluator.EvaluateCondition(iterator);
if (iterator.Current != null)
{
throw new SyntaxException(iterator.Current, "Unexpected expression.");
}
}
}
public ActionResult ReserveRoom(string RoomNo, string FrmDate, string Tdate, string username)
{
RoomNo = RoomNo.Trim();
Reserved reserved = new Reserved();
reserved.FromDate = Convert.ToDateTime(FrmDate);
reserved.ToDate = Convert.ToDateTime(Tdate);
reserved.BookedBy = username;
if (RoomNo != null && reserved != null && ModelState.IsValid)
{
if (!service.IsBookingExists(RoomNo, reserved))
{
if (service.AddReservation(RoomNo, reserved))
{
return(StatusCode(200, "Room Reservation Succssfull"));
}
else
{
return(StatusCode(401, $"Something wrong with the reservation , contact admin"));
}
}
else
{
return(StatusCode(499, $"A Booking Alreay Exists with the Room No : {RoomNo}"));
}
}
else
{
return(BadRequest());
}
}
public Reserved Reserve(int length)
{
if (length > 4096)
{
//TODO: do something
}
if (_span.Length == 0)
{
GetNextSpan();
}
if (_span.Length >= length)
{
var reserved = new Reserved(_span.Slice(0, length));
Advance(length);
if (_span.Length == 0)
{
GetNextSpan();
}
return(reserved);
}
else
{
var secondLen = length - _span.Length;
var first = _span.Slice(0, _span.Length);
_output.Advance(first.Length);
GetNextSpan();
var second = _span.Slice(0, secondLen);
Advance(secondLen);
return(new Reserved(first, second));
}
}
/// <summary>
/// Creates a new instance of a switch block processor.
/// </summary>
/// <param name="services">The shared <see cref="AssemblyServices"/> object.</param>
/// <param name="index">The index at which the block is defined.</param>
public SwitchBlock(AssemblyServices services,
int index)
: base(services, index)
{
Reserved.DefineType("Directives", ".switch", ".case", ".default", ".endswitch");
Reserved.DefineType("BreakContReturn", ".break", ".continue", ".return");
}
/// <summary>
/// The Postgres Server requires case sensativity if you enclose identifiers in double-quotes.
/// So, this is only done when necessary.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public string Enclose(string name)
{
if (_c.Enclose)
{
return(L + name + R);
}
return(name.Contains(" ") || Reserved.Contains(name) ? L + name + R : name);
}
/// <summary>
/// Constructs a Preprocessor object.
/// </summary>
/// <param name="controller">The assembly controller.</param>
/// <param name="checkSymbol">A function to check for symbols such as labels or variables.</param>
public Preprocessor(IAssemblyController controller,
Func <string, bool> checkSymbol)
: base(controller)
{
FileRegistry = new HashSet <string>();
_symbolNameFunc = checkSymbol;
Reserved.DefineType("Directives", ".binclude", ".include", ".comment", ".endcomment");
}
/// <summary>
/// Constructs a DotNetAsm.MiscAssembler class.
/// </summary>
public MiscAssembler()
{
Reserved.DefineType("Directives",
"assert", ".eor", ".echo", ".target",
".error", ".errorif",
".warnif", ".warn"
);
}
public void Resize(int size)
{
Header.Resize(size);
WidthTable.Resize(size);
Unknown.Resize(size);
Reserved.Resize(size);
Compressed.Resize(size);
}
public override void ExecuteDirective(RandomAccessIterator <SourceLine> iterator)
{
var line = iterator.Current;
if (_ifTrue)
{
SeekBlockEnd(iterator);
}
else
{
while (line != null && !line.Instruction.Name.Equals(".endif", Services.StringComparison) && !_ifTrue)
{
if (iterator.Current.Instruction == null)
{
continue;
}
var instruction = Services.Options.CaseSensitive ? line.Instruction.Name.ToString() :
line.Instruction.Name.ToLower();
if (instruction.StartsWith(".if"))
{
EvaluateCondition(line);
}
else
{
if (!instruction.Equals(".endif"))
{
if (_elseEvaluated)
{
throw new SyntaxException(iterator.Current.Instruction,
$"Invalid use of \"{instruction}\" directive.");
}
_elseEvaluated = instruction.Equals(".else");
if (_elseEvaluated)
{
if (line.Operands.Count > 0)
{
throw new SyntaxException(line.Operands[0], "Unexpected expression.");
}
break;
}
EvaluateCondition(line);
}
}
if (_ifTrue)
{
break;
}
SeekBlockDirectives(iterator, Reserved.GetReserved("Keywords").ToArray());
line = iterator.Current;
}
if (line == null)
{
throw new SyntaxException(line.Instruction, $"Missing \".endif\" directive.");
}
}
}
/// <summary>
/// Constructs an instance of the <see cref="T:DotNetAsm.Disassembler"/> class.
/// </summary>
public Disassembler()
{
PrintingOn = true;
Reserved.DefineType("Blocks", ConstStrings.OPEN_SCOPE, ConstStrings.CLOSE_SCOPE);
Reserved.DefineType("Directives",
".cpu", ".elif", ".else", ".endif", ".eor", ".error", ".errorif", ".if", ".ifdef",
".warnif", ".relocate", ".pseudopc", ".realpc", ".endrelocate", ".warn"
);
}
/// <summary>
/// Constructs a new instance of the assignment assembler class.
/// </summary>
public AssignmentAssembler()
{
Reserved.DefineType("Assignments", ".equ", ".global");
Reserved.DefineType("Pseudo",
".relocate", ".pseudopc", ".endrelocate", ".realpc");
Reserved.DefineType("Directives", ".let", ".org");
}
/// <summary>
/// Constructs an instance of a <see cref="T:DotNetAsm.RepetitionHandler"/> object.
/// </summary>
public RepetitionHandler()
{
Reserved.DefineType("Directives", ".repeat", ".endrepeat");
_currBlock =
_rootBlock = new RepetitionBlock();
_levels = 0;
_processedLines = new List <SourceLine>();
}
/// <summary>
/// Constructs a DotNetAsm.MiscAssembler class.
/// </summary>
/// <param name="controller">The DotNetAsm.IAssemblyController to associate</param>
public MiscAssembler(IAssemblyController controller) :
base(controller)
{
Reserved.DefineType("Directives",
"assert", ".eor", ".echo", ".target",
".error", ".errorif",
".warnif", ".warn"
);
}
public IIntegratedDocument Clone()
{
var newDocument = new IntegratedDocument();
newDocument.Document = new Lazy <BsonDocument>(CloneDocument);
newDocument.Reserved = Reserved.Clone().ToBsonDocument();
newDocument.APIId = this.APIId;
newDocument.IntegrationId = this.IntegrationId;
return(newDocument);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:DotNetAsm.MacroHandler"/> class.
/// </summary>
/// <param name="controller">A <see cref="T:DotNetAsm.IAssemblyController"/>.</param>
/// <param name="instructionFcn">The lookup function to validate whether the name is an instruction or directive.</param>
public MacroHandler(IAssemblyController controller, Func <string, bool> instructionFcn)
: base(controller)
{
Reserved.DefineType("Directives", ".macro", ".endmacro", ".segment", ".endsegment");
_macros = new Dictionary <string, Macro>(controller.Options.StringComparar);
_expandedSource = new List <SourceLine>();
_macroDefinitions = new Stack <List <SourceLine> >();
_instructionFcn = instructionFcn;
_definitions = new Stack <SourceLine>();
}
private async Task <Client> GetClientByReserved(Reserved rev)
{
var item = await _context.Client.FirstOrDefaultAsync(e => e.Cmnd == rev.Cmnd && e.PhoneNumber == rev.PhoneNumber);
if (item == null)
{
throw new NullReferenceException(nameof(Client));
}
return(item);
}
private string GetPhoneNumber(Reserved item)
{
if (string.IsNullOrWhiteSpace(item.PhoneNumber))
{
return(string.Empty);
}
var newPhoneNumber = "XXXXX" + item.PhoneNumber.Substring(item.PhoneNumber.Length - 4);
return(newPhoneNumber);
}
public object GetReserved(object obj, string szName)
{
Reserved res = (Reserved)GetMemberVlaue(obj, "reserved");
if (res.Ext == null)
{
return(null);
}
return(res.Ext[szName]);
}
/// <summary>
/// Constructs a DotNetAsm.MiscAssembler class.
/// </summary>
public MiscAssembler()
{
Reserved.DefineType("Directives",
".assert", ".bank",
".eor", ".echo", ".format",
".initmem", ".target",
".error", ".errorif",
".pron", ".proff",
".warnif", ".warn"
);
}
Reserved GetReserved(BinaryReader binReader)
{
Reserved reserved = new Reserved();
binReader.ReadInt32(); //null
binReader.ReadInt32(); // 01
while (binReader.ReadInt32() != 0x01) { } // Read until the marker has been reached
binReader.ReadInt32(); //null
reserved.title = GetString(binReader);
binReader.ReadInt32(); //null
reserved.unknown = binReader.ReadBytes(64);
return reserved;
}
