public override Program Load(Address addrLoad)
{
BinHexDecoder dec = new BinHexDecoder(new StringReader(Encoding.ASCII.GetString(RawImage)));
IEnumerator<byte> stm = dec.GetBytes().GetEnumerator();
BinHexHeader hdr = LoadBinHexHeader(stm);
byte[] dataFork = LoadFork(hdr.DataForkLength, stm);
byte[] rsrcFork = LoadFork(hdr.ResourceForkLength, stm);
var arch = new M68kArchitecture();
var platform = new MacOSClassic(Services, arch);
if (hdr.FileType == "PACT")
{
Cpt.CompactProArchive archive = new Cpt.CompactProArchive();
List<ArchiveDirectoryEntry> items = archive.Load(new MemoryStream(dataFork));
IArchiveBrowserService abSvc = Services.GetService<IArchiveBrowserService>();
if (abSvc != null)
{
var selectedFile = abSvc.UserSelectFileFromArchive(items);
if (selectedFile != null)
{
var image = selectedFile.GetBytes();
this.rsrcFork = new ResourceFork(image, arch);
this.image = new LoadedImage(addrLoad, image);
this.imageMap = new ImageMap(addrLoad, image.Length);
return new Program(this.image, this.imageMap, arch, platform);
}
}
}
var li = new LoadedImage(addrLoad, dataFork);
return new Program(li, li.CreateImageMap(), arch, platform);
}
public Project(object key, string number, string name)
: base(key)
{
this.number = number;
this.name = name;
this.address = null;
this.owner = null;
this.constructionAdministrator = null;
this.principal = null;
this.contractDate = null;
this.estimatedStartDate = null;
this.estimatedCompletionDate = null;
this.currentCompletionDate = null;
this.actualCompletionDate = null;
this.contingencyAllowanceAmount = 0;
this.testingAllowanceAmount = 0;
this.utilityAllowanceAmount = 0;
this.originalConstructionCost = 0;
this.totalChangeOrderDays = 0;
this.adjustedConstructionCost = 0;
this.totalChangeOrdersAmount = 0;
this.totalSquareFeet = 0;
this.percentComplete = 0;
this.remarks = string.Empty;
this.aeChangeOrderAmount = 0;
this.contractReason = string.Empty;
this.agencyApplicationNumber = string.Empty;
this.agencyFileNumber = string.Empty;
this.segment = null;
this.allowances = new List<Allowance>();
}
public DisassemblyTextModel(Program program)
{
if (program == null)
throw new ArgumentNullException("program");
this.program = program;
this.position = program.Image.BaseAddress;
}
public override RelocationResults Relocate(Address addrLoad)
{
ImageMap imageMap = imgLoadedMap;
ImageReader rdr = new LeImageReader(exe.RawImage, (uint) exe.e_lfaRelocations);
var relocations = new RelocationDictionary();
int i = exe.e_cRelocations;
while (i != 0)
{
uint offset = rdr.ReadLeUInt16();
ushort segOffset = rdr.ReadLeUInt16();
offset += segOffset * 0x0010u;
ushort seg = (ushort) (imgLoaded.ReadLeUInt16(offset) + addrLoad.Selector);
imgLoaded.WriteLeUInt16(offset, seg);
relocations.AddSegmentReference(offset, seg);
imageMap.AddSegment(Address.SegPtr(seg, 0), seg.ToString("X4"), AccessMode.ReadWriteExecute);
--i;
}
// Found the start address.
Address addrStart = Address.SegPtr((ushort)(exe.e_cs + addrLoad.Selector), exe.e_ip);
imageMap.AddSegment(Address.SegPtr(addrStart.Selector, 0), addrStart.Selector.ToString("X4"), AccessMode.ReadWriteExecute);
return new RelocationResults(
new List<EntryPoint> { new EntryPoint(addrStart, arch.CreateProcessorState()) },
relocations);
}
public void Test()
{
int id = -1;
using (ISession s = OpenSession())
{
var address1 = new Address("60", "EH3 8BE");
var address2 = new Address("2", "EH6 6JA");
s.Save(address1);
s.Save(address2);
var person1 = new Person("'lil old me");
person1.AddPercentageToFeeMatrix(0, .20m);
person1.AddPercentageToFeeMatrix(50, .15m);
person1.AddPercentageToFeeMatrix(100, .1m);
person1.RegisterChangeOfAddress(new DateTime(2005, 4, 15), address1);
person1.RegisterChangeOfAddress(new DateTime(2007, 5, 29), address2);
s.Save(person1);
s.Flush();
id = person1.Id;
}
using (ISession s = OpenSession())
{
var person1 = s.Load<Person>(id);
person1.RegisterChangeOfAddress(new DateTime(2008, 3, 23), new Address("8", "SS7 1TT"));
s.Save(person1);
s.Flush();
}
}
public async Task CreateProviderAsync(ProviderDto provider, Phone phone, Address address)
{
try
{
var dbPhone = await CreatePhone(phone);
var addressId = await CreateAddress(address);
var user = await DbContext.GetUserByEmailAsync(provider.Email);
var dbProvider = new Provider
{
DateOfBirth = provider.DateOfBirth,
Specialty = provider.Specialty,
Sex = provider.Sex,
LicenseNumber = provider.LicenseNumber,
AddressId = addressId,
Address = address,
Phone = new List<Phone> { dbPhone },
User = user,
UserId = user?.Id,
};
await DbContext.CreateProviderAsync(dbProvider);
}
catch (DbEntityValidationException ex)
{
}
}
public void Unsubscribe(Type eventType, Address publisherAddress)
{
using (var channel = ConnectionManager.GetAdministrationConnection().CreateModel())
{
RoutingTopology.TeardownSubscription(channel, eventType, EndpointQueueName);
}
}
public PayExAddress(string orderRef)
{
OrderRef = orderRef;
BillingAddress = new Address();
ShippingAddress = new Address();
}
/// <summary>
/// Gets or sets the <see cref="IEnumerable{Join}"/> with the specified address.
/// </summary>
/// <param name="address">The address.</param>
/// <returns>IEnumerable<Join>.</returns>
public IEnumerable<Join> this[Address address]
{
get
{
List<Join> value;
if (_joins.TryGetValue(address, out value))
{
return value;
}
else
{
return CreateEmptyJoinList();
}
}
set
{
List<Join> matchingJoins;
if (!_joins.TryGetValue(address, out matchingJoins))
{
matchingJoins = new List<Join>();
_joins[address] = matchingJoins;
}
matchingJoins.AddRange(value);
}
}
public PyBuildValueFormatParser(
Program program,
Address addrInstr,
string format,
IServiceProvider services)
{
this.ArgumentTypes = new List<DataType>();
this.format = format;
var platform = program.Platform;
this.pointerSize = platform.PointerType.Size;
var wordSize = platform.Architecture.WordWidth.Size;
var longSize = platform.GetByteSizeFromCBasicType(
CBasicType.Long);
var longLongSize = platform.GetByteSizeFromCBasicType(
CBasicType.LongLong);
var doubleSize = platform.GetByteSizeFromCBasicType(
CBasicType.Double);
dtInt = Integer(wordSize);
dtUInt = UInteger(wordSize);
dtLong = Integer(longSize);
dtULong = UInteger(longSize);
dtLongLong = Integer(longLongSize);
dtULongLong = UInteger(longLongSize);
dtDouble = Real(doubleSize);
ptrChar = Ptr(PrimitiveType.Char);
ptrVoid = Ptr(VoidType.Instance);
dtPySize = UInteger(pointerSize);
ptrPyObject = Ptr(Ref("PyObject"));
ptrPyUnicode = Ptr(Ref("Py_UNICODE"));
ptrPyComplex = Ptr(Ref("Py_complex"));
ptrPyConverter = Ptr(new CodeType());
}
public IEnumerable<Address> RetrieveByCustomerId(int customerId)
{
var addressList = new List<Address>();
var address = new Address(1)
{
AddressType = 1,
StreetLine1 = "Bad End",
StreetLine2 = "Bagshot row",
City = "Hobbiton",
State = "Shire",
Country = "Middle Earth",
PostalCode = "144"
};
addressList.Add(address);
address = new Address(2)
{
AddressType = 2,
StreetLine1 = "Green Dragon",
City = "Bywater",
State = "Shire",
Country = "Middle Earth",
PostalCode = "144"
};
addressList.Add(address);
return addressList;
}
/// <summary>
/// Constructor
/// </summary>
public CreateJoinForm(Peer peerObject, Address addressObject, ConnectWizard connectionWizard)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
peer = peerObject;
this.connectionWizard = connectionWizard;
this.Text = connectionWizard.SampleName + " - " + this.Text;
deviceAddress = addressObject;
//Set up the event handlers
peer.FindHostResponse += new FindHostResponseEventHandler(FindHostResponseMessage);
peer.ConnectComplete += new ConnectCompleteEventHandler(ConnectResult);
peer.AsyncOperationComplete += new AsyncOperationCompleteEventHandler(CancelAsync);
//Set up our timer
updateListTimer = new System.Timers.Timer(300); // A 300 ms interval
updateListTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.UpdateTimer);
updateListTimer.SynchronizingObject = this;
updateListTimer.Start();
//Set up our connect timer
connectTimer = new System.Timers.Timer(100); // A 100ms interval
connectTimer.Elapsed += new System.Timers.ElapsedEventHandler(this.ConnectTimer);
connectTimer.SynchronizingObject = this;
// Set up our connect event
connectEvent = new ManualResetEvent(false);
}
static void Main(string[] args)
{
using (ShopContext ctx = new ShopContext())
{
Address a = new Address
{
AddressLine1 = "Somewhere 1",
AddressLine2 = "At some floor",
City = "SomeCity",
ZipCode = "1111AA"
};
Customer c = new Customer()
{
FirstName = "Willamar",
LastName = "Fernandes",
BillingAddress = a,
ShippingAddress = a
};
ctx.Customers.Add(c);
ctx.SaveChanges();
}
}
// Precondition: None
// Postcondition: Small list of Parcels is created and displayed
static void Main(string[] args)
{
Address a1 = new Address("John Smith", "123 Any St.", "Apt. 45",
"Louisville", "KY", 40202); // Test Address 1
Address a2 = new Address("Jane Doe", "987 Main St.", "",
"Beverly Hills", "CA", 90210); // Test Address 2
Address a3 = new Address("James Kirk", "654 Roddenberry Way", "Suite 321",
"El Paso", "TX", 79901); // Test Address 3
Address a4 = new Address("John Crichton", "678 Pau Place", "Apt. 7",
"Portland", "ME", 04101); // Test Address 4
Letter l1 = new Letter(a1, a3, 1.50M); // Test Letter 1
Letter l2 = new Letter(a2, a4, 1.25M); // Test Letter 2
Letter l3 = new Letter(a4, a1, 1.75M); // Test Letter 3
List<Parcel> parcels = new List<Parcel>(); // Test list of parcels
// Add test data to list
parcels.Add(l1);
parcels.Add(l2);
parcels.Add(l3);
// Display data
Console.WriteLine("Program 0 - List of Parcels\n\n");
foreach (Parcel p in parcels)
{
Console.WriteLine(p);
Console.WriteLine("--------------------");
}
}
protected AddressOperand(Address a, PrimitiveType type)
: base(type)
{
if (a == null)
throw new ArgumentNullException("a");
Address = a;
}
public async Task<ActionResult> Register() {
var pcats = CURTAPI.GetParentCategoriesAsync();
await Task.WhenAll(new Task[] { pcats });
ViewBag.parent_cats = await pcats;
List<Country> countries = UDF.GetCountries();
Customer cust = new Customer();
Address billing = new Address();
Address shipping = new Address();
bool same = true;
try {
cust = (Customer)TempData["customer"];
billing = (Address)TempData["billing"];
shipping = (Address)TempData["customer"];
same = (bool)TempData["same"];
} catch (Exception) { }
ViewBag.cust = cust;
ViewBag.billing = billing;
ViewBag.shipping = shipping;
ViewBag.same = same;
ViewBag.countries = countries;
ViewBag.error = TempData["error"];
return View();
}
static void Main(string[] args)
{
/*
* Rules
*
* External entities are only mapped one way (either to or from)
* Data entities are mapped both ways
**/
AutoMapper.Mapper.AddProfile<MapperProfile>();
// External Entites
var addressExternalEntity = new AddressExternalEntity { Id = 1, Line1 = "Line1", Line2 = "Line2", Line3 = "Line3" };
AutoMapper.Mapper.Map<AddressExternalEntity, Address>(addressExternalEntity);
var personExternalEntity = new PersonExternalEntity {Id = 10, Name = "Bob"};
AutoMapper.Mapper.Map<PersonExternalEntity, Person>(personExternalEntity);
var personStatusResponse = new PersonStatusResponse {PersonId = 324};
AutoMapper.Mapper.Map<PersonStatusResponse, PersonStatusResponseExternalEntity>(personStatusResponse);
// Data Entities
var address = new Address { Id = 1, Line1 = "Line1", Line2 = "Line2", Line3 = "Line3" };
var addressDataEntity = AutoMapper.Mapper.Map<Address, AddressDataEntity>(address);
address = AutoMapper.Mapper.Map<AddressDataEntity, Address>(addressDataEntity);
var person = new Person { Id = 10, Name = "Bob" };
var personDataEntity = AutoMapper.Mapper.Map<Person, PersonDataEntity>(person);
person = AutoMapper.Mapper.Map<PersonDataEntity, Person>(personDataEntity);
Console.ReadKey();
}
public Person()
{
Adresse = new Address();
Telefon = new PhoneNumber();
Rights = new Rights();
ID = Guid.NewGuid();
}
public Cmd_EditSignature(IServiceProvider services, Program program, Procedure procedure, Address addr)
: base(services)
{
this.program = program;
this.procedure = procedure;
this.address = addr;
}
public static void SetGeographicalLocation(Address address)
{
Contract.Requires(address != null);
var rooturl = "http://maps.google.com/maps/api/geocode/xml?address=";
var tailurl = "&sensor=false";
var appendedString = new StringBuilder();
if (!string.IsNullOrWhiteSpace(address.StreetAddress))
{
appendedString.Append(address.StreetAddress.Trim().Replace(" ", " ").Replace(" ", "+"));
}
CleanAndAppendAddressPart(appendedString, address.Suburb);
CleanAndAppendAddressPart(appendedString, address.City);
CleanAndAppendAddressPart(appendedString, address.Provence);
CleanAndAppendAddressPart(appendedString, address.PostCode);
CleanAndAppendAddressPart(appendedString, address.Country);
appendedString.Insert(0, rooturl);
appendedString.Append(tailurl);
var url = appendedString.ToString();
var xmldata = XDocument.Load(url);
var response = xmldata.Element("GeocodeResponse");
if (response.Element("status").Value.ToUpperInvariant() != "OK")
return;
var location = response.Element("result").Element("geometry").Element("location");
var latitude = decimal.Parse(location.Element("lat").Value);
var longitude = decimal.Parse(location.Element("lng").Value);
address.AddEstimatedGeoLocation(latitude, longitude);
//$lat = $xmldata.GeocodeResponse.result.geometry.location.lat
//$lng = $xmldata.GeocodeResponse.result.geometry.location.lng
//return @{ "Lat" = $lat; "Long" = $lng; "StreetAddress" = $StreetAddress; "City" = $City; "State" = $State; "Zip" = $Zip}
}
protected void RunTest(string sourceFile, string outputFile, Address addrBase)
{
Program program;
using (var rdr = new StreamReader(FileUnitTester.MapTestPath(sourceFile)))
{
program = asm.Assemble(addrBase, rdr);
}
foreach (var item in asm.ImportReferences)
{
program.ImportReferences.Add(item.Key, item.Value);
}
using (FileUnitTester fut = new FileUnitTester(outputFile))
{
Dumper dumper = new Dumper(program.Architecture);
dumper.ShowAddresses = true;
dumper.ShowCodeBytes = true;
dumper.DumpData(program.Image, program.Image.BaseAddress, program.Image.Length, fut.TextWriter);
fut.TextWriter.WriteLine();
dumper.DumpAssembler(program.Image, program.Image.BaseAddress, program.Image.BaseAddress + (uint)program.Image.Length, fut.TextWriter);
if (program.ImportReferences.Count > 0)
{
foreach (var de in program.ImportReferences.OrderBy(d => d.Key))
{
fut.TextWriter.WriteLine("{0:X8}: {1}", de.Key, de.Value);
}
}
fut.AssertFilesEqual();
}
}
private void AddExportedEntryPoints(Address addrLoad, ImageMap imageMap, List<EntryPoint> entryPoints)
{
ImageReader rdr = imgLoaded.CreateLeReader(rvaExportTable);
rdr.ReadLeUInt32(); // Characteristics
rdr.ReadLeUInt32(); // timestamp
rdr.ReadLeUInt32(); // version.
rdr.ReadLeUInt32(); // binary name.
rdr.ReadLeUInt32(); // base ordinal
int nExports = rdr.ReadLeInt32();
int nNames = rdr.ReadLeInt32();
if (nExports != nNames)
throw new BadImageFormatException("Unexpected discrepancy in PE image.");
uint rvaApfn = rdr.ReadLeUInt32();
uint rvaNames = rdr.ReadLeUInt32();
ImageReader rdrAddrs = imgLoaded.CreateLeReader(rvaApfn);
ImageReader rdrNames = imgLoaded.CreateLeReader(rvaNames);
for (int i = 0; i < nNames; ++i)
{
EntryPoint ep = LoadEntryPoint(addrLoad, rdrAddrs, rdrNames);
if (imageMap.IsExecutableAddress(ep.Address))
{
entryPoints.Add(ep);
}
}
}
/// <summary>
/// Create a new CustomerBlob object.
/// </summary>
/// <param name="ID">Initial value of ID.</param>
/// <param name="address">Initial value of Address.</param>
public static CustomerBlob CreateCustomerBlob(int ID, Address address)
{
CustomerBlob customer = new CustomerBlob();
customer.ID = ID;
customer.Address = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(address, "Address");
return customer;
}
public void Create(Address? address, int peerLimit, int channelLimit, uint incomingBandwidth, uint outgoingBandwidth)
{
if (_host != null)
{
throw new InvalidOperationException("Already created.");
}
if (peerLimit < 0 || peerLimit > Native.ENET_PROTOCOL_MAXIMUM_PEER_ID)
{
throw new ArgumentOutOfRangeException("peerLimit");
}
CheckChannelLimit(channelLimit);
if (address != null)
{
var nativeAddress = address.Value.NativeData;
_host = Native.enet_host_create(ref nativeAddress, (IntPtr) peerLimit,
(IntPtr) channelLimit, incomingBandwidth, outgoingBandwidth);
}
else
{
_host = Native.enet_host_create(null, (IntPtr) peerLimit,
(IntPtr) channelLimit, incomingBandwidth, outgoingBandwidth);
}
if (_host == null)
{
throw new ENetException(0, "Host creation call failed.");
}
}
public void CreateQueueIfNecessary(Address address, string account)
{
foreach (var creator in queueCreators)
{
creator.RegisterProjectionsFor(address, account);
}
}
public void PassInPrecreatedAddress_GetsDataCorrectly()
{
Address bkAddress = CreateCustomer().Address;
var vm = new AddressVM(bkAddress);
var toCopy = new Address {HouseNumber = vm.HouseNumber, AddressBody = vm.AddressBody, Postcode = vm.Postcode, PhoneNumber = vm.PhoneNumber, ProofOfAddressPath = vm.ProofOfAddressPath};
Assert.IsTrue(toCopy.HasMatchingState(bkAddress));
}
public void ShippingEdits(object s, RepeaterCommandEventArgs e)
{
Address address = new Address();
Guid selectedAddress = new Guid(e.CommandArgument.ToString());
_user = new WebProfile().GetProfile(ddlCustomer.SelectedValue);
address = _user.AddressCollection.Find(delegate(Address addressToFind) {
return addressToFind.AddressId == selectedAddress && addressToFind.AddressType == AddressType.ShippingAddress;
});
if (address.AddressId != Guid.Empty) {
if (e.CommandName == "Edit") {
//Do the edit
pnlBillingAddresses.Visible = false;
pnlShippingAddresses.Visible = false;
pnlEditAddress.Visible = true;
LoadEditPanel(address);
tcMyAccount.ActiveTab = tpAddresses;
}
if (e.CommandName == "Delete") {
_user.AddressCollection.Remove(address);
_user.Save();
LoadAddresses();
tcMyAccount.ActiveTab = tpAddresses;
}
}
}
protected void lbBasicAuth_Click(object sender, EventArgs e)
{
string merchantId = ConfigurationManager.AppSettings["MerchantID"];
string account = ConfigurationManager.AppSettings["Account"];
string sharedSecret = ConfigurationManager.AppSettings["SharedSecret"];
Merchant merchant = new Merchant(merchantId, account, sharedSecret);
Order order = new Order("GBP", 999);
//working
CreditCard card = new CreditCard("MC", "5425232820001308", "0118", "Phil McCracken", "123", 1);
//invalid
//CreditCard card = new CreditCard("MC", "1234123412341234", "0118", "Phil McCracken", "123", 1);
Address address = new Address("", "", "", "", "", "", "", "");
PhoneNumbers numbers = new PhoneNumbers("", "", "", "");
Payer payer = new Payer("Business", "test", "", "Phil", "McCracken", "", address, numbers, "", new ArrayList());
string timestamp = Common.GenerateTimestamp();
string autoSettle = "1";
RealAuthTransactionResponse resp = RealAuthorisation.Auth(merchant, order, card, autoSettle, timestamp);
lblErrorCode.Text = resp.ResultCode.ToString();
lblResult.Text = resp.ResultMessage;
}
public ContractorAddressChanged(Guid id, DateTime eventTime,string einNumber,Address oldAddress,Address newAddress)
: base(id, eventTime)
{
EinNumber = einNumber;
OldAddress = oldAddress;
NewAddress = newAddress;
}
protected Program RewriteFile(string relativePath, Address addrBase)
{
sc = new ServiceContainer();
var config = new FakeDecompilerConfiguration();
var eventListener = new FakeDecompilerEventListener();
sc.AddService<IConfigurationService>(config);
sc.AddService<DecompilerHost>(new FakeDecompilerHost());
sc.AddService<DecompilerEventListener>(eventListener);
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
ILoader ldr = new Loader(sc);
var program = ldr.AssembleExecutable(
FileUnitTester.MapTestPath(relativePath),
new X86TextAssembler(sc, new X86ArchitectureReal()),
addrBase);
program.Platform = new DefaultPlatform(sc, program.Architecture);
var ep = new ImageSymbol(program.SegmentMap.BaseAddress);
var project = new Project { Programs = { program } };
var scan = new Scanner(
program,
new ImportResolver(project, program, eventListener),
sc);
scan.EnqueueImageSymbol(ep, true);
scan.ScanImage();
var importResolver = new ImportResolver(project, program, eventListener);
var dfa = new DataFlowAnalysis(program, importResolver, eventListener);
dfa.AnalyzeProgram();
return program;
}
public bool TryParseAddress(string txtAddress, out Address addr)
{
return(Address.TryParse32(txtAddress, out addr));
}
public void Bwslc_Slices()
{
// This test is derived from a m68k binary which originally looked like this:
// cmpi.b #$17,d0
// bhi $0010F010
//
// moveq #$00,d1
// move.b d0,d1
// add.w d1,d1
// move.w (06,pc,d1),d1
// jmp.l (pc,d1)
// The code introduces a lot of SLICEs, which must be dealt with appropriately.
var W8 = PrimitiveType.Byte;
var W16 = PrimitiveType.Word16;
var W32 = PrimitiveType.Word32;
var I16 = PrimitiveType.Int16;
var I32 = PrimitiveType.Int32;
arch = new Reko.Arch.M68k.M68kArchitecture(sc, "m68k");
var d0 = Reg("d0");
var d1 = Reg("d1");
var v2 = binder.CreateTemporary("v2", W8);
var v3 = binder.CreateTemporary("v3", W8);
var v4 = binder.CreateTemporary("v4", W16);
var v5 = binder.CreateTemporary("v5", PrimitiveType.Word16);
var CVZNX = Cc("CVZNX");
var CVZN = Cc("CVZN");
var CZ = Cc("CZ");
var b = Given_Block(0x00100000);
Given_Instrs(b, m =>
{
m.Assign(v2, m.ISub(m.Slice(PrimitiveType.Byte, d0, 0), 0x17));
m.Assign(CVZN, m.Cond(v2));
});
Given_Instrs(b, m =>
{
m.Branch(m.Test(ConditionCode.UGT, CZ), Address.Ptr32(0x00100040), InstrClass.ConditionalTransfer);
});
var b2 = Given_Block(0x00100008);
Given_Instrs(b2, m => {
m.Assign(d1, m.Word32(0));
m.Assign(CVZN, m.Cond(d1));
});
Given_Instrs(b2, m =>
{
m.Assign(v3, m.Slice(v3.DataType, d0, 0));
m.Assign(d1, m.Dpb(d1, v3, 0));
m.Assign(CVZN, m.Cond(v3));
});
Given_Instrs(b2, m =>
{
m.Assign(v4, m.IAdd(m.Slice(v4.DataType, d1, 0), m.Slice(v4.DataType, d1, 0)));
m.Assign(d1, m.Dpb(d1, v4, 0));
m.Assign(CVZNX, m.Cond(v4));
});
Given_Instrs(b2, m =>
{
m.Assign(v5, m.Mem16(m.IAdd(m.Word32(0x0010EC32), m.Convert(m.Slice(W16, d1, 0), W16, W32))));
m.Assign(d1, m.Dpb(d1, v5, 0));
m.Assign(CVZN, m.Cond(v5));
});
Given_Instrs(b2, m => {
m.Goto(m.IAdd(m.Word32(0x0010EC30), m.Convert(m.Slice(I16, d1, 0), I16, I32)));
});
graph.Nodes.Add(b);
graph.Nodes.Add(b2);
graph.AddEdge(b, b2);
var bwslc = new BackwardSlicer(host, b2, processorState);
Assert.IsTrue(bwslc.Start(b2, 10, Target(b2)));
while (bwslc.Step())
{
;
}
Assert.AreEqual(2, bwslc.Live.Count);
Console.WriteLine(bwslc.JumpTableFormat.ToString());
Assert.AreEqual("CONVERT(Mem0[CONVERT(SLICE(SEQ(d1, d0) * 2<32>, word16, 0), word16, word32) + 0x10EC32<32>:word16], word16, int32) + 0x10EC30<32>", bwslc.JumpTableFormat.ToString());
Assert.AreEqual("d0", bwslc.JumpTableIndex.ToString());
Assert.AreEqual("SLICE(d0, byte, 0)", bwslc.JumpTableIndexToUse.ToString(), "Expression to use when indexing");
Assert.AreEqual("1[0,17]", bwslc.JumpTableIndexInterval.ToString());
}
public void Bwslc_RepMovsd()
{
// Original i386 code:
// shr ecx,02
// and edx,03
// cmp ecx,08
// jc 00002000
// rep movsd
// jmp dword ptr[007862E8 + edx * 4]
arch = new Reko.Arch.X86.X86ArchitectureReal(sc, "x86-real-16");
var ecx = binder.EnsureRegister(arch.GetRegister("ecx"));
var edx = binder.EnsureRegister(arch.GetRegister("edx"));
var esi = binder.EnsureRegister(arch.GetRegister("esi"));
var edi = binder.EnsureRegister(arch.GetRegister("edi"));
var C = binder.EnsureFlagGroup(arch.GetFlagGroup("C"));
var SZO = binder.EnsureFlagGroup(arch.GetFlagGroup("SZO"));
var SCZO = binder.EnsureFlagGroup(arch.GetFlagGroup("SCZO"));
var tmp = binder.CreateTemporary(ecx.DataType);
var b = Given_Block(0x1000);
Given_Instrs(b, m => { m.Assign(ecx, m.Shr(ecx, 2)); m.Assign(SCZO, m.Cond(ecx)); });
Given_Instrs(b, m => { m.Assign(edx, m.And(edx, 3)); m.Assign(SZO, m.Cond(edx)); m.Assign(C, Constant.False()); });
Given_Instrs(b, m => { m.Assign(SCZO, m.Cond(m.ISub(ecx, 8))); });
Given_Instrs(b, m => { m.Branch(m.Test(ConditionCode.ULT, C), Address.Ptr32(0x2000), InstrClass.ConditionalTransfer); });
var b2 = Given_Block(0x1008);
Given_Instrs(b2, m => {
m.BranchInMiddleOfInstruction(m.Eq0(ecx), Address.Ptr32(0x1010), InstrClass.ConditionalTransfer);
m.Assign(tmp, m.Mem32(esi));
m.Assign(m.Mem32(edi), tmp);
m.Assign(esi, m.IAdd(esi, 4));
m.Assign(edi, m.IAdd(edi, 4));
m.Assign(ecx, m.ISub(ecx, 1));
m.Goto(Address.Ptr32(0x1008));
});
var b3 = Given_Block(0x1010);
Given_Instrs(b3, m => {
m.Goto(m.Mem32(m.IAdd(m.IMul(edx, 4), 0x00123400)));
});
graph.Nodes.Add(b);
graph.Nodes.Add(b2);
graph.Nodes.Add(b3);
graph.AddEdge(b, b2);
graph.AddEdge(b2, b3);
graph.AddEdge(b2, b2);
var bwslc = new BackwardSlicer(host, b3, processorState);
Assert.IsTrue(bwslc.Start(b3, -1, Target(b3))); // indirect jump
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.IsTrue(bwslc.Step());
Assert.False(bwslc.Step()); // edx &= 3
Assert.AreEqual("Mem0[(edx & 3<32>) * 4<32> + 0x123400<32>:word32]", bwslc.JumpTableFormat.ToString());
Assert.AreEqual("1[0,3]", bwslc.JumpTableIndexInterval.ToString());
}
public CombinationSlotState(Address address, int unlockStage) : base(address)
{
UnlockStage = unlockStage;
}
public override void SetInstructionPointer(Address addr)
{
}
public bool TryRead(MemoryArea mem, Address addr, PrimitiveType dt, out Constant value)
{
return(mem.TryReadLe(addr, dt, out value));
}
public Address MakeSegmentedAddress(Constant seg, Constant offset)
{
return(Address.SegPtr(seg.ToUInt16(), offset.ToUInt16()));
}
public List <RtlInstruction> InlineCall(Address addr, Address addrContinuation, EndianImageReader rdr, IStorageBinder binder)
{
return(null);
}
public EndianImageReader CreateImageReader(MemoryArea image, Address addrBegin, Address addrEnd)
{
return(new LeImageReader(image, addrBegin, addrEnd));
}
public Address MakeAddressFromConstant(Constant c)
{
return(Address.Ptr32(c.ToUInt32()));
}
internal static Address LocalAddressForRemote(
IDictionary<string, HashSet<ProtocolTransportAddressPair>> transportMapping, Address remote)
{
HashSet<ProtocolTransportAddressPair> transports;
if (transportMapping.TryGetValue(remote.Protocol, out transports))
{
ProtocolTransportAddressPair[] responsibleTransports =
transports.Where(t => t.ProtocolTransport.IsResponsibleFor(remote)).ToArray();
if (responsibleTransports.Length == 0)
{
throw new RemoteTransportException(
"No transport is responsible for address:[" + remote + "] although protocol [" + remote.Protocol +
"] is available." +
" Make sure at least one transport is configured to be responsible for the address.",
null);
}
if (responsibleTransports.Length == 1)
{
return responsibleTransports.First().Address;
}
throw new RemoteTransportException(
"Multiple transports are available for [" + remote + ": " +
string.Join(",", responsibleTransports.Select(t => t.ToString())) + "] " +
"Remoting cannot decide which transport to use to reach the remote system. Change your configuration " +
"so that only one transport is responsible for the address.",
null);
}
throw new RemoteTransportException(
"No transport is loaded for protocol: [" + remote.Protocol + "], available protocols: [" +
string.Join(",", transportMapping.Keys.Select(t => t.ToString())) + "]", null);
}
public ImageWriter CreateImageWriter(MemoryArea mem, Address addr)
{
return(new LeImageWriter(mem, addr));
}
/// <summary>
/// Start assumes that it cannot be followed by another Start() without having a Shutdown() first
/// </summary>
public override void Start()
{
if (_endpointManager == null)
{
_log.Info("Starting remoting");
_endpointManager =
System.SystemActorOf(RARP.For(System).ConfigureDispatcher(
Props.Create(() => new EndpointManager(System.Settings.Config, _log)).WithDeploy(Deploy.Local)),
EndpointManagerName);
try
{
var addressPromise = new TaskCompletionSource<IList<ProtocolTransportAddressPair>>();
// tells the EndpointManager to start all transports and bind them to listenable addresses, and then set the results
// of this promise to include them.
_endpointManager.Tell(new EndpointManager.Listen(addressPromise));
addressPromise.Task.Wait(Provider.RemoteSettings.StartupTimeout);
var akkaProtocolTransports = addressPromise.Task.Result;
if(akkaProtocolTransports.Count==0)
throw new ConfigurationException(@"No transports enabled under ""akka.remote.enabled-transports""");
_addresses = new HashSet<Address>(akkaProtocolTransports.Select(a => a.Address));
IEnumerable<IGrouping<string, ProtocolTransportAddressPair>> tmp =
akkaProtocolTransports.GroupBy(t => t.ProtocolTransport.SchemeIdentifier);
_transportMapping = new Dictionary<string, HashSet<ProtocolTransportAddressPair>>();
foreach (var g in tmp)
{
var set = new HashSet<ProtocolTransportAddressPair>(g);
_transportMapping.Add(g.Key, set);
}
_defaultAddress = akkaProtocolTransports.Head().Address;
_addresses = new HashSet<Address>(akkaProtocolTransports.Select(x => x.Address));
_log.Info("Remoting started; listening on addresses : [{0}]", string.Join(",", _addresses.Select(x => x.ToString())));
_endpointManager.Tell(new EndpointManager.StartupFinished());
_eventPublisher.NotifyListeners(new RemotingListenEvent(_addresses.ToList()));
}
catch (TaskCanceledException ex)
{
NotifyError("Startup was cancelled due to timeout", ex);
throw;
}
catch (TimeoutException ex)
{
NotifyError("Startup timed out", ex);
throw;
}
catch (Exception ex)
{
NotifyError("Startup failed", ex);
throw;
}
}
else
{
_log.Warning("Remoting was already started. Ignoring start attempt.");
}
}
/// <summary>
/// URL-encodes an actor <see cref="Address"/>. Used when generating the names
/// of some system remote actors.
/// </summary>
public static string Encode(Address address)
{
return HttpUtility.UrlEncode(address.ToString(), Encoding.UTF8);
}
public ProtocolTransportAddressPair(AkkaProtocolTransport protocolTransport, Address address)
{
ProtocolTransport = protocolTransport;
Address = address;
}
public override Address LocalAddressForRemote(Address remote)
{
return Remoting.LocalAddressForRemote(_transportMapping, remote);
}
public AssociateUnderlyingRefuseUid(Address remoteAddress, TaskCompletionSource <AssociationHandle> statusCompletionSource, int?refuseUid = null)
{
RefuseUid = refuseUid;
StatusCompletionSource = statusCompletionSource;
RemoteAddress = remoteAddress;
}
public OutboundUnassociated(Address remoteAddress, TaskCompletionSource <AssociationHandle> statusCompletionSource, Transport transport)
{
Transport = transport;
StatusCompletionSource = statusCompletionSource;
RemoteAddress = remoteAddress;
}
/// <summary>
/// <see cref="Props"/> used when creating OUTBOUND associations to remote endpoints.
///
/// These <see cref="Props"/> create outbound <see cref="ProtocolStateActor"/> instances,
/// which begin a state of
/// </summary>
/// <param name="handshakeInfo"></param>
/// <param name="remoteAddress"></param>
/// <param name="statusCompletionSource"></param>
/// <param name="transport"></param>
/// <param name="settings"></param>
/// <param name="codec"></param>
/// <param name="failureDetector"></param>
/// <param name="refuseUid"></param>
/// <returns></returns>
public static Props OutboundProps(HandshakeInfo handshakeInfo, Address remoteAddress,
TaskCompletionSource <AssociationHandle> statusCompletionSource,
Transport transport, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector, int?refuseUid = null)
{
return(Props.Create(() => new ProtocolStateActor(handshakeInfo, remoteAddress, statusCompletionSource, transport, settings, codec, failureDetector, refuseUid)));
}
public HandshakeInfo(Address origin, int uid)
{
Origin = origin;
Uid = uid;
}
public override RelocationResults Relocate(Program program, Address addrLoad)
{
return(new RelocationResults(new List <ImageSymbol>(), new SortedList <Address, ImageSymbol>()));
}
private string ActorNameFor(Address remoteAddress)
{
return(string.Format("akkaProtocol-{0}-{1}", AddressUrlEncoder.Encode(remoteAddress), NextId()));
}
protected override void SetState(IDictionary <string, object> state)
{
this.LastCreatedAddress = state.Get <Address>("LastCreatedAddress");
base.SetState(state);
}
protected override void LoadPlainValueInternal(IImmutableDictionary <string, IValue> plainValue)
{
productId = plainValue["productId"].ToGuid();
sellerAvatarAddress = plainValue["sellerAvatarAddress"].ToAddress();
}
/// <summary>
/// TBD
/// </summary>
/// <param name="listenAddress">TBD</param>
/// <param name="upstreamListener">TBD</param>
public ListenUnderlying(Address listenAddress, Task <IAssociationEventListener> upstreamListener)
{
UpstreamListener = upstreamListener;
ListenAddress = listenAddress;
}
public XbeSection(XbeSectionHeader hdr)
{
SectionHeader = hdr;
VirtualAddress = Address.Ptr32(SectionHeader.VirtualAddress);
NameAddress = Address.Ptr32(SectionHeader.SectionNameAddress);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="remote">TBD</param>
/// <returns>TBD</returns>
public override bool IsResponsibleFor(Address remote)
{
return(WrappedTransport.IsResponsibleFor(remote));
}
/// <inheritdoc/>
protected override void InterceptAssociate(Address remoteAddress, TaskCompletionSource <AssociationHandle> statusPromise)
{
manager.Tell(new AssociateUnderlying(remoteAddress, statusPromise));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="remoteAddress">TBD</param>
/// <param name="statusPromise">TBD</param>
protected abstract void InterceptAssociate(Address remoteAddress,
TaskCompletionSource <AssociationHandle> statusPromise);
/// <summary>
/// TBD
/// </summary>
/// <param name="remoteAddress">TBD</param>
/// <param name="statusPromise">TBD</param>
public AssociateUnderlying(Address remoteAddress, TaskCompletionSource <AssociationHandle> statusPromise)
{
RemoteAddress = remoteAddress;
StatusPromise = statusPromise;
}
