public string GetUsage() { string usage = "Arguments:" + Environment.NewLine; // usage += ApplicationName + Environment.NewLine; string[] switchLine = new string[Switches.Length]; int maxWidth = 0; for (int i = 0; i < Switches.Length; i++) { SwitchInfo s = Switches[i]; switchLine[i] = "-" + s.Name; if (s.Aliases != null) { foreach (string alias in s.Aliases) { switchLine[i] += ", -" + alias; } } maxWidth = Math.Max(maxWidth, switchLine[i].Length); } for (int i = 0; i < Switches.Length; i++) { SwitchInfo s = Switches[i]; usage += (switchLine[i] + ":").PadRight(maxWidth + 5) + s.Description + ((s.Required) ? " (REQUIRED)" : "") + Environment.NewLine; } return(usage); }
private void EmitSwitchBuckets(SwitchInfo info, List <List <SwitchLabel> > buckets, int first, int last) { if (first == last) { EmitSwitchBucket(info, buckets[first]); return; } // Split the buckets into two groups, and use an if test to find // the right bucket. This ensures we'll only need O(lg(B)) tests // where B is the number of buckets int mid = (int)(((long)first + last + 1) / 2); if (first == mid - 1) { EmitSwitchBucket(info, buckets[first]); } else { // If the first half contains more than one, we need to emit an // explicit guard Label secondHalf = _ilg.DefineLabel(); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(buckets[mid - 1].Last().Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Bgt_Un : OpCodes.Bgt, secondHalf); EmitSwitchBuckets(info, buckets, first, mid - 1); _ilg.MarkLabel(secondHalf); } EmitSwitchBuckets(info, buckets, mid, last); }
public async Task <SwitchInfo> GetSwitchInfo() { var client = GetClient(cookies); var responseBody = await client.GetStringSafeAsync(GetUrl(connectionInfo, URLs.Index)); try { var switchInfo = new SwitchInfo(); var controllerName = ParseControllerName(responseBody); var newOutlets = ParseRelayName(responseBody); switchInfo.Name = controllerName; switchInfo.Outlets = new OutletInfo[newOutlets.Count]; int index = 0; foreach (var item in newOutlets) { switchInfo.Outlets[index++] = new OutletInfo() { Index = item.Index, Name = item.Name, IsOn = item.IsOn }; } return(switchInfo); } catch (Exception ex) { Console.WriteLine(ex); } return(null); }
public IHttpActionResult CreateSwitchInfo(SwitchInfoModel model) { try { if (ModelState.IsValid) { var switchinformation = new SwitchInfo(); switchinformation.HostName = model.HostName; switchinformation.SelectManufacturer = model.SelectManufacturer; switchinformation.Model = model.Model; switchinformation.OS = model.OS; switchinformation.OSVersion = model.OSVersion; switchinformation.ManufacturerPartNumber = model.ManufacturerPartNumber; switchinformation.SerialNumber = model.SerialNumber; switchinformation.InstallDate = model.InstallDate; switchinformation.WarrantyStarted = model.WarrantyStarted; switchinformation.WarrantyExpires = model.WarrantyExpires; switchinformation.UploadNetworkSwitchConfiguration = model.UploadNetworkSwitchConfiguration; switchinformation.Notes = model.Notes; switchinformation.SelectTag = model.SelectTag; switchinformation.CompanyId = model.CompanyId; db.SwitchInfoes.Add(switchinformation); db.SaveChanges(); return(Ok(switchinformation)); } else { return(Ok("Please Enter All the mandatory Fields")); } } catch (Exception ex) { return(Ok("" + ex.Message + "")); } }
void CreateSwitchInfos(ConfigNode node) { var si_list = node.GetNodes ("SwitchInfo"); switch_infos = new List<SwitchInfo> (); foreach (var si_node in si_list) { var si = new SwitchInfo (internalProp); si.Load (si_node); switch_infos.Add (si); } }
public void SwitchType() { SwitchInfo info = GameController.manager.doorMan.GetSwitchInfoById(id); if (info == null) { return; } info.SwitchType(); sr.sprite = spList[(int)info.colorType]; }
public static string ToDetailsString(this SwitchInfo switchInfo) { var sb = new StringBuilder(); sb.AppendLine($"Switch: {switchInfo.Name}"); foreach (var o in switchInfo.Outlets) { sb.AppendLine(o.ToDetailsString()); } return(sb.ToString()); }
public bool CanEnter() { bool sameControl = false; SwitchInfo switchInfo = GameController.manager.doorMan.GetSwitchInfoById(switchId); if (switchInfo == null) { return(false); } return(switchInfo.colorType == colorType); }
// CreateSwitch() public void CreateSwitch(SwitchInfo NewSwitch) { var db = new PocoDynamo(con.GetClient()); try { db.RegisterTable <SwitchInfo>(); db.PutItem(NewSwitch); } catch (Exception ex) { Debug.WriteLine("\nError \nUbicación: Capa DAL -> MSwitchInfo -> CreateSwitch(). \nDescripción: " + ex.Message); } }
public void CTOR_RecognizesValidFilePath_NonExistent() { //Arrange string[] args = new string[] { VALID_FILEPATH_NONEXISTENT }; bool expected = true; //Act SwitchInfo switchInfo = new SwitchInfo(args); bool actual = switchInfo.TargetFile == VALID_FILEPATH_NONEXISTENT; //Assert Assert.AreEqual(expected, actual); }
public void CTOR_RecognizesValidFilePath() { //Arrange string[] args = new string[] { Application_Test.GetAnyFile() }; bool expected = true; //Act SwitchInfo switchInfo = new SwitchInfo(args); bool actual = switchInfo.TargetFile == Application_Test.GetAnyFile(); //Assert Assert.AreEqual(expected, actual); }
public void CTOR_TakesR() { //Arrange string[] args = new string[] { "-r" }; bool expected = true; //Act SwitchInfo switchInfo = new SwitchInfo(args); bool actual = switchInfo.Mode == CryptoMode.Read; //Assert Assert.AreEqual(expected, actual); }
public void CTOR_RejectsInvalidFilePath() { //Arrange string[] args = new string[] { INVALID_FILEPATH }; bool expected = false; //Act SwitchInfo switchInfo = new SwitchInfo(args); bool actual = switchInfo.TargetFile == INVALID_FILEPATH; //Assert Assert.AreEqual(expected, actual); }
public static void CreateSwitch(string Type, string Switches, string Current, string Caliber, string Comments) { var IdSwitch = _tools.Decrypt(IdPanel) + "_" + Switches; var NewSwitch = new SwitchInfo { IdSwitch = _tools.Encrypt(IdSwitch), IdPanel = IdPanel, Type = _tools.Encrypt(_tools.Capitalize(Type)), Switches = _tools.Encrypt(Switches), Current = _tools.Encrypt(Current), Caliber = _tools.Encrypt(Caliber), Comments = _tools.Encrypt(_tools.Capitalize(Comments)), IsAvailable = true }; _switchInfo.CreateSwitch(NewSwitch); }
private void Start() { StartCoroutine(Util.DelayExecute(() => { return(GameController.manager.doorMan.initFinish); }, () => { SwitchInfo info = GameController.manager.doorMan.GetSwitchInfoById(id); Debug.Log(info); if (info == null) { return; } Debug.Log(info.colorType); sr.sprite = spList[(int)info.colorType]; sr.transform.localPosition = new Vector3(sr.transform.localPosition.x, sr.transform.localPosition.y, -0.1f); })); }
public void ParseDoorInfos() { JsonData controlData = JsonMapper.ToObject(Resources.Load <TextAsset>("DoorData/doors").text); foreach (JsonData item in controlData) { DoorInfo doorInfo = new DoorInfo(); doorInfo.id = (int)item["id"]; doorInfo.switchId = (int)item["switchId"]; doorInfo.colorType = (ColorType)(int)item["type"]; JsonData dt = item["rooms"]; for (int i = 0; i < dt.Count; i++) { doorInfo.roomList.Add((int)dt[i]); } doorInfoDict[doorInfo.id] = doorInfo; } JsonData normalData = JsonMapper.ToObject(Resources.Load <TextAsset>("DoorData/switches").text); foreach (JsonData item in normalData) { SwitchInfo switchInfo = new SwitchInfo(); switchInfo.id = (int)item["id"]; switchInfo.colorType = (ColorType)(int)item["type"]; switchInfoDict[switchInfo.id] = switchInfo; } JsonData enterData = JsonMapper.ToObject(Resources.Load <TextAsset>("DoorData/enters").text); foreach (JsonData item in enterData) { EnterInfo enterInfo = new EnterInfo(); enterInfo.id = (int)item["id"]; JsonData dt = item["rooms"]; for (int i = 0; i < dt.Count; i++) { enterInfo.roomList.Add((int)dt[i]); } enterInfoDict[enterInfo.id] = enterInfo; } initFinish = true; }
public EnumSwitchHandler(SwitchInfo switchInfo) : base(switchInfo) { }
// Tries to emit switch as a jmp table private bool TryEmitSwitchInstruction(SwitchExpression node, CompilationFlags flags) { // If we have a comparison, bail if (node.Comparison != null) { return false; } // Make sure the switch value type and the right side type // are types we can optimize Type type = node.SwitchValue.Type; if (!CanOptimizeSwitchType(type) || !TypeUtils.AreEquivalent(type, node.Cases[0].TestValues[0].Type)) { return false; } // Make sure all test values are constant, or we can't emit the // jump table. if (!node.Cases.All(c => c.TestValues.All(t => t is ConstantExpression))) { return false; } // // We can emit the optimized switch, let's do it. // // Build target labels, collect keys. var labels = new Label[node.Cases.Count]; var isGoto = new bool[node.Cases.Count]; var uniqueKeys = new Set<decimal>(); var keys = new List<SwitchLabel>(); for (int i = 0; i < node.Cases.Count; i++) { DefineSwitchCaseLabel(node.Cases[i], out labels[i], out isGoto[i]); foreach (ConstantExpression test in node.Cases[i].TestValues) { // Guarenteed to work thanks to CanOptimizeSwitchType. // // Use decimal because it can hold Int64 or UInt64 without // precision loss or signed/unsigned conversions. decimal key = ConvertSwitchValue(test.Value); // Only add each key once. If it appears twice, it's // allowed, but can't be reached. if (!uniqueKeys.Contains(key)) { keys.Add(new SwitchLabel(key, test.Value, labels[i])); uniqueKeys.Add(key); } } } // Sort the keys, and group them into buckets. keys.Sort((x, y) => Math.Sign(x.Key - y.Key)); var buckets = new List<List<SwitchLabel>>(); foreach (var key in keys) { AddToBuckets(buckets, key); } // Emit the switchValue LocalBuilder value = GetLocal(node.SwitchValue.Type); EmitExpression(node.SwitchValue); _ilg.Emit(OpCodes.Stloc, value); // Create end label, and default label if needed Label end = _ilg.DefineLabel(); Label @default = (node.DefaultBody == null) ? end : _ilg.DefineLabel(); // Emit the switch var info = new SwitchInfo(node, value, @default); EmitSwitchBuckets(info, buckets, 0, buckets.Count - 1); // Emit the case bodies and default EmitSwitchCases(node, labels, isGoto, @default, end, flags); FreeLocal(value); return true; }
public IntSwitchHandler(SwitchInfo switchInfo) : base(switchInfo) { }
} // With // Return a switch statement. public StmtFrag Switch( SrcLoc loc, ExprFrag switchValue, SwitchInfo switchInfo ) { // HACK snewman 8/15/01: implement switch statements. throw new ParseError( "Switch statements not yet implemented", loc ); } // Switch
EnumerateSwitch( string switchName) { ManagementScope scope = new ManagementScope(@"root\virtualization\v2"); // // Initialize our SwitchInfo structure to hold information about the switch. // SwitchInfo ethernetSwitchInfo = new SwitchInfo(); ethernetSwitchInfo.Name = switchName; ethernetSwitchInfo.Type = SwitchConnectionType.Private; ethernetSwitchInfo.PortList = new List <PortInfo>(); ethernetSwitchInfo.SwitchFeatureList = new List <NetworkingUtilities.SwitchFeatureType>(); using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope)) { // // Enumerate the switch's ports. // using (ManagementObjectCollection portCollection = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort", "Msvm_SystemDevice", null, null, null, null, false, null)) { foreach (ManagementObject port in portCollection) { using (port) { // // Initialize a PortInfo structure to hold information about this port. // PortInfo portInfo = new PortInfo(); portInfo.Type = PortConnectionType.Nothing; portInfo.FeatureList = new List <NetworkingUtilities.PortFeatureType>(); // // The port's connection settings are stored on its related // Msvm_EthernetPortAllocationSettingData object. // using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection( port.GetRelated("Msvm_EthernetPortAllocationSettingData", "Msvm_ElementSettingData", null, null, null, null, false, null))) { // // Determine the port's connection type. // portInfo.Type = DeterminePortType(portSettings); if (portInfo.Type == PortConnectionType.VirtualMachine) { // Get the name of the connected virtual machine. using (ManagementObject virtualMachineSettings = WmiUtilities.GetFirstObjectFromCollection( portSettings.GetRelated("Msvm_VirtualSystemSettingData", "Msvm_VirtualSystemSettingDataComponent", null, null, null, null, false, null))) { portInfo.ConnectedName = (string)virtualMachineSettings["ElementName"]; } } else if (portInfo.Type == PortConnectionType.External) { // Get the name of the external connection. using (ManagementObject externalAdapter = new ManagementObject( ((string[])portSettings["HostResource"])[0])) { portInfo.ConnectedName = (string)externalAdapter["ElementName"]; } } // // Now determine which advanced properties are configured for this port. // Each Feature has its own class definition and is related to the portSettings // through the Msvm_EthernetPortSettingDataComponent association. // using (ManagementObjectCollection portFeatureCollection = portSettings.GetRelated("Msvm_EthernetSwitchPortFeatureSettingData", "Msvm_EthernetPortSettingDataComponent", null, null, null, null, false, null)) { foreach (ManagementObject portFeature in portFeatureCollection) { using (portFeature) { portInfo.FeatureList.Add(DeterminePortFeatureType(portFeature)); } } } } ethernetSwitchInfo.PortList.Add(portInfo); } } } // // Then enumerate the switch's features. // using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection( ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData", "Msvm_SettingsDefineState", null, null, null, null, false, null))) using (ManagementObjectCollection switchFeatures = ethernetSwitchSetting.GetRelated( "Msvm_EthernetSwitchFeatureSettingData", "Msvm_VirtualEthernetSwitchSettingDataComponent", null, null, null, null, false, null)) foreach (ManagementObject switchFeature in switchFeatures) { using (switchFeature) { ethernetSwitchInfo.SwitchFeatureList.Add(DetermineSwitchFeatureType(switchFeature)); } } } // // Now that we have enumerated all of the switch's ports, we can determine the // switch's connection type. // ethernetSwitchInfo.Type = DetermineSwitchConnectionType(ethernetSwitchInfo.PortList); // // We now have all of the information we need - output it to the console. // OutputSwitchInfo(ethernetSwitchInfo); }
protected SwitchHandler(SwitchInfo switchInfo) { SwitchName = switchInfo.Name; SwitchProperty = switchInfo.PropertyInfo; DefaultValue = switchInfo.DefaultValue; }
public static SwitchHandler GetSwitchHandler(SwitchInfo switchInfo) { var switchType = switchInfo.PropertyInfo.PropertyType; if (switchType == typeof(bool)) { return new ToggleSwitchHandler(switchInfo); } if (switchType == typeof(int)) { return new IntSwitchHandler(switchInfo); } if (switchType == typeof(string)) { return new ValueSwitchHandler(switchInfo); } if (switchType.IsSubclassOf(typeof(Enum))) { return new EnumSwitchHandler(switchInfo); } throw new InvalidOperationException(string.Format("Unhandled type for switch {0}", switchInfo.Name)); }
private void EmitSwitchBucket(SwitchInfo info, List<SwitchLabel> bucket) { // No need for switch if we only have one value if (bucket.Count == 1) { _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(OpCodes.Beq, bucket[0].Label); return; } // // If we're switching off of Int64/UInt64, we need more guards here // because we'll have to narrow the switch value to an Int32, and // we can't do that unless the value is in the right range. // Label? after = null; if (info.Is64BitSwitch) { after = _ilg.DefineLabel(); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket.Last().Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Bgt_Un : OpCodes.Bgt, after.Value); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Blt_Un : OpCodes.Blt, after.Value); } _ilg.Emit(OpCodes.Ldloc, info.Value); // Normalize key decimal key = bucket[0].Key; if (key != 0) { _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(OpCodes.Sub); } if (info.Is64BitSwitch) { _ilg.Emit(OpCodes.Conv_I4); } // Collect labels int len = (int)(bucket[bucket.Count - 1].Key - bucket[0].Key + 1); Label[] jmpLabels = new Label[len]; // Initialize all labels to the default int slot = 0; foreach (SwitchLabel label in bucket) { while (key++ != label.Key) { jmpLabels[slot++] = info.Default; } jmpLabels[slot++] = label.Label; } // check we used all keys and filled all slots Debug.Assert(key == bucket[bucket.Count - 1].Key + 1); Debug.Assert(slot == jmpLabels.Length); // Finally, emit the switch instruction _ilg.Emit(OpCodes.Switch, jmpLabels); if (info.Is64BitSwitch) { _ilg.MarkLabel(after.Value); } }
OutputSwitchInfo( SwitchInfo switchInfo) { Console.WriteLine("Successfully enumerated the ports and port features of the switch '{0}'\n", switchInfo.Name); Console.WriteLine("The switch's connection type is:"); Console.WriteLine(" {0}\n", switchInfo.Type); // // If the switch is connected to an external network, output the name of the network. // if (switchInfo.Type == SwitchConnectionType.External || switchInfo.Type == SwitchConnectionType.ExternalOnly) { Console.WriteLine("The switch is connected to the following network:"); foreach (PortInfo portInfo in switchInfo.PortList) { if (portInfo.Type == PortConnectionType.External) { Console.WriteLine(" {0}", portInfo.ConnectedName); } } Console.WriteLine(); } // // Output the virtual machines that are currently connected to this switch. // Console.WriteLine("The switch is connected to the following virtual machines:"); bool atLeastOneVirtualMachine = false; foreach (string virtualMachineName in GetConnectedVirtualMachineList(switchInfo.PortList)) { atLeastOneVirtualMachine = true; Console.WriteLine(" {0}", virtualMachineName); } if (!atLeastOneVirtualMachine) { Console.WriteLine(" The switch is not connected to any virtual machines"); } Console.WriteLine(); // // Output the advanced features that have been configured for the switch. // Console.WriteLine("The switch has the following advanced features: "); if (switchInfo.SwitchFeatureList.Count > 0) { foreach (NetworkingUtilities.SwitchFeatureType featureType in switchInfo.SwitchFeatureList) { Console.WriteLine(" {0}", featureType.ToString()); } } else { Console.WriteLine(" The switch has no advanced features"); } Console.WriteLine(); // // Now output information about features for each port. // Console.WriteLine("The switch is connected to {0} ports.", switchInfo.PortList.Count); if (switchInfo.PortList.Count > 0) { Console.WriteLine("Outputting port features for each port:\n"); int count = 1; foreach (PortInfo portInfo in switchInfo.PortList) { switch (portInfo.Type) { case PortConnectionType.VirtualMachine: Console.WriteLine(" Port {0} connected to virtual machine '{1}' has the following features:", count, portInfo.ConnectedName); break; case PortConnectionType.External: Console.WriteLine(" Port {0} connected to the external network '{1}' has the following features:", count, portInfo.ConnectedName); break; case PortConnectionType.Internal: Console.WriteLine(" Port {0} connected to the internal network has the following features:", count); break; case PortConnectionType.Nothing: Console.WriteLine(" Port {0} not connected to anything has the following features:", count); break; } if (portInfo.FeatureList.Count > 0) { foreach (NetworkingUtilities.PortFeatureType featureType in portInfo.FeatureList) { Console.WriteLine(" {0}", featureType.ToString()); } } else { Console.WriteLine(" The port has no advanced features"); } count++; Console.WriteLine(); } } }
public ToggleSwitchHandler(SwitchInfo switchInfo) : base(switchInfo) { }
EnumerateSwitch( string switchName) { ManagementScope scope = new ManagementScope(@"root\virtualization\v2"); // // Initialize our SwitchInfo structure to hold information about the switch. // SwitchInfo ethernetSwitchInfo = new SwitchInfo(); ethernetSwitchInfo.Name = switchName; ethernetSwitchInfo.Type = SwitchConnectionType.Private; ethernetSwitchInfo.PortList = new List<PortInfo>(); ethernetSwitchInfo.SwitchFeatureList = new List<NetworkingUtilities.SwitchFeatureType>(); using (ManagementObject ethernetSwitch = NetworkingUtilities.FindEthernetSwitch(switchName, scope)) { // // Enumerate the switch's ports. // using (ManagementObjectCollection portCollection = ethernetSwitch.GetRelated("Msvm_EthernetSwitchPort", "Msvm_SystemDevice", null, null, null, null, false, null)) { foreach (ManagementObject port in portCollection) using (port) { // // Initialize a PortInfo structure to hold information about this port. // PortInfo portInfo = new PortInfo(); portInfo.Type = PortConnectionType.Nothing; portInfo.FeatureList = new List<NetworkingUtilities.PortFeatureType>(); // // The port's connection settings are stored on its related // Msvm_EthernetPortAllocationSettingData object. // using (ManagementObject portSettings = WmiUtilities.GetFirstObjectFromCollection( port.GetRelated("Msvm_EthernetPortAllocationSettingData", "Msvm_ElementSettingData", null, null, null, null, false, null))) { // // Determine the port's connection type. // portInfo.Type = DeterminePortType(portSettings); if (portInfo.Type == PortConnectionType.VirtualMachine) { // Get the name of the connected virtual machine. using (ManagementObject virtualMachineSettings = WmiUtilities.GetFirstObjectFromCollection( portSettings.GetRelated("Msvm_VirtualSystemSettingData", "Msvm_VirtualSystemSettingDataComponent", null, null, null, null, false, null))) { portInfo.ConnectedName = (string)virtualMachineSettings["ElementName"]; } } else if (portInfo.Type == PortConnectionType.External) { // Get the name of the external connection. using (ManagementObject externalAdapter = new ManagementObject( ((string[])portSettings["HostResource"])[0])) { portInfo.ConnectedName = (string)externalAdapter["ElementName"]; } } // // Now determine which advanced properties are configured for this port. // Each Feature has its own class definition and is related to the portSettings // through the Msvm_EthernetPortSettingDataComponent association. // using (ManagementObjectCollection portFeatureCollection = portSettings.GetRelated("Msvm_EthernetSwitchPortFeatureSettingData", "Msvm_EthernetPortSettingDataComponent", null, null, null, null, false, null)) { foreach (ManagementObject portFeature in portFeatureCollection) using (portFeature) { portInfo.FeatureList.Add(DeterminePortFeatureType(portFeature)); } } } ethernetSwitchInfo.PortList.Add(portInfo); } } // // Then enumerate the switch's features. // using (ManagementObject ethernetSwitchSetting = WmiUtilities.GetFirstObjectFromCollection( ethernetSwitch.GetRelated("Msvm_VirtualEthernetSwitchSettingData", "Msvm_SettingsDefineState", null, null, null, null, false, null))) using (ManagementObjectCollection switchFeatures = ethernetSwitchSetting.GetRelated( "Msvm_EthernetSwitchFeatureSettingData", "Msvm_VirtualEthernetSwitchSettingDataComponent", null, null, null, null, false, null)) foreach (ManagementObject switchFeature in switchFeatures) using (switchFeature) { ethernetSwitchInfo.SwitchFeatureList.Add(DetermineSwitchFeatureType(switchFeature)); } } // // Now that we have enumerated all of the switch's ports, we can determine the // switch's connection type. // ethernetSwitchInfo.Type = DetermineSwitchConnectionType(ethernetSwitchInfo.PortList); // // We now have all of the information we need - output it to the console. // OutputSwitchInfo(ethernetSwitchInfo); }
public ValueSwitchHandler(SwitchInfo switchInfo) : base(switchInfo) { _pattern = string.Format(@"^-{0}:((""(.+)"")|([^""]\S*))", switchInfo.Name); }
} // ParseForStatement // Parse a Statement. private StmtFrag ParseStatement(FunctionInfo info) { StringCollection labels = MatchLabelSet(); if (tok.TryMatchKeyword("do")) { LoopInfo loopInfo = gen.NewLoopInfo( curCGFuncInfo, tok.Prev().loc, labels ); loops.Push(loopInfo); StmtFrag body = ParseStatement(info); tok.MatchKeyword("while"); tok.MatchOp("("); ExprFrag condition = ParseExpression(info, true); tok.MatchOp(")"); tok.MatchOp(";"); LoopInfo temp = (LoopInfo) loops.Pop(); Trace.Assert(temp == loopInfo); return gen.DoWhile(loopInfo, body, condition); } else if (tok.TryMatchKeyword("while")) { LoopInfo loopInfo = gen.NewLoopInfo( curCGFuncInfo, tok.Prev().loc, labels ); loops.Push(loopInfo); tok.MatchOp("("); ExprFrag condition = ParseExpression(info, true); tok.MatchOp(")"); StmtFrag body = ParseStatement(info); LoopInfo temp = (LoopInfo) loops.Pop(); Trace.Assert(temp == loopInfo); return gen.WhileDo(loopInfo, condition, body); } else if (tok.TryMatchKeyword("for")) return ParseForStatement(info, labels); else { bool isSwitch = tok.PeekKeyword("switch"); LoopInfo labelInfo = null; if (labels != null || isSwitch) { labelInfo = gen.NewLabeledStmtInfo( curCGFuncInfo, tok.Prev().loc, labels, isSwitch ); loops.Push(labelInfo); } StmtFrag stmt; if (tok.PeekOp("{")) stmt = ParseBlock(info); else if (tok.TryMatchKeyword("var")) { stmt = gen.NewStmtFrag(tok.Prev().loc); do { string varName; SrcLoc varLoc; stmt.Append(ParseVariableDeclaration( info, true, out varName, out varLoc )); } while (tok.TryMatchOp(",")); tok.MatchOp(";"); } else if (tok.TryMatchOp(";")) { // EmptyStatement stmt = gen.NewStmtFrag(tok.Prev().loc); } else if (tok.TryMatchKeyword("if")) { SrcLoc ifLoc = tok.Prev().loc; tok.MatchOp("("); ExprFrag condition = ParseExpression(info, true); tok.MatchOp(")"); StmtFrag ifClause = ParseStatement(info); StmtFrag elseClause = null; if (tok.TryMatchKeyword("else")) elseClause = ParseStatement(info); stmt = gen.IfThenElse(ifLoc, condition, ifClause, elseClause); } else if (tok.TryMatchKeyword("continue")) { SrcLoc continueLoc = tok.Prev().loc; // HACK snewman 8/7/01: the grammar (ContinueStatement) specifies // "no LineTerminator here". string id; tok.TryMatchID(out id); tok.MatchOp(";"); stmt = gen.Continue(continueLoc, id, CloneStack(loops)); } else if (tok.TryMatchKeyword("break")) { SrcLoc breakLoc = tok.Prev().loc; // HACK snewman 8/7/01: the grammar (BreakStatement) specifies // "no LineTerminator here". string id; tok.TryMatchID(out id); tok.MatchOp(";"); stmt = gen.Break(breakLoc, id, CloneStack(loops)); } else if (tok.TryMatchKeyword("return")) { SrcLoc returnLoc = tok.Prev().loc; // HACK snewman 8/7/01: the grammar (ReturnStatement) specifies // "no LineTerminator here". if (tok.TryMatchOp(";")) stmt = gen.Return(returnLoc, null); else { ExprFrag value = ParseExpression(info, true); tok.MatchOp(";"); stmt = gen.Return(returnLoc, value); } } else if (tok.TryMatchKeyword("with")) { SrcLoc withLoc = tok.Prev().loc; tok.MatchOp("("); ExprFrag value = ParseExpression(info, true); tok.MatchOp(")"); WithInfo withInfo = gen.NewWithInfo(curCGFuncInfo, withLoc); withs.Push(withInfo); StmtFrag body = ParseStatement(info); WithInfo temp = (WithInfo) withs.Pop(); Trace.Assert(temp == withInfo); stmt = gen.With(withInfo, value, body); } else if (tok.TryMatchKeyword("switch")) { SrcLoc switchLoc = tok.Prev().loc; SwitchInfo switchInfo = gen.NewSwitchInfo(); tok.MatchOp("("); ExprFrag switchValue = ParseExpression(info, true); tok.MatchOp(")"); tok.MatchOp("{"); while (!tok.TryMatchOp("}")) { ExprFrag caseValue; if (tok.TryMatchKeyword("default")) caseValue = null; else { tok.MatchKeyword("case"); caseValue = ParseExpression(info, true); } StmtFrag clauseStmt = null; tok.MatchOp(":"); while ( !tok.PeekOp("}") && !tok.PeekKeyword("case") && !tok.PeekKeyword("default") ) { StmtFrag tempStmt = ParseStatement(info); if (clauseStmt == null) clauseStmt = tempStmt; else clauseStmt.Append(tempStmt); } switchInfo.AddCase(caseValue, clauseStmt); } stmt = gen.Switch(switchLoc, switchValue, switchInfo); } else if (tok.TryMatchKeyword("throw")) { SrcLoc throwLoc = tok.Prev().loc; // HACK snewman 8/7/01: the grammar (ThrowStatement) specifies // "no LineTerminator here". ExprFrag value = ParseExpression(info, true); tok.MatchOp(";"); stmt = gen.Throw(throwLoc, value); } else if (tok.TryMatchKeyword("try")) { SrcLoc tryLoc = tok.Prev().loc; StmtFrag tryBody = ParseBlock(info); String catchVar = null; WithInfo catchWithInfo = null; StmtFrag catchBody = null; StmtFrag finallyBody = null; if (tok.TryMatchKeyword("catch")) { SrcLoc catchLoc = tok.Prev().loc; tok.MatchOp("("); catchVar = tok.MatchID(); tok.MatchOp(")"); catchWithInfo = gen.NewWithInfo(curCGFuncInfo, catchLoc); withs.Push(catchWithInfo); catchBody = ParseBlock(info); WithInfo temp = (WithInfo) withs.Pop(); Trace.Assert(temp == catchWithInfo); } if (tok.TryMatchKeyword("finally")) finallyBody = ParseBlock(info); stmt = gen.TryCatchFinally( tryLoc, tryBody, catchVar, catchWithInfo, catchBody, finallyBody ); } else { ExprFrag expr = ParseExpression(info, true); tok.MatchOp(";"); stmt = gen.ExpressionStmt(expr); } if (labelInfo != null) { LoopInfo temp2 = (LoopInfo) loops.Pop(); Trace.Assert(temp2 == labelInfo); stmt = gen.LabeledStmt(labelInfo, stmt); } return stmt; } } // ParseStatement
private void EmitSwitchBuckets(SwitchInfo info, List<List<SwitchLabel>> buckets, int first, int last) { if (first == last) { EmitSwitchBucket(info, buckets[first]); return; } // Split the buckets into two groups, and use an if test to find // the right bucket. This ensures we'll only need O(lg(B)) tests // where B is the number of buckets int mid = (int)(((long)first + last + 1) / 2); if (first == mid - 1) { EmitSwitchBucket(info, buckets[first]); } else { // If the first half contains more than one, we need to emit an // explicit guard Label secondHalf = _ilg.DefineLabel(); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(buckets[mid - 1].Last().Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Bgt_Un : OpCodes.Bgt, secondHalf); EmitSwitchBuckets(info, buckets, first, mid - 1); _ilg.MarkLabel(secondHalf); } EmitSwitchBuckets(info, buckets, mid, last); }
public void read(Reader reader) { foreach (ScriptSub sub in subs) { sub.scriptCode.Clear(); sub.blankLines.Clear(); sub.labels.Clear(); sub.jumpTable.Clear(); bool finishedScriptCode = false; int scriptCodeLength = reader.ReadByte() << 8; scriptCodeLength |= reader.ReadByte(); sub.scriptCode.Clear(); while (!finishedScriptCode) { byte scriptOpcode = reader.ReadByte(); if (scriptOpcode == 0xFF) { scriptOpcode = reader.ReadByte(); if (scriptOpcode == 0xFF) { scriptOpcode = reader.ReadByte(); if (scriptOpcode == 0xFF) { scriptOpcode = reader.ReadByte(); if (scriptOpcode == 0xFF) { finishedScriptCode = true; } } } } if (!finishedScriptCode) { OpcodeInfo opInfo = new OpcodeInfo(); opInfo.opcode = scriptOpcode; uint paramCount = (uint)opcodeList[scriptOpcode].paramCount; opInfo.parameters.Clear(); for (int p = 0; p < paramCount; p++) { ParamInfo param = new ParamInfo(); int paramType = reader.ReadByte(); // if 0 then int constant, else variable if (paramType != 0) { param.isVariable = true; param.value = reader.ReadByte(); int arrayIndex = reader.ReadByte(); if (arrayIndex > 0x80) { arrayIndex = 0x80 - arrayIndex; } param.arrayIndex = (sbyte)arrayIndex; } else { param.isVariable = false; param.arrayIndex = -1; int byte1 = reader.ReadByte(); int constVal = 0; if (byte1 < 0x80) // unsigned uint16 { constVal = byte1 << 8; constVal |= reader.ReadByte(); } else // signed uint16 { constVal = (byte1 - 0x80) << 8; constVal |= reader.ReadByte(); constVal = -constVal; } param.value = constVal; } opInfo.parameters.Add(param); } sub.scriptCode.Add(opInfo); } } int blankLineUnused = reader.ReadByte(); int blankLineCount = reader.ReadByte(); for (int u = 0; u < blankLineCount; u++) { int blankLineID = reader.ReadByte() << 8; blankLineID |= reader.ReadByte(); sub.blankLines.Add(blankLineID); } int labelUnused = reader.ReadByte(); int labelCount = reader.ReadByte(); for (int l = 0; l < labelCount; l++) { LabelInfo label = new LabelInfo(); label.scriptCodePos = reader.ReadByte() << 8; label.scriptCodePos |= reader.ReadByte(); label.id = reader.ReadByte() << 8; label.id |= reader.ReadByte(); label.lineID = reader.ReadByte() << 8; label.lineID |= reader.ReadByte(); sub.labels.Add(label); } int jumpTableUnused = reader.ReadByte(); int jumpTableCount = reader.ReadByte(); for (int s = 0; s < jumpTableCount; ++s) { SwitchInfo info = new SwitchInfo(); info.scriptCodePos = reader.ReadByte() << 8; info.scriptCodePos |= reader.ReadByte(); int caseCount = reader.ReadByte() << 8; caseCount |= reader.ReadByte(); info.defaultScriptCodePos = reader.ReadByte() << 8; info.defaultScriptCodePos |= reader.ReadByte(); info.defaultCaseLineID = reader.ReadByte() << 8; info.defaultCaseLineID |= reader.ReadByte(); info.endScriptCodePos = reader.ReadByte() << 8; info.endScriptCodePos |= reader.ReadByte(); // if (info.defaultScriptCodePos == 0) // info.defaultScriptCodePos = info.endScriptCodePos; int lowestCase = 0x8000; int highestCase = 0; info.cases.Clear(); for (int c = 0; c < caseCount; c++) { SwitchCaseInfo caseInfo = new SwitchCaseInfo(); caseInfo.scriptCodePos = reader.ReadByte() << 8; caseInfo.scriptCodePos |= reader.ReadByte(); caseInfo.caseNum = reader.ReadByte() << 8; caseInfo.caseNum |= reader.ReadByte(); if (caseInfo.caseNum < lowestCase) { lowestCase = caseInfo.caseNum; } if (caseInfo.caseNum > highestCase) { highestCase = caseInfo.caseNum; } caseInfo.lineID = reader.ReadByte() << 8; caseInfo.lineID |= reader.ReadByte(); info.cases.Add(caseInfo); } info.lowestCase = lowestCase; info.highestCase = highestCase; // Take any duds and make em default cases // for (int m = lowestCase; m <= highestCase; ++m) // { // int jump = sub.scriptCode[caseTablePos + m]; // if (jump == 0) // sub.scriptCode[caseTablePos + m] = sub.jumpTable[startSwitchTablePos + 2]; // } // wow this is weird // it manually goes and sets up the offsets instead of doing it at compile-time like later RSDK versions int pos = 0; foreach (OpcodeInfo opcodeInfo in sub.scriptCode) { if (pos == info.scriptCodePos) { opcodeInfo.parameters[1].value = pos; break; } pos += opcodeInfo.size; } sub.jumpTable.Add(info); } } reader.Close(); }
// Tries to emit switch as a jmp table private bool TryEmitSwitchInstruction(SwitchExpression node, CompilationFlags flags) { // If we have a comparison, bail if (node.Comparison != null) { return(false); } // Make sure the switch value type and the right side type // are types we can optimize Type type = node.SwitchValue.Type; if (!CanOptimizeSwitchType(type) || !TypeUtils.AreEquivalent(type, node.Cases[0].TestValues[0].Type)) { return(false); } // Make sure all test values are constant, or we can't emit the // jump table. if (!node.Cases.All(c => c.TestValues.All(t => t is ConstantExpression))) { return(false); } // // We can emit the optimized switch, let's do it. // // Build target labels, collect keys. var labels = new Label[node.Cases.Count]; var isGoto = new bool[node.Cases.Count]; var uniqueKeys = new HashSet <decimal>(); var keys = new List <SwitchLabel>(); for (int i = 0; i < node.Cases.Count; i++) { DefineSwitchCaseLabel(node.Cases[i], out labels[i], out isGoto[i]); foreach (ConstantExpression test in node.Cases[i].TestValues) { // Guaranteed to work thanks to CanOptimizeSwitchType. // // Use decimal because it can hold Int64 or UInt64 without // precision loss or signed/unsigned conversions. decimal key = ConvertSwitchValue(test.Value); // Only add each key once. If it appears twice, it's // allowed, but can't be reached. if (uniqueKeys.Add(key)) { keys.Add(new SwitchLabel(key, test.Value, labels[i])); } } } // Sort the keys, and group them into buckets. keys.Sort((x, y) => Math.Sign(x.Key - y.Key)); var buckets = new List <List <SwitchLabel> >(); foreach (var key in keys) { AddToBuckets(buckets, key); } // Emit the switchValue LocalBuilder value = GetLocal(node.SwitchValue.Type); EmitExpression(node.SwitchValue); _ilg.Emit(OpCodes.Stloc, value); // Create end label, and default label if needed Label end = _ilg.DefineLabel(); Label @default = (node.DefaultBody == null) ? end : _ilg.DefineLabel(); // Emit the switch var info = new SwitchInfo(node, value, @default); EmitSwitchBuckets(info, buckets, 0, buckets.Count - 1); // Emit the case bodies and default EmitSwitchCases(node, labels, isGoto, @default, end, flags); FreeLocal(value); return(true); }
private void EmitSwitchBucket(SwitchInfo info, List <SwitchLabel> bucket) { // No need for switch if we only have one value if (bucket.Count == 1) { _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(OpCodes.Beq, bucket[0].Label); return; } // // If we're switching off of Int64/UInt64, we need more guards here // because we'll have to narrow the switch value to an Int32, and // we can't do that unless the value is in the right range. // Label?after = null; if (info.Is64BitSwitch) { after = _ilg.DefineLabel(); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket.Last().Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Bgt_Un : OpCodes.Bgt, after.Value); _ilg.Emit(OpCodes.Ldloc, info.Value); _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(info.IsUnsigned ? OpCodes.Blt_Un : OpCodes.Blt, after.Value); } _ilg.Emit(OpCodes.Ldloc, info.Value); // Normalize key decimal key = bucket[0].Key; if (key != 0) { _ilg.EmitConstant(bucket[0].Constant); _ilg.Emit(OpCodes.Sub); } if (info.Is64BitSwitch) { _ilg.Emit(OpCodes.Conv_I4); } // Collect labels int len = (int)(bucket[bucket.Count - 1].Key - bucket[0].Key + 1); Label[] jmpLabels = new Label[len]; // Initialize all labels to the default int slot = 0; foreach (SwitchLabel label in bucket) { while (key++ != label.Key) { jmpLabels[slot++] = info.Default; } jmpLabels[slot++] = label.Label; } // check we used all keys and filled all slots Debug.Assert(key == bucket[bucket.Count - 1].Key + 1); Debug.Assert(slot == jmpLabels.Length); // Finally, emit the switch instruction _ilg.Emit(OpCodes.Switch, jmpLabels); if (info.Is64BitSwitch) { _ilg.MarkLabel(after.Value); } }
// CreateSwitch() public void CreateSwitch(SwitchInfo NewSwitch) { _switchInfo.CreateSwitch(NewSwitch); }