private void ScanPeripherals(RegisterSettings defaultRegisterSettings)
{
if(deviceNode.Element("peripherals") == null)
{
throw new RecoverableException("There is no <peripherals> section.");
}
var peripheralElements = deviceNode.Element("peripherals").Elements("peripheral");
if(!peripheralElements.Any())
{
Parent.currentSystemBus.Log(LogLevel.Warning, "There are no <peripheral> sections in <peripherals>.");
}
foreach(var peripheralElement in peripheralElements)
{
var derivingAttribute = peripheralElement.Attribute("derivedFrom");
if(derivingAttribute == null)
{
ScanPeripheral(peripheralElement, defaultRegisterSettings);
}
else
{
var derivedElement = GetDerivedElementFromTheScope(
peripheralElement,
peripheralElements,
NestingType.Peripheral,
derivingAttribute.Value
);
if(!peripheralElement.Elements("registers").Any())
{
peripheralElement.Add(derivedElement.Element("registers"));
}
var newDefaultRegisterSettings = GetRegisterSettings(derivedElement, defaultRegisterSettings);
ScanPeripheral(peripheralElement, newDefaultRegisterSettings);
}
}
}
public override object CreateRoute(RouteSettings routeSettings, RegisterSettings registerSettings)
{
ActionInfo first = routeSettings.Actions.First();
string baseRoute = registerSettings.BaseRoute;
var nonActionParameterTokens = new List <string>();
if (baseRoute != null)
{
nonActionParameterTokens.AddRange(
TokenPattern.Matches(baseRoute).Cast <Match>().Select(m => m.Groups[1].Value)
);
}
nonActionParameterTokens.AddRange(first.Controller.RouteProperties.Select(p => p.Name));
return(new CodeRoute(routeSettings.RouteTemplate, new RouteValueDictionary(routeSettings.Defaults), new RouteValueDictionary(routeSettings.Constraints), new RouteValueDictionary(routeSettings.DataTokens), new MvcRouteHandler())
{
ActionMapping = routeSettings.ActionMapping,
ControllerMapping = routeSettings.ControllerMapping,
NonActionParameterTokens = nonActionParameterTokens,
ControllerTypes = routeSettings.Actions
.Select(a => a.Controller)
.DistinctReference()
.ToDictionary(c => c.Name, c => c.Type, StringComparer.OrdinalIgnoreCase)
});
}
public override object CreateRoute(RouteSettings routeSettings, RegisterSettings registerSettings)
{
ActionInfo first = routeSettings.Actions.First();
string baseRoute = registerSettings.BaseRoute;
var nonActionParameterTokens = new List<string>();
if (baseRoute != null) {
nonActionParameterTokens.AddRange(
TokenPattern.Matches(baseRoute).Cast<Match>().Select(m => m.Groups[1].Value)
);
}
nonActionParameterTokens.AddRange(first.Controller.RouteProperties.Select(p => p.Name));
return new CodeRoute(routeSettings.RouteTemplate, new RouteValueDictionary(routeSettings.Defaults), new RouteValueDictionary(routeSettings.Constraints), new RouteValueDictionary(routeSettings.DataTokens), new MvcRouteHandler()) {
ActionMapping = routeSettings.ActionMapping,
ControllerMapping = routeSettings.ControllerMapping,
NonActionParameterTokens = nonActionParameterTokens,
ControllerTypes = routeSettings.Actions
.Select(a => a.Controller)
.DistinctReference()
.ToDictionary(c => c.Name, c => c.Type, StringComparer.OrdinalIgnoreCase)
};
}
public static ControllerInfo Create(Type controllerType, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
ControllerDescriptor controllerDescr = null;
if (createActionInvoker != null) {
Controller instance = null;
try {
instance = (Controller)FormatterServices.GetUninitializedObject(controllerType);
} catch (SecurityException) { }
if (instance != null) {
ControllerActionInvoker actionInvoker = createActionInvoker(instance) as ControllerActionInvoker;
if (actionInvoker != null) {
controllerDescr = getControllerDescriptor(actionInvoker, new ControllerContext { Controller = instance });
}
}
}
if (controllerDescr != null) {
return new DescribedMvcControllerInfo(controllerDescr, controllerType, registerSettings, provider);
}
return new ReflectedMvcControllerInfo(controllerType, registerSettings, provider);
}
public RegisterSettings(RegisterSettings parentRegisterSettings, int?size = null, uint?resetValue = null, ulong?address = null, PermittedAccess?access = null)
{
Size = size ?? parentRegisterSettings.Size;
ResetValue = resetValue ?? parentRegisterSettings.ResetValue;
Address = address ?? parentRegisterSettings.Address;
Access = access ?? parentRegisterSettings.Access;
}
private void ScanClusters(XElement node, RegisterSettings defaultRegisterSettings, SVDPeripheral peripheral)
{
var clusterItems = node.Elements("cluster");
foreach (var cluster in clusterItems)
{
var derivedAttribute = cluster.Attribute("derivedFrom");
if (derivedAttribute == null)
{
ScanCluster(cluster, defaultRegisterSettings, peripheral);
}
else
{
var derivedClusterName = derivedAttribute.Value;
var derivedCluster = FindDerivedElement(NestingType.Cluster, cluster, derivedAttribute.Value, defaultRegisterSettings, out var outRegisterSettings);
if (!cluster.Elements("register").Any())
{
cluster.Add(derivedCluster.Elements("register"));
}
if (!cluster.Elements("cluster").Any())
{
cluster.Add(derivedCluster.Elements("cluster"));
}
ScanCluster(cluster, outRegisterSettings, peripheral);
}
}
}
public static ControllerInfo Create(Type controllerType, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
ControllerDescriptor controllerDescr = null;
if (createActionInvoker != null)
{
Controller instance = null;
try {
instance = (Controller)FormatterServices.GetUninitializedObject(controllerType);
} catch (SecurityException) { }
if (instance != null)
{
ControllerActionInvoker actionInvoker = createActionInvoker(instance) as ControllerActionInvoker;
if (actionInvoker != null)
{
controllerDescr = getControllerDescriptor(actionInvoker, new ControllerContext {
Controller = instance
});
}
}
}
if (controllerDescr != null)
{
return(new DescribedMvcControllerInfo(controllerDescr, controllerType, registerSettings, provider));
}
return(new ReflectedMvcControllerInfo(controllerType, registerSettings, provider));
}
public static void Start()
{
var container = new UnityContainer();
GlobalConfiguration.Configuration.DependencyResolver = new UnityDependencyResolver(container);
RegisterSettings.Register(container);
ConfigureNHibernate.Configure(container);
RegisterRepositories.Register(container);
}
private void ScanCluster(XElement node, RegisterSettings defaultRegisterSettings, SVDPeripheral peripheral)
{
GetMandatoryField(node, "name");
var address = CalculateOffset(
defaultRegisterSettings.Address,
GetAddressOffset(node)
);
var newRegisterSettings = GetRegisterSettings(node, defaultRegisterSettings, address);
ScanRegistersAndClusters(node, newRegisterSettings, peripheral);
}
private XElement FindDerivedElement(NestingType nestingType, XElement element, String derivedElementName, RegisterSettings defaultRegisterSettings, out RegisterSettings outRegisterSettings)
{
string[] derivedSplitNode = derivedElementName.Split('.');
outRegisterSettings = defaultRegisterSettings;
XElement derivedElement;
if (derivedSplitNode.Length == 1)
{
derivedElement = GetDerivedElementFromTheScope(
element,
element.Parent.Elements(),
nestingType,
derivedElementName
);
}
else
{
var derivedPeripheral = GetDerivedElementFromTheScope(
element,
deviceNode.Element("peripherals").Elements(),
NestingType.Peripheral,
derivedSplitNode[0]
);
outRegisterSettings = GetRegisterSettings(derivedPeripheral, defaultRegisterSettings);
derivedElement = derivedPeripheral.Element("registers");
// if we are deriving from the cluster we should go through all cluster in the cluster chain,
// but if we are deriving from register we should go through all cluster chain but last one.
var limit = derivedSplitNode.Length - (nestingType == NestingType.Register ? 1 : 0);
for (var i = 1; i < limit; i++)
{
derivedElement = GetDerivedElementFromTheScope(
derivedElement,
derivedElement.Elements("cluster"),
NestingType.Cluster,
derivedSplitNode[i]
);
var address = CalculateOffset(
outRegisterSettings.Address,
GetAddressOffset(derivedElement)
);
outRegisterSettings = GetRegisterSettings(derivedElement, outRegisterSettings, address);
}
// If we are deriving from the register, we must find this register in the last cluster in the chain.
if (nestingType == NestingType.Register)
{
derivedElement = derivedElement.Elements("register").First(x => x.Element("name").Value == derivedSplitNode[derivedSplitNode.Length - 1]);
}
}
outRegisterSettings = GetRegisterSettings(derivedElement, outRegisterSettings, defaultRegisterSettings.Address);
return(derivedElement);
}
private static RegisterSettings GetRegisterSettings(XElement node, RegisterSettings defaultRegisterSettings, ulong? definiteAddress = null)
{
var localRegisterSettings = GetLocalRegisterSettings(node);
return new RegisterSettings(
defaultRegisterSettings,
localRegisterSettings.Size,
localRegisterSettings.ResetValue,
definiteAddress ?? localRegisterSettings.Address,
localRegisterSettings.Access
);
}
protected override bool SetSettingItemValue(SettingBase setting, System.Reflection.PropertyInfo property)
{
if (property.Name == "ScopeList")
{
RegisterSettings temp = (RegisterSettings)setting;
temp.ScopeList = RegisterSettings.ScopeList;
return(true);
}
else
{
return(base.SetSettingItemValue(setting, property));
}
}
private void ScanPeripheral(XElement node, RegisterSettings defaultRegisterSettings)
{
var name = GetMandatoryField(node, "name");
var newRegisterSettings = GetRegisterSettings(node, defaultRegisterSettings);
var peripheral = new SVDPeripheral(name, this);
Peripherals.Add(peripheral);
var registersElement = node.Element("registers");
if(registersElement != null)
{
ScanRegistersAndClusters(registersElement, newRegisterSettings, peripheral);
}
}
public static void RegisterAssembly(RegisterSettings registerSettings)
{
string basePath = String.Join("/", new[] { "Views", registerSettings.ViewsLocation }.Where(s => !String.IsNullOrEmpty(s)));
var assemblyResources = new AssemblyResources(registerSettings.Assembly, basePath);
if (assemblyResources.HasResources) {
ViewResources.Add(assemblyResources);
}
if (embeddedViewsEnabled
&& !registered) {
RegisterIfNecessary();
}
}
public static void RegisterAssembly(RegisterSettings registerSettings)
{
string basePath = String.Join("/", new[] { "Views", registerSettings.ViewsLocation }.Where(s => !String.IsNullOrEmpty(s)));
var assemblyResources = new AssemblyResources(registerSettings.Assembly, basePath);
if (assemblyResources.HasResources)
{
ViewResources.Add(assemblyResources);
}
if (embeddedViewsEnabled &&
!registered)
{
RegisterIfNecessary();
}
}
public static Route ConvertToWebRoute(object route, RegisterSettings registerSettings)
{
HttpConfiguration httpConfig = registerSettings.Settings.HttpConfiguration();
CodeHttpRoute httpRoute = (CodeHttpRoute)route;
// httpWebRoute is System.Web.Http.WebHost.Routing.HttpWebRoute
// with HttpRoute property set to httpRoute
GlobalConfiguration.Configuration.Routes.Add(null, httpRoute);
Route httpWebRoute = (Route)RouteTable.Routes.Last();
RouteTable.Routes.RemoveAt(RouteTable.Routes.Count - 1);
foreach (var item in httpWebRoute.Constraints.ToArray())
{
var paramBindConstraint = item.Value as Web.Http.Routing.ParameterBindingRouteConstraint;
if (paramBindConstraint != null)
{
httpWebRoute.Constraints[item.Key] = new ParameterBindingRouteConstraint(paramBindConstraint.Binder);
continue;
}
var regexConstraint = item.Value as Web.Http.Routing.RegexRouteConstraint;
if (regexConstraint != null)
{
httpWebRoute.Constraints[item.Key] = new RegexRouteConstraint(regexConstraint.Regex);
continue;
}
var setConstraint = item.Value as Web.Http.Routing.SetRouteConstraint;
if (setConstraint != null)
{
httpWebRoute.Constraints[item.Key] = new SetRouteConstraint(setConstraint.GetValues());
continue;
}
}
var codeWebRoute = new CodeHttpWebRoute(httpWebRoute, httpRoute);
CodeRoutingHttpExtensions.EnableCodeRouting(httpConfig);
return(codeWebRoute);
}
private void ScanRegisters(XElement node, RegisterSettings defaultRegisterSettings, SVDPeripheral peripheral)
{
var registerItems = node.Elements("register");
foreach(var register in registerItems)
{
var derivedAttribute = register.Attribute("derivedFrom");
if(derivedAttribute == null)
{
ScanRegister(register, defaultRegisterSettings, peripheral);
}
else
{
var derivedRegisterName = derivedAttribute.Value;
var derivedRegister = FindDerivedElement(NestingType.Register, register, derivedAttribute.Value, defaultRegisterSettings, out var outRegisterSettings);
ScanRegister(register, outRegisterSettings, peripheral);
}
}
}
public static Route ConvertToWebRoute(object route, RegisterSettings registerSettings) {
HttpConfiguration httpConfig = registerSettings.Settings.HttpConfiguration();
CodeHttpRoute httpRoute = (CodeHttpRoute)route;
// httpWebRoute is System.Web.Http.WebHost.Routing.HttpWebRoute
// with HttpRoute property set to httpRoute
GlobalConfiguration.Configuration.Routes.Add(null, httpRoute);
Route httpWebRoute = (Route)RouteTable.Routes.Last();
RouteTable.Routes.RemoveAt(RouteTable.Routes.Count - 1);
foreach (var item in httpWebRoute.Constraints.ToArray()) {
var paramBindConstraint = item.Value as Web.Http.Routing.ParameterBindingRouteConstraint;
if (paramBindConstraint != null) {
httpWebRoute.Constraints[item.Key] = new ParameterBindingRouteConstraint(paramBindConstraint.Binder);
continue;
}
var regexConstraint = item.Value as Web.Http.Routing.RegexRouteConstraint;
if (regexConstraint != null) {
httpWebRoute.Constraints[item.Key] = new RegexRouteConstraint(regexConstraint.Regex);
continue;
}
var setConstraint = item.Value as Web.Http.Routing.SetRouteConstraint;
if (setConstraint != null) {
httpWebRoute.Constraints[item.Key] = new SetRouteConstraint(setConstraint.GetValues());
continue;
}
}
var codeWebRoute = new CodeHttpWebRoute(httpWebRoute, httpRoute);
CodeRoutingHttpExtensions.EnableCodeRouting(httpConfig);
return codeWebRoute;
}
public static ControllerInfo Create(Type controllerType, RegisterSettings registerSettings, CodeRoutingProvider provider) {
HttpConfiguration configuration = registerSettings.Settings.HttpConfiguration();
if (configuration == null) {
throw new ArgumentException(
"You must first specify an {0} instance using the HttpConfiguration key on {1}.Properties.".FormatInvariant(
typeof(HttpConfiguration).FullName,
typeof(CodeRoutingSettings).FullName
)
);
}
return new DescribedHttpControllerInfo(
new HttpControllerDescriptor(
configuration,
controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length),
controllerType),
controllerType,
registerSettings,
provider
);
}
public static ControllerInfo Create(Type controllerType, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
HttpConfiguration configuration = registerSettings.Settings.HttpConfiguration();
if (configuration == null)
{
throw new ArgumentException(
"You must first specify an {0} instance using the HttpConfiguration key on {1}.Properties.".FormatInvariant(
typeof(HttpConfiguration).FullName,
typeof(CodeRoutingSettings).FullName
)
);
}
return(new DescribedHttpControllerInfo(
new HttpControllerDescriptor(
configuration,
controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length),
controllerType),
controllerType,
registerSettings,
provider
));
}
public SVDRegister(XElement node, string name, RegisterSettings settings, SVDPeripheral peripheral)
{
Name = name;
path = GetPath(node);
Peripheral = peripheral;
Size = settings.Size ?? throw new RecoverableException($"Size not provided for register '{path}'.");
// Register's size can be not dividable by 8
SizeInBytes = (uint)Math.Ceiling(Size / 8.0);
// Reset value assumed to be 0 if not provided. Maximum size of the register cropped to 32 bits.
ResetValue = (settings.ResetValue & 0xFFFFFFFF) ?? 0u;
if (Size > 32)
{
ResetValue = 0u;
Peripheral.ParentDevice.Parent.currentSystemBus.Log(
LogLevel.Warning,
"Register {0} size set to {1} bits. Registers larger than 32 bits are not supported. Reset value for this register is set to {2}.",
Name,
Size,
ResetValue
);
}
Address = settings.Address ?? throw new RecoverableException($"Address not provided for register '{path}'.");
Access = settings.Access ?? PermittedAccess.Read | PermittedAccess.Write;
}
protected ControllerInfo(Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
this.Type = type;
this.Register = registerSettings;
this.Provider = provider;
}
protected override ControllerInfo CreateControllerInfo(Type controllerType, RegisterSettings registerSettings)
{
return(MvcControllerInfo.Create(controllerType, registerSettings, this));
}
public MvcControllerInfo(Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
: base(type, registerSettings, provider)
{
}
public DescribedHttpControllerInfo(HttpControllerDescriptor controllerDescr, Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
: base(type, registerSettings, provider)
{
this.controllerDescr = controllerDescr;
}
protected ControllerInfo(Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
this.Type = type;
this.Register = registerSettings;
this.Provider = provider;
}
protected override ControllerInfo CreateControllerInfo(Type controllerType, RegisterSettings registerSettings) {
return MvcControllerInfo.Create(controllerType, registerSettings, this);
}
private void ScanRegistersAndClusters(XElement node, RegisterSettings defaultRegisterSettings, SVDPeripheral peripheral)
{
ScanClusters(node, defaultRegisterSettings, peripheral);
ScanRegisters(node, defaultRegisterSettings, peripheral);
}
public DescribedMvcControllerInfo(ControllerDescriptor controllerDescr, Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
: base(type, registerSettings, provider)
{
this.controllerDescr = controllerDescr;
}
public MvcControllerInfo(Type type, RegisterSettings registerSettings, CodeRoutingProvider provider)
: base(type, registerSettings, provider)
{
}
