public void AddInnerMessageToLast(
Diagnostics.MessageKind kind, Diagnostics.MessageCode code,
string text, params Diagnostics.Span[] spans)
{
var msg = Diagnostics.Message.Make(code, text, kind, spans);
this.messages[this.messages.Count - 1].SetInner(msg);
}
/// <summary>
/// Initializes a new instance of the ServerLink class.
/// </summary>
protected ServerLink(string name)
: base(name)
{
sessions = new SortedList<int, LinkSession>();
Diag = new Diagnostics();
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public virtual void Process(PipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
Order order = args.CustomData["order"] as Order;
if (order == null)
{
return;
}
BusinessCatalogSettings businnesCatalogSettings = Context.Entity.GetConfiguration<BusinessCatalogSettings>();
Item companyMasterData = Sitecore.Context.Database.SelectSingleItem(businnesCatalogSettings.CompanyMasterDataLink);
if (companyMasterData == null)
{
return;
}
string queryString = string.Format("orderid={0}&mode=mail", order.OrderNumber);
Item saleDepartment = companyMasterData.Children["Sale"];
var saleParams = new { Recipient = saleDepartment["Email"] };
IMail mailProvider = Context.Entity.Resolve<IMail>();
mailProvider.SendMail("Order Mail To Admin", saleParams, queryString);
}
public void AddMessage(
Diagnostics.MessageKind kind, Diagnostics.MessageCode code,
string text, params Diagnostics.Span[] spans)
{
var msg = Diagnostics.Message.Make(code, text, kind, spans);
msg.SetContext(this.contextStack);
this.messages.Add(msg);
}
public int CreateBinding(Core.Name name, int registerIndex, Diagnostics.Span span)
{
var binding = new LocalBinding();
binding.name = name;
binding.registerIndex = registerIndex;
binding.declSpan = span;
this.localBindings.Add(binding);
return this.localBindings.Count - 1;
}
public bool HasMessagesWithCode(Diagnostics.MessageCode code)
{
foreach (var message in this.messages)
{
if (message.GetCode() == code)
return true;
}
return false;
}
/// <summary>
/// Initializes a new instance of the ServerLink class.
/// </summary>
protected ServerLink(string name)
: base(name)
{
sessions = new SortedList<int, LinkSession>();
recoverable = new Dictionary<string, LinkSession>();
recoveryTokens = new Dictionary<int, Binder.Token>();
Diag = new Diagnostics();
}
public static InstructionMoveLiteralStruct Of(
Diagnostics.Span span, DataAccess destination, int structIndex,
DataAccess[] fieldSources, Diagnostics.Span[] fieldDestSpans)
{
return new InstructionMoveLiteralStruct
{
span = span,
destination = destination,
structIndex = structIndex,
fieldSources = fieldSources,
fieldDestSpans = fieldDestSpans
};
}
public static InstructionMoveCallResult For(
Diagnostics.Span span,
DataAccess destination,
DataAccess callTarget,
DataAccess[] arguments)
{
return new InstructionMoveCallResult
{
span = span,
destination = destination,
callTargetSource = callTarget,
argumentSources = arguments
};
}
/// <summary>
/// Initializes a new instance of the LinkSession class.
/// </summary>
protected LinkSession(SessionBasedLink link)
{
handle = handlePool.Acquire();
this.link = link;
rxBuffer = new Buffer();
rxBufferList = new List<ArraySegment<byte>>();
txBufferList = new List<ArraySegment<byte>>();
eventsSending = new List<Event>();
eventsToSend = new List<Event>();
buffersSending = new List<SendBuffer>();
Diag = new Diagnostics(this);
}
public AmqpSession(AmqpConnection connection, AmqpSessionSettings settings, ILinkFactory linkFactory)
{
Fx.Assert(connection != null, "connection must not be null");
Fx.Assert(settings != null, "settings must not be null");
this.connection = connection;
this.settings = settings;
this.linkFactory = linkFactory;
this.State = AmqpObjectState.Start;
this.links = new Dictionary<string, AmqpLink>();
this.linksByLocalHandle = new HandleTable<AmqpLink>(uint.MaxValue);
this.linksByRemoteHandle = new HandleTable<AmqpLink>(uint.MaxValue);
this.outgoingChannel = new OutgoingSessionChannel(this);
this.incomingChannel = new IncomingSessionChannel(this);
this.diagnostics = new Diagnostics();
}
protected Socket socket; // underlying socket
#endregion Fields
#region Constructors
protected SocketLinkSession(SocketLink link, Socket socket)
: base(socket.Handle)
{
this.link = link;
this.socket = socket;
sendQueue = new Queue<Event>();
recvBuffer = new Buffer(12);
sendBuffer = new Buffer(12);
recvBufferList = new List<ArraySegment<byte>>();
sendBufferList = new List<ArraySegment<byte>>();
Diag = new Diagnostics(this);
}
/// <summary>
/// Initializes a new instance of the AbsractUdpLink class.
/// </summary>
protected AbstractUdpLink(string name)
: base(name)
{
map = new SortedList<int, EndPoint>();
reverseMap = new Dictionary<EndPoint, int>();
socket = new Socket(IPAddress.Any.AddressFamily,
SocketType.Dgram, ProtocolType.Udp);
rxBuffer = new Buffer();
txBuffer = new Buffer();
txQueue = new Queue<Event>();
rwlock = new ReaderWriterLockSlim();
Diag = new Diagnostics();
}
/// <summary>
/// Initializes a new instance of the LinkSession class.
/// </summary>
protected LinkSession(SessionBasedLink link)
{
this.link = link;
rxBuffer = new Buffer();
rxBufferList = new List<ArraySegment<byte>>();
txBufferList = new List<ArraySegment<byte>>();
eventsSending = new List<Event>();
eventsToSend = new List<Event>();
buffersSending = new List<SendBuffer>();
buffersSent = new List<SendBuffer>();
if (link.SessionRecoveryEnabled)
{
preConnectionQueue = new List<Event>();
}
Diag = new Diagnostics(this);
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public virtual void Process(PipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
Order order = args.CustomData["order"] as Order;
if (order == null)
{
return;
}
IMail mailProvider = Context.Entity.Resolve<IMail>();
string queryString = string.Format("orderid={0}&mode=mail", order.OrderNumber);
var param = new
{
Recipient = order.CustomerInfo.Email
};
mailProvider.SendMail("Order Mail To Customer", param, queryString);
}
public bool ValidateSingleDecl(List<DeclReference> decls, Name origName, Diagnostics.Span span)
{
if (decls.Count == 0)
{
this.AddMessage(
Diagnostics.MessageKind.Error,
Diagnostics.MessageCode.Unknown,
"unknown '" + origName.GetString() + "'",
span);
return false;
}
else if (decls.Count > 1)
{
this.AddMessage(
Diagnostics.MessageKind.Error,
Diagnostics.MessageCode.AmbiguousDeclaration,
"ambiguous '" + origName.GetString() + "' between " +
"'" + this.GetDeclName(decls[0]).GetString() + "'" +
(decls.Count == 2 ? " and " : ", ") +
"'" + this.GetDeclName(decls[1]).GetString() + "'" +
(decls.Count > 2 ? ", and other " + (decls.Count - 2) : ""),
span);
return false;
}
else
return true;
}
internal static GraphicalHostReflectionWrapper GetGraphicalHostReflectionWrapper(PSCmdlet parentCmdlet, string graphicalHostHelperTypeName, string featureName)
{
GraphicalHostReflectionWrapper returnValue = new GraphicalHostReflectionWrapper();
if (GraphicalHostReflectionWrapper.IsInputFromRemoting(parentCmdlet))
{
ErrorRecord error = new ErrorRecord(
new NotSupportedException(StringUtil.Format(HelpErrors.RemotingNotSupportedForFeature, featureName)),
"RemotingNotSupported",
ErrorCategory.InvalidOperation,
parentCmdlet);
parentCmdlet.ThrowTerminatingError(error);
}
// Prepare the full assembly name.
AssemblyName graphicalHostAssemblyName = new AssemblyName();
graphicalHostAssemblyName.Name = "Microsoft.PowerShell.GraphicalHost";
graphicalHostAssemblyName.Version = new Version(3, 0, 0, 0);
graphicalHostAssemblyName.CultureInfo = new CultureInfo(string.Empty); // Neutral culture
graphicalHostAssemblyName.SetPublicKeyToken(new byte[] { 0x31, 0xbf, 0x38, 0x56, 0xad, 0x36, 0x4e, 0x35 });
try
{
returnValue._graphicalHostAssembly = Assembly.Load(graphicalHostAssemblyName);
}
catch (FileNotFoundException fileNotFoundEx)
{
// This exception is thrown if the Microsoft.PowerShell.GraphicalHost.dll could not be found (was not installed).
string errorMessage = StringUtil.Format(
HelpErrors.GraphicalHostAssemblyIsNotFound,
featureName,
fileNotFoundEx.Message);
parentCmdlet.ThrowTerminatingError(
new ErrorRecord(
new NotSupportedException(errorMessage, fileNotFoundEx),
"ErrorLoadingAssembly",
ErrorCategory.ObjectNotFound,
graphicalHostAssemblyName));
}
catch (Exception e)
{
parentCmdlet.ThrowTerminatingError(
new ErrorRecord(
e,
"ErrorLoadingAssembly",
ErrorCategory.ObjectNotFound,
graphicalHostAssemblyName));
}
returnValue._graphicalHostHelperType = returnValue._graphicalHostAssembly.GetType(graphicalHostHelperTypeName);
Diagnostics.Assert(returnValue._graphicalHostHelperType != null, "the type exists in Microsoft.PowerShell.GraphicalHost");
ConstructorInfo constructor = returnValue._graphicalHostHelperType.GetConstructor(
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new Type[] { },
null);
if (constructor != null)
{
returnValue._graphicalHostHelperObject = constructor.Invoke(new object[] { });
Diagnostics.Assert(returnValue._graphicalHostHelperObject != null, "the constructor does not throw anything");
}
return(returnValue);
}
public int GetColumnAtSpanEnd(Diagnostics.Span span)
{
return this.GetColumnAtPos(span.end);
}
private bool AreAllTargetEnemyDead(QuestBehaviour questBehaviour, EventEncounterStateChange e)
{
if (this.EnemyArmyGUIDs != null)
{
if (questBehaviour.Quest.QuestDefinition.Category != "GlobalQuest" && !this.IgnoreDisbandedArmies)
{
for (int i = 0; i < this.EnemyArmyGUIDs.Length; i++)
{
IGameEntity gameEntity;
this.gameEntityRepositoryService.TryGetValue(this.EnemyArmyGUIDs[i], out gameEntity);
if (gameEntity != null)
{
break;
}
if (gameEntity == null && i == this.EnemyArmyGUIDs.Length - 1)
{
return(true);
}
}
}
bool flag = true;
for (int j = 0; j < this.EnemyArmyGUIDs.Length; j++)
{
ulong enemyArmyGUID = this.EnemyArmyGUIDs[j];
if (enemyArmyGUID == 0UL)
{
Diagnostics.LogError("Enemy contender corresponding to quest variable (varname: '{0}') isn't valid in quest definition (name: '{1}')", new object[]
{
this.EnemyArmyGUIDs[j],
questBehaviour.Quest.QuestDefinition.Name
});
}
else
{
Func <ContenderSnapShot, bool> < > 9__2;
Contender contender = e.EventArgs.Encounter.Contenders.FirstOrDefault(delegate(Contender match)
{
IEnumerable <ContenderSnapShot> contenderSnapShots = match.ContenderSnapShots;
Func <ContenderSnapShot, bool> predicate;
if ((predicate = < > 9__2) == null)
{
predicate = (< > 9__2 = ((ContenderSnapShot snapshot) => snapshot.ContenderGUID == enemyArmyGUID));
}
return(contenderSnapShots.Any(predicate));
});
if (contender == null)
{
return(false);
}
if (contender.Empire != e.Empire)
{
if (contender.ContenderState != ContenderState.Defeated)
{
return(false);
}
flag = false;
}
}
}
return(!flag);
}
IEnumerable <Contender> enemiesContenderFromEmpire = e.EventArgs.Encounter.GetEnemiesContenderFromEmpire(e.Empire as global::Empire);
if (enemiesContenderFromEmpire == null)
{
return(false);
}
return(enemiesContenderFromEmpire.All((Contender match) => match.ContenderState == ContenderState.Defeated));
}
/// <summary>
/// remove breakpoints
/// </summary>
protected override void ProcessRecord()
{
List <Breakpoint> breakpoints = Context.Debugger.GetBreakpoints();
//
// Filter by parameter set
//
if (this.ParameterSetName.Equals("Script", StringComparison.OrdinalIgnoreCase))
{
// no filter
}
else if (this.ParameterSetName.Equals("Id", StringComparison.OrdinalIgnoreCase))
{
breakpoints = Filter(
breakpoints,
_id,
delegate(Breakpoint breakpoint, int id)
{
return(breakpoint.Id == id);
}
);
}
else if (this.ParameterSetName.Equals("Command", StringComparison.OrdinalIgnoreCase))
{
breakpoints = Filter(
breakpoints,
_command,
delegate(Breakpoint breakpoint, string command)
{
CommandBreakpoint commandBreakpoint = breakpoint as CommandBreakpoint;
if (commandBreakpoint == null)
{
return(false);
}
return(commandBreakpoint.Command.Equals(command, StringComparison.OrdinalIgnoreCase));
});
}
else if (this.ParameterSetName.Equals("Variable", StringComparison.OrdinalIgnoreCase))
{
breakpoints = Filter(
breakpoints,
_variable,
delegate(Breakpoint breakpoint, string variable)
{
VariableBreakpoint variableBreakpoint = breakpoint as VariableBreakpoint;
if (variableBreakpoint == null)
{
return(false);
}
return(variableBreakpoint.Variable.Equals(variable, StringComparison.OrdinalIgnoreCase));
});
}
else if (this.ParameterSetName.Equals("Type", StringComparison.OrdinalIgnoreCase))
{
breakpoints = Filter(
breakpoints,
_type,
delegate(Breakpoint breakpoint, BreakpointType type)
{
switch (type)
{
case BreakpointType.Line:
if (breakpoint is LineBreakpoint)
{
return(true);
}
break;
case BreakpointType.Command:
if (breakpoint is CommandBreakpoint)
{
return(true);
}
break;
case BreakpointType.Variable:
if (breakpoint is VariableBreakpoint)
{
return(true);
}
break;
}
return(false);
});
}
else
{
Diagnostics.Assert(false, "Invalid parameter set: {0}", this.ParameterSetName);
}
//
// Filter by script
//
if (_script != null)
{
breakpoints = Filter(
breakpoints,
_script,
delegate(Breakpoint breakpoint, string script)
{
if (breakpoint.Script == null)
{
return(false);
}
return(string.Compare(
SessionState.Path.GetUnresolvedProviderPathFromPSPath(breakpoint.Script),
SessionState.Path.GetUnresolvedProviderPathFromPSPath(script),
StringComparison.OrdinalIgnoreCase
) == 0);
});
}
//
// Output results
//
foreach (Breakpoint b in breakpoints)
{
WriteObject(b);
}
}
public bool LoadListen()
{
// Don't allocate anything if we have no phrases to hook.
if (App.ActiveProfile == null)
{
return(false);
}
if (App.ActiveProfile.ProfileTriggers != null &&
App.ActiveProfile.ProfileTriggers.Count == 0)
{
Diagnostics.Log("LoadListen() called without a trigger added.");
MessageBox.Show("At least one Trigger must be added!");
return(false);
}
_synthesizer = App.ActiveProfile.Synthesizer;
_synthesizer.SelectVoice(App.Settings.VoiceInfo);
_speechRecognitionEngine = new SpeechRecognitionEngine(App.Settings.RecognizerInfo);
GrammarBuilder grammarPhrases = new GrammarBuilder {
Culture = App.Settings.RecognizerInfo
};
// Grammar must match speech recognition language localization
List <string> glossary = new List <string>();
// Add trigger phrases to glossary of voice recognition engine.
if (App.ActiveProfile.ProfileTriggers != null)
{
glossary.AddRange(from trigger in App.ActiveProfile.ProfileTriggers
let phrase = (Phrase)trigger
select trigger.Value);
}
grammarPhrases.Append(new Choices(glossary.ToArray()));
_speechRecognitionEngine.LoadGrammar(new Grammar(grammarPhrases));
// event function hook
_speechRecognitionEngine.SpeechRecognized += PhraseRecognized;
_speechRecognitionEngine.SpeechRecognitionRejected += Recognizer_SpeechRecognitionRejected;
try
{
_speechRecognitionEngine.SetInputToDefaultAudioDevice();
}
catch (InvalidOperationException e)
{
Diagnostics.Log(e, "No microphone was detected.");
MessageBox.Show("No microphone was detected!", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
catch (Exception e)
{
Diagnostics.Log(e, "An Unknown error occured when attempting to set default input device.");
MessageBox.Show("An unknown error has occured, contact support if the problem persists.", "Error",
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
_speechRecognitionEngine.RecognizeAsync(RecognizeMode.Multiple);
// subscribe to Push-to-Talk key hooks.
KeyboardHook.KeyDown += _pushToTalkKeyDownHook;
KeyboardHook.KeyUp += _pushToTalkKeyUpHook;
KeyboardHook.InstallHook();
if (App.Settings.PushToTalkMode != "Hold" && App.Settings.PushToTalkMode != "Toggle" &&
App.Settings.PushToTalkMode != "Single")
{
_pushToTalkActive = true;
}
// successfully established an instance of SAPI engine with well-formed grammar.
IsListening = true;
return(true);
}
protected override State Execute(AIBehaviorTree aiBehaviorTree, params object[] parameters)
{
IGameService service = Services.GetService <IGameService>();
Diagnostics.Assert(service != null);
if (this.orderTicket != null)
{
if (!this.orderTicket.Raised)
{
return(State.Running);
}
if (this.orderTicket.PostOrderResponse != PostOrderResponse.Processed)
{
aiBehaviorTree.ErrorCode = 36;
return(State.Failure);
}
this.orderTicket = null;
return(State.Success);
}
else if (this.heroTicket != null)
{
if (!this.heroTicket.Raised)
{
return(State.Running);
}
if (this.heroTicket.PostOrderResponse != PostOrderResponse.Processed)
{
aiBehaviorTree.ErrorCode = 36;
return(State.Failure);
}
this.heroTicket = null;
return(State.Running);
}
else
{
Army army;
if (base.GetArmyUnlessLocked(aiBehaviorTree, "$Army", out army) != AIArmyMission.AIArmyMissionErrorCode.None)
{
return(State.Failure);
}
if (army.IsPrivateers)
{
return(State.Success);
}
using (IEnumerator <Unit> enumerator = army.StandardUnits.GetEnumerator())
{
while (enumerator.MoveNext())
{
if (!enumerator.Current.UnitDesign.Tags.Contains(TradableUnit.ReadOnlyMercenary))
{
return(State.Failure);
}
}
}
if (army.Hero != null)
{
OrderChangeHeroAssignment orderChangeHeroAssignment = new OrderChangeHeroAssignment(aiBehaviorTree.AICommander.Empire.Index, army.Hero.GUID, GameEntityGUID.Zero);
orderChangeHeroAssignment.IgnoreCooldown = true;
aiBehaviorTree.AICommander.Empire.PlayerControllers.AI.PostOrder(orderChangeHeroAssignment, out this.heroTicket, null);
return(State.Running);
}
Region region = service.Game.Services.GetService <IWorldPositionningService>().GetRegion(army.WorldPosition);
if (region != null && region.City != null && region.City.Empire == army.Empire)
{
OrderTogglePrivateers order = new OrderTogglePrivateers(army.Empire.Index, army.GUID, true);
aiBehaviorTree.AICommander.Empire.PlayerControllers.AI.PostOrder(order, out this.orderTicket, null);
return(State.Running);
}
aiBehaviorTree.ErrorCode = 36;
return(State.Failure);
}
}
private void diagnostics_Click(object sender, EventArgs e)
{
var diagnostics = new Diagnostics(new WinFormsWindowMessageHook(this));
}
// Hides the base SetResult method which we need to override
// This method is called when the message is actually delivered to a ReceiveAsync call
// The update to the CloseMessageSequenceNumber property of Inbound is transactional
internal async Task SetResult(InboundBaseStreamWireMessage message)
{
var closeSeqNumber = this.stream.CloseMessageSequenceNumber;
if (message.Kind == StreamWireProtocolMessageKind.CloseStream)
{
// The close message can be a repeat in recovery cases, but the close sequence number must be unique
// It is also possible that the transaction surrounding this ReceiveAsync will abort and the message
// will not in fact be consumed -- and will be received again, but the close sequence number must be unique
Diagnostics.Assert(
closeSeqNumber == StreamConstants.InitialValueOfLastSequenceNumberInStream || closeSeqNumber == message.MessageSequenceNumber,
"{0} TraceId::{1} encountered multiple close sequence number values {2} and {3}",
this.stream.Tracer,
this.traceId,
closeSeqNumber,
message.MessageSequenceNumber);
try
{
// this method is idempotent; the close sequence number for a stream is invariant
await this.stream.SetCloseMessageSequenceNumber(message.MessageSequenceNumber, this.transactionContext);
await this.stream.CloseInboundStream(this.transactionContext);
}
catch (Exception e)
{
if (e is FabricObjectClosedException)
{
FabricEvents.Events.DataMessageDelivery(
string.Format(CultureInfo.InvariantCulture, "ObjectClosed@{0}{1}", this.traceId, this.stream.TraceType),
this.stream.StreamIdentity.ToString(),
message.MessageSequenceNumber,
this.transactionContext.Id.ToString());
this.TrySetException(e);
return;
}
if (e is FabricNotPrimaryException)
{
FabricEvents.Events.DataMessageDelivery(
string.Format(CultureInfo.InvariantCulture, "NotPrimary@{0}{1}", this.traceId, this.stream.TraceType),
this.stream.StreamIdentity.ToString(),
message.MessageSequenceNumber,
this.transactionContext.Id.ToString());
this.TrySetException(e);
return;
}
if (e is FabricNotReadableException)
{
FabricEvents.Events.DataMessageDelivery(
string.Format(CultureInfo.InvariantCulture, "NotReadable@{0}{1}", this.traceId, this.stream.TraceType),
this.stream.StreamIdentity.ToString(),
message.MessageSequenceNumber,
this.transactionContext.Id.ToString());
this.TrySetException(e);
return;
}
Tracing.WriteExceptionAsError(
"DataMessageDelivery.Failure",
e,
"Partition::Replica {0} TraceId: {1} MessageNumber: {2} TransactionId: {3}",
this.stream.TraceType,
this.traceId,
message.MessageSequenceNumber,
this.transactionContext.Id);
Diagnostics.Assert(
false,
"Unexpected Exception In {0} TraceId: {1} MessageNumber: {2} TransactionId: {3}",
this.stream.TraceType,
this.traceId,
message.MessageSequenceNumber,
this.transactionContext.Id);
}
}
else
{
Diagnostics.Assert(
closeSeqNumber == StreamConstants.InitialValueOfLastSequenceNumberInStream || closeSeqNumber > message.MessageSequenceNumber,
"{0} received payload message with sequence number {1} which is greater than the close sequence number {2}",
this.stream.Tracer,
message.MessageSequenceNumber,
closeSeqNumber);
}
var setResultSuccess = this.TrySetResult(message);
if (setResultSuccess)
{
FabricEvents.Events.DataMessageDelivery(
"Success::" + this.traceId + "@" + this.stream.TraceType,
this.stream.StreamIdentity.ToString(),
message.MessageSequenceNumber,
this.transactionContext.Id.ToString());
}
else
{
FabricEvents.Events.DataMessageDelivery(
"Failure::" + this.traceId + "@" + this.stream.TraceType,
this.stream.StreamIdentity.ToString(),
message.MessageSequenceNumber,
this.transactionContext.Id.ToString());
}
}
CreateCommandProcessor
(
ExecutionContext executionContext,
bool addToHistory,
CommandOrigin origin
)
{
Dbg.Assert(executionContext != null, "Caller should verify the parameters");
CommandProcessorBase commandProcessorBase;
if (IsScript)
{
if ((executionContext.LanguageMode == PSLanguageMode.NoLanguage) &&
(origin == Automation.CommandOrigin.Runspace))
{
throw InterpreterError.NewInterpreterException(CommandText, typeof(ParseException),
null, "ScriptsNotAllowed", ParserStrings.ScriptsNotAllowed);
}
ScriptBlock scriptBlock = executionContext.Engine.ParseScriptBlock(CommandText, addToHistory);
if (origin == Automation.CommandOrigin.Internal)
{
scriptBlock.LanguageMode = PSLanguageMode.FullLanguage;
}
// If running in restricted language mode, verify that the parse tree represents on legitimate
// constructions...
switch (scriptBlock.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
scriptBlock.CheckRestrictedLanguage(null, null, false);
break;
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode.
break;
case PSLanguageMode.ConstrainedLanguage:
// Constrained Language is checked at runtime.
break;
default:
// This should never happen...
Diagnostics.Assert(false, "Invalid language mode was set when building a ScriptCommandProcessor");
throw new InvalidOperationException("Invalid language mode was set when building a ScriptCommandProcessor");
}
if (scriptBlock.UsesCmdletBinding)
{
FunctionInfo functionInfo = new FunctionInfo(string.Empty, scriptBlock, executionContext);
commandProcessorBase = new CommandProcessor(functionInfo, executionContext,
_useLocalScope ?? false, fromScriptFile: false, sessionState: executionContext.EngineSessionState);
}
else
{
commandProcessorBase = new DlrScriptCommandProcessor(scriptBlock,
executionContext, _useLocalScope ?? false,
origin,
executionContext.EngineSessionState);
}
}
else
{
// RestrictedLanguage / NoLanguage do not support dot-sourcing when CommandOrigin is Runspace
if ((_useLocalScope.HasValue) && (!_useLocalScope.Value))
{
switch (executionContext.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
case PSLanguageMode.NoLanguage:
string message = StringUtil.Format(RunspaceStrings.UseLocalScopeNotAllowed,
"UseLocalScope",
PSLanguageMode.RestrictedLanguage.ToString(),
PSLanguageMode.NoLanguage.ToString());
throw new RuntimeException(message);
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode...
break;
}
}
commandProcessorBase = executionContext.CommandDiscovery.LookupCommandProcessor(CommandText, origin, _useLocalScope);
}
CommandParameterCollection parameters = Parameters;
if (parameters != null)
{
bool isNativeCommand = commandProcessorBase is NativeCommandProcessor;
foreach (CommandParameter publicParameter in parameters)
{
CommandParameterInternal internalParameter = CommandParameter.ToCommandParameterInternal(publicParameter, isNativeCommand);
commandProcessorBase.AddParameter(internalParameter);
}
}
string helpTarget;
HelpCategory helpCategory;
if (commandProcessorBase.IsHelpRequested(out helpTarget, out helpCategory))
{
commandProcessorBase = CommandProcessorBase.CreateGetHelpCommandProcessor(
executionContext,
helpTarget,
helpCategory);
}
//Set the merge settings
SetMergeSettingsOnCommandProcessor(commandProcessorBase);
return(commandProcessorBase);
}
private string GetStringHelper(StringResourceReference resourceReference, out LoadingResult result, out AssemblyBindingStatus bindingStatus)
{
result = LoadingResult.AssemblyNotFound;
bindingStatus = AssemblyBindingStatus.NotFound;
AssemblyLoadResult loadResult = null;
// try first to see if we have an assembly reference in the cache
if (_resourceReferenceToAssemblyCache.Contains(resourceReference))
{
loadResult = _resourceReferenceToAssemblyCache[resourceReference] as AssemblyLoadResult;
bindingStatus = loadResult.status;
}
else
{
loadResult = new AssemblyLoadResult();
// we do not have an assembly, we try to load it
bool foundInGac;
loadResult.a = LoadAssemblyFromResourceReference(resourceReference, out foundInGac);
if (loadResult.a == null)
{
loadResult.status = AssemblyBindingStatus.NotFound;
}
else
{
loadResult.status = foundInGac ? AssemblyBindingStatus.FoundInGac : AssemblyBindingStatus.FoundInPath;
}
// add to the cache even if null
_resourceReferenceToAssemblyCache.Add(resourceReference, loadResult);
}
bindingStatus = loadResult.status;
if (loadResult.a == null)
{
// we failed the assembly loading
result = LoadingResult.AssemblyNotFound;
return(null);
}
else
{
resourceReference.assemblyLocation = loadResult.a.Location;
};
// load now the resource from the resource manager cache
try
{
string val = ResourceManagerCache.GetResourceString(loadResult.a, resourceReference.baseName, resourceReference.resourceId);
if (val == null)
{
result = LoadingResult.StringNotFound;
return(null);
}
else
{
result = LoadingResult.NoError;
return(val);
}
}
catch (InvalidOperationException)
{
result = LoadingResult.ResourceNotFound;
}
catch (MissingManifestResourceException)
{
result = LoadingResult.ResourceNotFound;
}
catch (Exception e) // will rethrow
{
Diagnostics.Assert(false, "ResourceManagerCache.GetResourceString unexpected exception " + e.GetType().FullName);
throw;
}
return(null);
}
public int GetLineIndexAtSpanEnd(Diagnostics.Span span)
{
return this.GetLineAtPos(span.end);
}
protected override State Execute(QuestBehaviour questBehaviour, EventEncounterStateChange e, params object[] parameters)
{
if (this.UpdateVars)
{
this.Initialize(questBehaviour);
this.UpdateVars = false;
}
if (e.EventArgs.EncounterState != EncounterState.BattleHasEnded)
{
return(State.Running);
}
IEnumerable <Contender> enemiesContenderFromEmpire = e.EventArgs.Encounter.GetEnemiesContenderFromEmpire(e.Empire as global::Empire);
if (enemiesContenderFromEmpire == null)
{
return(State.Running);
}
this.SaveEnemyArmyGUIDs(questBehaviour);
if (this.EnemyArmyGUIDVarName != null && this.EnemyArmyGUIDs == null)
{
Diagnostics.LogError("Fail to find all army GUID in '{0}' (for quest {1})", new object[]
{
string.Join(", ", this.EnemyArmyGUIDVarName),
questBehaviour.Quest.Name
});
return(State.Running);
}
if (this.EnemyArmyGUIDs == null || this.EnemyArmyGUIDs.Length == 0)
{
if (this.CountAllDeadEnemyArmiesForStepProgression)
{
base.ProgressionIncrement = enemiesContenderFromEmpire.Count((Contender match) => match.ContenderState == ContenderState.Defeated);
}
else
{
base.ProgressionIncrement = 1;
}
}
else if (this.CountAllDeadEnemyArmiesForStepProgression)
{
base.ProgressionIncrement = this.ComputeDeadEnemyTargetCount(questBehaviour, e);
}
else
{
base.ProgressionIncrement = 1;
}
if (!string.IsNullOrEmpty(this.Output_WinnerVarName))
{
this.AddWinnerToQuestVariable(questBehaviour, e);
}
if (!string.IsNullOrEmpty(this.Output_LooserVarName))
{
this.AddLooserToQuestVariable(questBehaviour, e);
}
if (!string.IsNullOrEmpty(this.Output_WinnerEmpire))
{
this.AddWinnerEmpireToQuestVariable(questBehaviour, e);
}
if (!string.IsNullOrEmpty(this.Output_Position))
{
this.AddPositionToQuestVariable(questBehaviour, e);
}
if (!this.DoesKilledArmyBelongsToTargetedEmpire(questBehaviour, e))
{
return(State.Running);
}
if ((this.TargetOption == QuestBehaviourTreeNode_Decorator_KillArmy.KillArmyTargetOption.All && this.AreAllTargetEnemyDead(questBehaviour, e)) || (this.TargetOption == QuestBehaviourTreeNode_Decorator_KillArmy.KillArmyTargetOption.Any && this.IsThereOneTargetEnemyDead(questBehaviour, e)))
{
return(State.Success);
}
return(State.Running);
}
public static InstructionMoveLiteralTuple Empty(Diagnostics.Span span, DataAccess destination)
{
return new InstructionMoveLiteralTuple { span = span, destination = destination };
}
// RenderAFrame is called once a frame
public override void RenderAFrame()
{
//_trailerTransform.Rotation = new float3(0,0,0);
// Clear the backbuffer
RC.Clear(ClearFlags.Color | ClearFlags.Depth);
if (Mouse.RightButton == true)
{
_camAngle += Mouse.Velocity.x * 0.00001f * DeltaTime / 20 * 10000;
}
// Setup the camera
//RC.View = float4x4.CreateTranslation(0,-5,40) * float4x4.CreateRotationY(pBalt.y);
//RC.View = float4x4.CreateTranslation(pBneu) * float4x4.CreateRotationY(_camAngle);
RC.View = float4x4.CreateRotationX(-M.Pi / 7.3f) * float4x4.CreateRotationY(M.Pi - _trailerTransform.Rotation.y) * float4x4.CreateTranslation(-_trailerTransform.Translation.x, -6, -_trailerTransform.Translation.z);
//ToDO If Bedingung eingefügt
if (Mouse.LeftButton)
{
float2 pickPosClip = Mouse.Position * new float2(2.0f / Width, -2.0f / Height) + new float2(-1, 1);
_scenePicker.View = RC.View;
_scenePicker.Projection = RC.Projection;
List <PickResult> pickResults = _scenePicker.Pick(pickPosClip).ToList();
if (pickResults.Count > 0)
{
Diagnostics.Log(pickResults[0].Node.Name);
PickResult newPick = null;
if (pickResults.Count > 0)
{
pickResults.Sort((a, b) => Sign(a.ClipPos.z - b.ClipPos.z));
newPick = pickResults[0];
}
if (newPick?.Node != _currentPick?.Node)
{
if (_currentPick != null)
{
_currentPick.Node.GetMaterial().Diffuse.Color = _oldColor;
}
if (newPick != null)
{
var mat = newPick.Node.GetMaterial();
_oldColor = mat.Diffuse.Color;
mat.Diffuse.Color = new float3(1, 0.4f, 0.4f);
_Pallete = newPick.Node.GetTransform().Translation.y - 2.5f;
}
_currentPick = newPick;
}
}
}
if (_currentPick != null)
{
if (_currentPick.Node.Name == "Rad_R_01")
{
float RadR01 = _RadR01Transform.Rotation.x;
RadR01 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR01Transform.Rotation = new float3(RadR01, 0, 0);
}
else if (_currentPick.Node.Name == "Rad_L_01")
{
float RadR02 = _RadR02Transform.Rotation.x;
RadR02 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR02Transform.Rotation = new float3(RadR02, 0, 0);
}
else if (_currentPick.Node.Name == "Rad_02_R")
{
float RadR03 = _RadR03Transform.Rotation.x;
RadR03 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR03Transform.Rotation = new float3(RadR03, 0, 0);
}
else if (_currentPick.Node.Name == "Rad_02_L")
{
float RadR04 = _RadR04Transform.Rotation.x;
RadR04 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR04Transform.Rotation = new float3(RadR04, 0, 0);
}
else if (_currentPick.Node.Name == "Rad_03_L")
{
float RadR05 = _RadR05Transform.Rotation.x;
RadR05 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR05Transform.Rotation = new float3(RadR05, 0, 0);
}
else if (_currentPick.Node.Name == "Rad_03_R")
{
float RadR06 = _RadR06Transform.Rotation.x;
RadR06 += Keyboard.ADAxis * 2.0f * (DeltaTime);
_RadR06Transform.Rotation = new float3(RadR06, 0, 0);
}
else if (_currentPick.Node.Name == "Pallete")
{
}
if (_currentPick.Node.Name == "pfeiler_gewinde_arm_nicht_drehbar")
{
float ogd = _oberesGewTransform.Rotation.y;
ogd += Keyboard.LeftRightAxis * 0.005f;
_oberesGewTransform.Rotation = new float3(0, ogd, 0);
}
else if (_currentPick.Node.Name == "unterer_arm")
{
float unter = _unterarmTransform.Rotation.x;
if (Keyboard.GetKey(KeyCodes.Up) == true)
{
if (unter <= 0.35f)
{
unter += DeltaTime * 0.1f;
_unterarmTransform.Rotation = new float3(unter, 0, 0);
}
}
if (Keyboard.GetKey(KeyCodes.Down) == true)
{
if (unter >= 0.0f)
{
unter -= DeltaTime * 0.1f;
_unterarmTransform.Rotation = new float3(unter, 0, 0);
}
}
}
/*case "Oberer_arm":
* float obArmx = _oberarmTransform.Translation.z;
* obArmx += Keyboard.UpDownAxis * 0.1f;
* /*float obArmy = _oberarmTransform.Translation.z;
* obArmy += Keyboard.UpDownAxis * 0.1f;*/
/*_oberarmTransform.Translation = new float3(0, 0, obArmx);
* break;*/
else if (_currentPick.Node.Name == "verbindung_arm_greifer")
{
float ver = _verbagTransform.Translation.y;
if (Keyboard.GetKey(KeyCodes.Up) == true)
{
if (ver <= -0.5f)
{
ver += DeltaTime * 2f;
_verbagTransform.Translation = new float3(0, ver, 0);
}
}
if (Keyboard.GetKey(KeyCodes.Down) == true)
{
if (ver >= -10.0f)
{
ver -= DeltaTime * 2f;
_verbagTransform.Translation = new float3(0, ver, 0);
}
}
}
}
float Rad_03 = _RadR03Transform.Rotation.x;
Rad_03 += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
_RadR03Transform.Rotation = new float3(Rad_03, 0, 0);
float Rad_04 = _RadR04Transform.Rotation.x;
Rad_04 += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
_RadR04Transform.Rotation = new float3(Rad_04, 0, 0);
float Rad_05 = _RadR05Transform.Rotation.x;
Rad_05 += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
_RadR05Transform.Rotation = new float3(Rad_05, 0, 0);
float Rad_06 = _RadR06Transform.Rotation.x;
Rad_06 += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
_RadR06Transform.Rotation = new float3(Rad_06, 0, 0);
float Rad_01x = _RadR01Transform.Rotation.x;
float Rad_01y = _RadR01Transform.Rotation.y;
Rad_01x += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
Rad_01y = -Keyboard.ADAxis * -0.35f;
_RadR01Transform.Rotation = new float3(Rad_01x, Rad_01y, 0);
float Rad_02x = _RadR02Transform.Rotation.x;
float Rad_02y = _RadR02Transform.Rotation.y;
Rad_02x += Keyboard.WSAxis * 0.15f * (DeltaTime / 16 * 1000);
Rad_02y = -Keyboard.ADAxis * -.35f;
_RadR02Transform.Rotation = new float3(Rad_02x, Rad_02y, 0);
float xArm = _unterarmTransform.Rotation.x;
float yVerbag = _verbagTransform.Translation.y;
if (_Pallete < yVerbag)
{
yVerbag -= DeltaTime;
if (_Pallete > yVerbag)
{
yVerbag = _Pallete;
}
}
if (_Pallete > yVerbag)
{
//xArm -= DeltaTime;
yVerbag += DeltaTime;
if (_Pallete < yVerbag)
{
//xArm = _Pallete;
yVerbag = _Pallete;
}
}
_verbagTransform.Translation = new float3(_verbagTransform.Translation.x, yVerbag, _verbagTransform.Translation.z);
float3 pAalt = _carTransform.Translation;
float3 pBalt = _trailerTransform.Translation;
float posVel = -Keyboard.WSAxis * Time.DeltaTime;
float rotVel = Keyboard.ADAxis * Time.DeltaTime;
float newRot = _carTransform.Rotation.y + (rotVel * Keyboard.WSAxis * Time.DeltaTime * 30);
_carTransform.Rotation = new float3(0, newRot, 0);
float3 pAneu = _carTransform.Translation + new float3(posVel * M.Sin(newRot) * 10, 0, posVel * M.Cos(newRot) * 10);
_carTransform.Translation = pAneu;
float3 pBneu = pAneu + (float3.Normalize(pBalt - pAneu) * _d);
_trailerTransform.Translation = pBneu;
_trailerTransform.Rotation = new float3(0, (float)System.Math.Atan2(float3.Normalize(pBalt - pAneu).x, float3.Normalize(pBalt - pAneu).z), 0);
// Render the scene on the current render context
_sceneRenderer.Render(RC);
// Swap buffers: Show the contents of the backbuffer (containing the currently rendered farame) on the front buffer.
Present();
}
private void AndroidLogger_Info(string task, string message)
{
Diagnostics.Debug(message);
}
/// <summary>
/// Initializes a new instance of the <see cref="BlobStateRepositoryFactory"/> class
/// </summary>
/// <param name="cloudStorageProviderFactory">The cloud storage provider factory</param>
/// <param name="tracer">The tracer</param>
public BlobStateRepositoryFactory(ICloudStorageProviderFactory cloudStorageProviderFactory, ITracer tracer)
{
this.cloudStorageProviderFactory = Diagnostics.EnsureArgumentNotNull(() => cloudStorageProviderFactory);
this.tracer = tracer;
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Containers == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Containers");
}
if (OsType == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "OsType");
}
if (Containers != null)
{
foreach (var element in Containers)
{
if (element != null)
{
element.Validate();
}
}
}
if (ImageRegistryCredentials != null)
{
foreach (var element1 in ImageRegistryCredentials)
{
if (element1 != null)
{
element1.Validate();
}
}
}
if (IpAddress != null)
{
IpAddress.Validate();
}
if (Volumes != null)
{
foreach (var element2 in Volumes)
{
if (element2 != null)
{
element2.Validate();
}
}
}
if (Diagnostics != null)
{
Diagnostics.Validate();
}
if (SubnetIds != null)
{
foreach (var element3 in SubnetIds)
{
if (element3 != null)
{
element3.Validate();
}
}
}
if (DnsConfig != null)
{
DnsConfig.Validate();
}
if (EncryptionProperties != null)
{
EncryptionProperties.Validate();
}
if (InitContainers != null)
{
foreach (var element4 in InitContainers)
{
if (element4 != null)
{
element4.Validate();
}
}
}
}
private void GenerateProperties(IEnumerable <Method> settersToUse, bool readOnly)
{
foreach (var setter in settersToUse)
{
var type = (Class)setter.Namespace;
var firstWord = GetFirstWord(setter.Name);
string property;
if ((firstWord == "set" || firstWord == "set_") &&
firstWord.Length < setter.Name.Length)
{
property = setter.Name.Substring(firstWord.Length);
}
else
{
property = setter.Name;
}
var nameBuilder = new StringBuilder(property);
if (char.IsLower(setter.Name[0]))
{
nameBuilder[0] = char.ToLowerInvariant(nameBuilder[0]);
}
string afterSet = nameBuilder.ToString();
var s = setter;
foreach (var getter in nonSetters.Where(m => m.Namespace == type &&
m.ExplicitInterfaceImpl == s.ExplicitInterfaceImpl))
{
var name = GetReadWritePropertyName(getter, afterSet);
if (name == afterSet &&
GetUnderlyingType(getter.OriginalReturnType).Equals(
GetUnderlyingType(setter.Parameters[0].QualifiedType)))
{
Method g = getter;
foreach (var method in type.Methods.Where(m => m != g && m.Name == name))
{
var oldName = method.Name;
method.Name = string.Format("get{0}{1}",
char.ToUpperInvariant(method.Name[0]), method.Name.Substring(1));
Diagnostics.Debug("Method {0}::{1} renamed to {2}", method.Namespace.Name, oldName, method.Name);
}
foreach (var @event in type.Events.Where(e => e.Name == name))
{
var oldName = @event.Name;
@event.Name = string.Format("on{0}{1}",
char.ToUpperInvariant(@event.Name[0]), @event.Name.Substring(1));
Diagnostics.Debug("Event {0}::{1} renamed to {2}", @event.Namespace.Name, oldName, @event.Name);
}
GenerateProperty(name, getter.Namespace, getter, readOnly ? null : setter);
goto next;
}
}
Property baseProperty = type.GetBaseProperty(new Property {
Name = afterSet
}, getTopmost: true);
if (!type.IsInterface && baseProperty != null && baseProperty.IsVirtual && setter.IsVirtual)
{
bool isReadOnly = baseProperty.SetMethod == null;
var name = GetReadWritePropertyName(baseProperty.GetMethod, afterSet);
GenerateProperty(name, setter.Namespace, baseProperty.GetMethod,
readOnly || isReadOnly ? null : setter);
}
next:
;
}
foreach (Method nonSetter in nonSetters)
{
Class type = (Class)nonSetter.Namespace;
string name = GetPropertyName(nonSetter.Name);
Property baseProperty = type.GetBaseProperty(new Property {
Name = name
}, getTopmost: true);
if (!type.IsInterface && baseProperty != null && baseProperty.IsVirtual)
{
bool isReadOnly = baseProperty.SetMethod == null;
if (readOnly == isReadOnly)
{
GenerateProperty(nonSetter.Namespace, nonSetter,
readOnly ? null : baseProperty.SetMethod);
}
}
}
}
private void btnSearch_Click(object sender, EventArgs e)
{
Stopwatch sw = new Stopwatch();
sw.Start();
AddValueFilter();
PopulateSelection(TaxonomyFilters, _valueSelection, _includeChildren);
if ((TaxonomyFilters == null || TaxonomyFilters.Count == 0) &&
MessageBox.Show(
"You forgot to tell me which taxonomy you wanted to query!\nLove, Arya\nDo you want to query the entire project?",
"Search everywhere?", MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
IQueryable <Sku> query = CurrentQuery;
if (query == null)
{
MessageBox.Show("Nothing to search!");
return;
}
lblStatus.Text = "Searching...";
lblStatus.Refresh();
DateTime startTime = DateTime.Now;
IQueryable <SearchResult> taxQuery = from sku in query
let skuInfo = sku.SkuInfos.First(si => si.Active)
group skuInfo by new { skuInfo.TaxonomyID, skuInfo.SkuID }
into taxSkuGrp
group taxSkuGrp by taxSkuGrp.Key.TaxonomyID
into taxGrp
join tax in AryaTools.Instance.InstanceData.Dc.TaxonomyInfos on taxGrp.Key equals
tax.ID
select new SearchResult {
Taxonomy = tax, SkuCount = taxGrp.Count()
};
_taxResults = taxQuery.ToList();
dgvTaxonomyResults.DataSource = _taxResults;
for (int i = 0; i < dgvTaxonomyResults.RowCount; i++)
{
if (i % 2 != 0)
{
dgvTaxonomyResults.Rows[i].DefaultCellStyle = DisplayStyle.CellStyleOddRow;
}
else
{
dgvTaxonomyResults.Rows[i].DefaultCellStyle = DisplayStyle.CellStyleGreyRegular;
}
}
int skuCount = _taxResults.Sum(tax => tax.SkuCount);
TimeSpan timeTaken = DateTime.Now.Subtract(startTime);
lblStatus.Text = string.Format(
"{0} SKUs found. Time taken: {1:00}:{2:00}", skuCount, timeTaken.TotalMinutes, timeTaken.Seconds);
sw.Stop();
Diagnostics.WriteMessage("Query", "FrmQueryView - btnSearch_Click", sw.Elapsed, skuCount);
sw.Reset();
}
#pragma warning restore CA1822 // Member can be static
public DiagnosticScope CreateScope(string name)
{
return(Diagnostics.CreateScope(name));
}
public override bool VisitFunctionDecl(Function function)
{
if (!function.IsGenerated)
{
return(false);
}
// Check if this function can be converted.
if (function.Parameters.Count == 0)
{
return(false);
}
var classParam = function.Parameters[0];
Class @class;
if (!GetClassParameter(classParam, out @class))
{
return(false);
}
// If we reach here, it means the first parameter is of class type.
// This means we can change the function to be an instance method.
// Clean up the name of the function now that it will be an instance method.
if (!function.Name.StartsWith(@class.Name))
{
return(false);
}
function.Name = function.Name.Substring(@class.Name.Length);
function.ExplicitlyIgnore();
// Create a new fake method so it acts as an instance method.
var method = new Method
{
Namespace = @class,
OriginalNamespace = function.Namespace,
Name = function.Name,
OriginalName = function.OriginalName,
Mangled = function.Mangled,
Access = AccessSpecifier.Public,
Kind = CXXMethodKind.Normal,
ReturnType = function.ReturnType,
Parameters = function.Parameters,
CallingConvention = function.CallingConvention,
IsVariadic = function.IsVariadic,
IsInline = function.IsInline,
Conversion = MethodConversionKind.FunctionToInstanceMethod
};
if (Options.GeneratorKind == GeneratorKind.CSharp)
{
method.Parameters = method.Parameters.Skip(1).ToList();
}
@class.Methods.Add(method);
Diagnostics.Debug("Function converted to instance method: {0}::{1}", @class.Name,
function.Name);
return(true);
}
/// <summary>
/// Minimax with transpositions.
///
/// Example - search depth 5
/// 5 4 3 2 1
/// A1 - B - E - F - G: Transposition added for each move
/// A2 - C - E: Same transposition encountered at depth 3.
/// -> No need to search deeper
///
/// General guidelines
/// * Don't save transposition values near the leaf nodes (depth 0, maybe 1)
///
/// Example
/// maximizing depth 4 alpha = 5, beta = 10
///
/// minimizing depth 3 alpha = 5, beta = 10
/// minimizing depth 3 value = 12 ok.
/// minimizing depth 3 value = 8 ok. beta = 8
/// minimizing depth 3 value = 4 -> prune and save as lowerbound. this move results to 4 or lower. return 4
///
/// maximizing depth 2 alpha = 5, beta = 8
/// maximizing depth 2 value = 13 -> prune and save as upperbound. this move results to 13 or higher. return 13
/// maximizing depth 2 value = 6 ok. alpha = 6
///
/// minimizing depth 1 alpha = 6 beta = 8
/// transposition found: lowerbound, 4
/// transposition found: upperbound, 13
///
///
/// maximizing depth 4 receives 4 - ignored
/// minimizing depth 3 receives 13 - ignored
/// </summary>
public static double ToDepthWithTranspositions(Board newBoard, int depth, double alpha, double beta, bool maximizingPlayer)
{
if (depth == 0)
{
return(newBoard.Evaluate(maximizingPlayer, false, false, depth));
}
// Check if solution already exists
var transposition = newBoard.Shared.Transpositions.GetTranspositionForBoard(newBoard.BoardHash);
if (transposition != null && transposition.Depth >= depth)
{
Diagnostics.IncrementTranspositionsFound();
var transpositionEval = MoveResearch.CheckMateScoreAdjustToDepthFixed(transposition.Evaluation, depth);
if (transposition.Type == NodeType.Exact)
{
return(transpositionEval);
}
else if (transposition.Type == NodeType.UpperBound && transpositionEval < beta)
{
beta = transpositionEval;
}
else if (transposition.Type == NodeType.LowerBound && transpositionEval > alpha)
{
alpha = transpositionEval;
}
//else if (transposition.Type == NodeType.UpperBound && !maximizingPlayer && transposition.Evaluation <= alpha)
//{
// // No need to search further, as score was worse than alpha
// return transposition.Evaluation;
//}
//else if (transposition.Type == NodeType.LowerBound && maximizingPlayer && transposition.Evaluation >= beta)
//{
// // No need to search further, as score was worse than beta
// return transposition.Evaluation;
//}
}
var allMoves = newBoard.Moves(maximizingPlayer, false);
if (!allMoves.Any())
{
return(newBoard.Evaluate(maximizingPlayer, false, newBoard.IsCheck(!maximizingPlayer), depth));
}
if (maximizingPlayer)
{
var value = MoveResearch.DefaultAlpha;
foreach (var move in allMoves)
{
var nextBoard = new Board(newBoard, move);
value = ToDepthWithTranspositions(nextBoard, depth - 1, alpha, beta, false);
if (value >= beta)
{
// Eval is at least beta. Fail high
// Prune. Alpha is better than previous level beta. Don't want to use moves from this board set.
if (depth > 1)
{
nextBoard.Shared.Transpositions.Add(nextBoard.BoardHash, depth, value,
NodeType.LowerBound, nextBoard.Shared.GameTurnCount);
}
Diagnostics.IncrementBeta();
break;
}
else if (value > alpha)
{
// Value between alpha and beta. Save as exact score
// Update alpha for rest of iteration
alpha = value;
if (depth > 1)
{
nextBoard.Shared.Transpositions.Add(nextBoard.BoardHash, depth, value, NodeType.Exact, nextBoard.Shared.GameTurnCount);
}
}
}
return(value);
}
else
{
var value = MoveResearch.DefaultBeta;
foreach (var move in allMoves)
{
var nextBoard = new Board(newBoard, move);
value = ToDepthWithTranspositions(nextBoard, depth - 1, alpha, beta, true);
if (value <= alpha)
{
// Eval is at most alpha. Fail low
// Prune. Beta is smaller than previous level alpha. Don't want to use moves from this board set.
if (depth > 1)
{
nextBoard.Shared.Transpositions.Add(nextBoard.BoardHash, depth, value,
NodeType.UpperBound, nextBoard.Shared.GameTurnCount);
}
Diagnostics.IncrementAlpha();
break;
}
else if (value < beta)
{
// Value between alpha and beta. Save as exact score
// Update beta for rest of iteration
beta = value;
if (depth > 1)
{
// Add new transposition table
nextBoard.Shared.Transpositions.Add(nextBoard.BoardHash, depth, value, NodeType.Exact, nextBoard.Shared.GameTurnCount);
}
}
}
return(value);
}
}
private bool VerifyAnonymousEnums(ASTContext context)
{
bool retVal = true;
foreach (var anonEnum in Configuration.AnonymousEnums)
{
var typeDefs = context.FindTypedef(anonEnum.Value).ToList();
if (typeDefs.Count == 0)
{
retVal = false;
Diagnostics.Warning("typedef {0} for anonymous enum not found in source"
, anonEnum.Value
);
}
else if (typeDefs.Count > 1)
{
retVal = false;
Diagnostics.Warning("Multiple type definitions for Anonymous enum ({0},{1}) found in source"
, anonEnum.Key
, anonEnum.Value
);
foreach (var td in typeDefs)
{
Diagnostics.Warning("\t{0} in {1}@{2}", td.Name, td.TranslationUnit.FileRelativePath, td.LineNumberStart);
}
}
/*At this point: typdefs.Count == 1 && typedefs[0] is the matching type - so good to go on that front */
var sourceEnums = (from unit in context.TranslationUnits
let @enum = unit.FindEnumWithItem(anonEnum.Key)
where @enum != null
select @enum
).ToList();
if (sourceEnums.Count == 0)
{
retVal = false;
Diagnostics.Warning("no enum found in source with first item matching {0}"
, anonEnum.Key
);
}
else if (sourceEnums.Count > 1)
{
retVal = false;
Diagnostics.Warning("Multiple enums found in source with first item matching {0}"
, anonEnum.Key
);
foreach (var e in sourceEnums)
{
Diagnostics.Warning("\t{1}@{2}", e.TranslationUnit.FileRelativePath, e.LineNumberStart);
}
}
else if (!string.IsNullOrEmpty(sourceEnums[0].Name))
{
retVal = false;
var wrongEnum = sourceEnums[0];
Diagnostics.Warning("Found enum {0} in {1}@{2} with value {3} but expected an anonymous enum"
, wrongEnum.Name
, wrongEnum.TranslationUnit.FileRelativePath
, wrongEnum.LineNumberStart
, anonEnum.Key
);
}
}
return(retVal);
}
public AsyncTcpServer(string name)
: base(name)
{
Diag = new Diagnostics(this);
}
public virtual IEnumerable <Diagnostic> GetDiagnostics()
{
return(Diagnostics.Union(ChildNodes.SelectMany(x => x.GetDiagnostics())));
}
private void LogLogger(Diagnostics.Logger logs)
{
if (logs == null)
return;
foreach (var message in logs.Messages)
{
if (parseLogMessages)
LogParsedMessage(message);
else
LogSimpleMessage(message);
}
}
public bool ValidateAsType(DeclReference decl, Name origName, Diagnostics.Span span)
{
if (decl.kind != Core.Session.DeclReference.Kind.Struct)
{
this.AddMessage(
Diagnostics.MessageKind.Error,
Diagnostics.MessageCode.WrongDeclarationKind,
"'" + this.GetDeclName(decl).GetString() + "' is not a type",
span);
return false;
}
return true;
}
public static DataAccessField Of(Diagnostics.Span span, DataAccess baseAccess, int fieldIndex)
{
return new DataAccessField { span = span, baseAccess = baseAccess, fieldIndex = fieldIndex };
}
public Token(TokenKind kind, Diagnostics.Span span)
{
this.kind = kind;
this.span = span;
}
private BoundExpression BindFunctionInvocationExpression(FunctionInvocationExpressionSyntax syntax)
{
// Don't try to bind CompileShader function calls, for now.
if ((syntax.Name.Kind == SyntaxKind.IdentifierName) && ((IdentifierNameSyntax)syntax.Name).Name.ContextualKind == SyntaxKind.CompileShaderKeyword)
{
return(new BoundFunctionInvocationExpression(syntax,
syntax.ArgumentList.Arguments.Select(x => (BoundExpression) new BoundErrorExpression()).ToImmutableArray(),
OverloadResolutionResult <FunctionSymbolSignature> .None));
}
var name = syntax.Name;
var boundArguments = BindArgumentList(syntax.ArgumentList);
var argumentTypes = boundArguments.Select(a => a.Type).ToImmutableArray();
var anyErrorsInArguments = argumentTypes.Any(a => a.IsError());
if (anyErrorsInArguments)
{
return(new BoundFunctionInvocationExpression(syntax, boundArguments, OverloadResolutionResult <FunctionSymbolSignature> .None));
}
ContainerSymbol containerSymbol;
SyntaxToken actualName;
switch (name.Kind)
{
case SyntaxKind.IdentifierName:
containerSymbol = null;
actualName = ((IdentifierNameSyntax)name).Name;
break;
case SyntaxKind.QualifiedName:
containerSymbol = LookupContainer(((QualifiedNameSyntax)syntax.Name).Left);
actualName = ((QualifiedNameSyntax)name).Right.Name;
break;
default:
throw new InvalidOperationException();
}
var result = (containerSymbol?.Binder ?? this).LookupFunction(actualName, argumentTypes);
if (result.Best == null)
{
if (result.Selected == null)
{
if (result.Candidates.IsEmpty)
{
Diagnostics.ReportUndeclaredFunction(syntax, argumentTypes);
return(new BoundErrorExpression());
}
else
{
Diagnostics.ReportOverloadResolutionFailure(syntax, boundArguments.Length);
}
}
else
{
var symbol1 = result.Selected.Signature.Symbol;
var symbol2 = result.Candidates.First(c => !c.Signature.Symbol.Equals(symbol1)).Signature.Symbol;
Diagnostics.ReportAmbiguousInvocation(syntax.SourceRange, symbol1, symbol2, argumentTypes);
}
}
var convertedArguments = boundArguments.Select((a, i) => BindArgument(a, result, i, syntax.ArgumentList.Arguments[i].SourceRange)).ToImmutableArray();
return(new BoundFunctionInvocationExpression(syntax, convertedArguments, result));
}
public static InstructionMoveAddr Of(Diagnostics.Span span, DataAccess destination, DataAccess source, bool mutable)
{
return new InstructionMoveAddr { span = span, destination = destination, source = source, mutable = mutable };
}
} // GetDynamicParameters
#endregion Parameters
#region parameter data
#endregion parameter data
#region Command code
/// <summary>
/// Sets the content of the item at the specified path
/// </summary>
protected override void ProcessRecord()
{
// Default to the CmdletProviderContext that will direct output to
// the pipeline.
CmdletProviderContext currentCommandContext = CmdletProviderContext;
currentCommandContext.PassThru = PassThru;
PSObject mshObject = null;
switch (ParameterSetName)
{
case propertyValuePathSet:
case propertyValueLiteralPathSet:
mshObject = new PSObject();
mshObject.Properties.Add(new PSNoteProperty(Name, Value));
break;
case propertyPSObjectPathSet:
mshObject = InputObject;
break;
default:
Diagnostics.Assert(
false,
"One of the parameter sets should have been resolved or an error should have been thrown by the command processor");
break;
} // switch
foreach (string path in Path)
{
try
{
InvokeProvider.Property.Set(path, mshObject, currentCommandContext);
}
catch (PSNotSupportedException notSupported)
{
WriteError(
new ErrorRecord(
notSupported.ErrorRecord,
notSupported));
continue;
}
catch (DriveNotFoundException driveNotFound)
{
WriteError(
new ErrorRecord(
driveNotFound.ErrorRecord,
driveNotFound));
continue;
}
catch (ProviderNotFoundException providerNotFound)
{
WriteError(
new ErrorRecord(
providerNotFound.ErrorRecord,
providerNotFound));
continue;
}
catch (ItemNotFoundException pathNotFound)
{
WriteError(
new ErrorRecord(
pathNotFound.ErrorRecord,
pathNotFound));
continue;
}
}
} // ProcessRecord
public AmbiguousTypeException(TypeName typeName, IEnumerable <string> candidates)
{
Candidates = candidates.ToArray();
TypeName = typeName;
Diagnostics.Assert(Candidates.Length > 1, "AmbiguousTypeException can be created only when there are more then 1 candidate.");
}
/// <summary> Create the object </summary>
protected override void BeginProcessing()
{
Type type = null;
PSArgumentException mshArgE = null;
if (string.Equals(ParameterSetName, netSetName, StringComparison.Ordinal))
{
object _newObject = null;
try
{
type = LanguagePrimitives.ConvertTo(TypeName, typeof(Type), CultureInfo.InvariantCulture) as Type;
}
catch (Exception e)
{
// these complications in Exception handling are aim to make error messages better.
if (e is InvalidCastException || e is ArgumentException)
{
if (e.InnerException != null && e.InnerException is TypeResolver.AmbiguousTypeException)
{
ThrowTerminatingError(
new ErrorRecord(
e,
"AmbiguousTypeReference",
ErrorCategory.InvalidType,
targetObject: null));
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName",
NewObjectStrings.TypeNotFound,
TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"TypeNotFound",
ErrorCategory.InvalidType,
targetObject: null));
}
throw;
}
Diagnostics.Assert(type != null, "LanguagePrimitives.TryConvertTo failed but returned true");
if (type.IsByRefLike)
{
ThrowTerminatingError(
new ErrorRecord(
PSTraceSource.NewInvalidOperationException(
NewObjectStrings.CannotInstantiateBoxedByRefLikeType,
type),
nameof(NewObjectStrings.CannotInstantiateBoxedByRefLikeType),
ErrorCategory.InvalidOperation,
targetObject: null));
}
if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
if (!CoreTypes.Contains(type))
{
ThrowTerminatingError(
new ErrorRecord(
new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
}
}
// WinRT does not support creating instances of attribute & delegate WinRT types.
if (WinRTHelper.IsWinRTType(type) && ((typeof(System.Attribute)).IsAssignableFrom(type) || (typeof(System.Delegate)).IsAssignableFrom(type)))
{
ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType),
"CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null));
}
if (ArgumentList == null || ArgumentList.Length == 0)
{
ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
if (ci != null && ci.IsPublic)
{
_newObject = CallConstructor(type, new ConstructorInfo[] { ci }, Array.Empty <object>());
if (_newObject != null && Property != null)
{
// The method invocation is disabled for "Hashtable to Object conversion" (Win8:649519), but we need to keep it enabled for New-Object for compatibility to PSv2
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
else if (type.GetTypeInfo().IsValueType)
{
// This is for default parameterless struct ctor which is not returned by
// Type.GetConstructor(System.Type.EmptyTypes).
try
{
_newObject = Activator.CreateInstance(type);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
}
catch (TargetInvocationException e)
{
ThrowTerminatingError(
new ErrorRecord(
e.InnerException ?? e,
"ConstructorCalledThrowException",
ErrorCategory.InvalidOperation, null));
}
WriteObject(_newObject);
return;
}
}
else
{
ConstructorInfo[] ctorInfos = type.GetConstructors();
if (ctorInfos.Length != 0)
{
_newObject = CallConstructor(type, ctorInfos, ArgumentList);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName", NewObjectStrings.CannotFindAppropriateCtor, TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"CannotFindAppropriateCtor",
ErrorCategory.ObjectNotFound, null));
}
#if !UNIX
else // Parameterset -Com
{
int result = NewObjectNativeMethods.CLSIDFromProgID(ComObject, out _comObjectClsId);
// If we're in ConstrainedLanguage, do additional restrictions
if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
bool isAllowed = false;
// If it's a system-wide lockdown, we may allow additional COM types
if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce)
{
if ((result >= 0) &&
SystemPolicy.IsClassInApprovedList(_comObjectClsId))
{
isAllowed = true;
}
}
if (!isAllowed)
{
ThrowTerminatingError(
new ErrorRecord(
new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateComTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
return;
}
}
object comObject = CreateComObject();
string comObjectTypeName = comObject.GetType().FullName;
if (!comObjectTypeName.Equals("System.__ComObject"))
{
mshArgE = PSTraceSource.NewArgumentException(
"TypeName", NewObjectStrings.ComInteropLoaded, comObjectTypeName);
WriteVerbose(mshArgE.Message);
if (Strict)
{
WriteError(new ErrorRecord(
mshArgE,
"ComInteropLoaded",
ErrorCategory.InvalidArgument, comObject));
}
}
if (comObject != null && Property != null)
{
// Win8:649519
comObject = LanguagePrimitives.SetObjectProperties(comObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(comObject);
}
#endif
}
public static DataAccessDereference Of(Diagnostics.Span span, DataAccess innerAccess)
{
return new DataAccessDereference { span = span, innerAccess = innerAccess };
}
/// <summary>
/// The following is the matching algorithm:
/// Retrieve the incoming object (differenceEntry) if any
/// Retrieve the next reference object (referenceEntry) if any
/// If differenceEntry matches referenceEntry
/// Emit referenceEntry as a match
/// Return
/// If differenceEntry matches any entry in referenceEntryBacklog
/// Emit the backlog entry as a match
/// Remove the backlog entry from referenceEntryBacklog
/// Clear differenceEntry
/// If referenceEntry (if any) matches any entry in differenceEntryBacklog
/// Emit referenceEntry as a match
/// Remove the backlog entry from differenceEntryBacklog
/// Clear referenceEntry
/// If differenceEntry is still present
/// If SyncWindow is 0
/// Emit differenceEntry as unmatched
/// Else
/// While there is no space in differenceEntryBacklog
/// Emit oldest entry in differenceEntryBacklog as unmatched
/// Remove oldest entry from differenceEntryBacklog
/// Add differenceEntry to differenceEntryBacklog
/// If referenceEntry is still present
/// If SyncWindow is 0
/// Emit referenceEntry as unmatched
/// Else
/// While there is no space in referenceEntryBacklog
/// Emit oldest entry in referenceEntryBacklog as unmatched
/// Remove oldest entry from referenceEntryBacklog
/// Add referenceEntry to referenceEntryBacklog
/// </summary>
/// <param name="differenceEntry"></param>
private void Process(OrderByPropertyEntry differenceEntry)
{
Diagnostics.Assert(null != _referenceEntries, "null referenceEntries");
// Retrieve the next reference object (referenceEntry) if any
OrderByPropertyEntry referenceEntry = null;
if (_referenceObjectIndex < _referenceEntries.Count)
{
referenceEntry = _referenceEntries[_referenceObjectIndex++];
}
// If differenceEntry matches referenceEntry
// Emit referenceEntry as a match
// Return
// 2005/07/19 Switched order of referenceEntry and differenceEntry
// so that we cast differenceEntry to the type of referenceEntry.
if (null != referenceEntry && null != differenceEntry &&
0 == _comparer.Compare(referenceEntry, differenceEntry))
{
EmitMatch(referenceEntry);
return;
}
// If differenceEntry matches any entry in referenceEntryBacklog
// Emit the backlog entry as a match
// Remove the backlog entry from referenceEntryBacklog
// Clear differenceEntry
OrderByPropertyEntry matchingEntry =
MatchAndRemove(differenceEntry, _referenceEntryBacklog);
if (null != matchingEntry)
{
EmitMatch(matchingEntry);
differenceEntry = null;
}
// If referenceEntry (if any) matches any entry in differenceEntryBacklog
// Emit referenceEntry as a match
// Remove the backlog entry from differenceEntryBacklog
// Clear referenceEntry
matchingEntry =
MatchAndRemove(referenceEntry, _differenceEntryBacklog);
if (null != matchingEntry)
{
EmitMatch(referenceEntry);
referenceEntry = null;
}
// If differenceEntry is still present
// If SyncWindow is 0
// Emit differenceEntry as unmatched
// Else
// While there is no space in differenceEntryBacklog
// Emit oldest entry in differenceEntryBacklog as unmatched
// Remove oldest entry from differenceEntryBacklog
// Add differenceEntry to differenceEntryBacklog
if (null != differenceEntry)
{
if (0 < SyncWindow)
{
while (_differenceEntryBacklog.Count >= SyncWindow)
{
EmitDifferenceOnly(_differenceEntryBacklog[0]);
_differenceEntryBacklog.RemoveAt(0);
}
_differenceEntryBacklog.Add(differenceEntry);
}
else
{
EmitDifferenceOnly(differenceEntry);
}
}
// If referenceEntry is still present
// If SyncWindow is 0
// Emit referenceEntry as unmatched
// Else
// While there is no space in referenceEntryBacklog
// Emit oldest entry in referenceEntryBacklog as unmatched
// Remove oldest entry from referenceEntryBacklog
// Add referenceEntry to referenceEntryBacklog
if (null != referenceEntry)
{
if (0 < SyncWindow)
{
while (_referenceEntryBacklog.Count >= SyncWindow)
{
EmitReferenceOnly(_referenceEntryBacklog[0]);
_referenceEntryBacklog.RemoveAt(0);
}
_referenceEntryBacklog.Add(referenceEntry);
}
else
{
EmitReferenceOnly(referenceEntry);
}
}
}
public static DataAccessRegister ForRegister(Diagnostics.Span span, int registerIndex)
{
return new DataAccessRegister { span = span, registerIndex = registerIndex };
}
public override bool VisitFunctionDecl(Function function)
{
if (!VisitDeclaration(function) || function.IsSynthetized ||
function.IsExplicitlyGenerated)
{
return(false);
}
if (function.IsDependent && !(function.Namespace is Class))
{
function.GenerationKind = GenerationKind.None;
Diagnostics.Debug("Function '{0}' was ignored due to dependent context",
function.Name);
return(false);
}
var ret = function.OriginalReturnType;
string msg;
if (HasInvalidType(ret.Type, function, out msg))
{
function.ExplicitlyIgnore();
Diagnostics.Debug("Function '{0}' was ignored due to {1} return decl",
function.Name, msg);
return(false);
}
foreach (var param in function.Parameters)
{
if (HasInvalidDecl(param, out msg))
{
function.ExplicitlyIgnore();
Diagnostics.Debug("Function '{0}' was ignored due to {1} param",
function.Name, msg);
return(false);
}
if (HasInvalidType(param, out msg))
{
function.ExplicitlyIgnore();
Diagnostics.Debug("Function '{0}' was ignored due to {1} param",
function.Name, msg);
return(false);
}
if (CheckDecayedTypes)
{
var decayedType = param.Type.Desugar() as DecayedType;
if (decayedType != null)
{
function.ExplicitlyIgnore();
Diagnostics.Debug("Function '{0}' was ignored due to unsupported decayed type param",
function.Name);
return(false);
}
}
if (param.Kind == ParameterKind.IndirectReturnType)
{
Class retClass;
param.Type.Desugar().TryGetClass(out retClass);
if (retClass == null)
{
function.ExplicitlyIgnore();
Diagnostics.Debug(
"Function '{0}' was ignored due to an indirect return param not of a tag type",
function.Name);
return(false);
}
}
}
return(true);
}
public int GetLineIndexAtSpanStart(Diagnostics.Span span)
{
return this.GetLineAtPos(span.start);
}
internal void LeaveScope()
{
Diagnostics.Assert(_scopes.Count > 0, "Scope stack can't be empty when leaving a scope");
_scopes.RemoveAt(_scopes.Count - 1);
}
public int GetColumnAtSpanStart(Diagnostics.Span span)
{
return this.GetColumnAtPos(span.start);
}
internal CommandExecutionAttemptResult HandleLine(CString8 *input, bool verboseFailure, bool useHelp)
{
Diagnostics.Assert(input != null, "Prompter::HandleLine(CString8*): Parameter 'input' is null");
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Function started");
#endif
if (input->Length == 0)
{
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Raw input is blank");
#endif
if (verboseFailure)
{
HandleEmptyCommandEntry();
}
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return(CommandExecutionAttemptResult.BlankEntry);
}
CString8 *trimmedInput = input->Trim();
if (trimmedInput->Length == 0)
{
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Trimmed input is blank");
#endif
CString8.DISPOSE(trimmedInput);
if (verboseFailure)
{
HandleEmptyCommandEntry();
}
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return(CommandExecutionAttemptResult.BlankEntry);
}
int firstSpace = trimmedInput->IndexOf(" ");
CString8 *commandName;
CString8 *parameters;
if (firstSpace < 0)
{
commandName = trimmedInput;
parameters = CString8.CreateEmpty();
}
else
{
commandName = trimmedInput->Substring(0, firstSpace);
parameters = trimmedInput->Substring(firstSpace + 1);
}
CommandTableEntry *command = this.FindCommand(commandName);
if (command == null)
{
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Command not found");
#endif
if (verboseFailure)
{
HandleUnrecognizedCommandEntry(commandName);
}
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Freeing contextual stuff");
#endif
//Free up what we used
if (commandName != trimmedInput)
{
CString8.DISPOSE(commandName);
}
CString8.DISPOSE(trimmedInput);
CString8.DISPOSE(parameters);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return(CommandExecutionAttemptResult.NotFound);
}
CommandExecutionContext *commandExecutionContext = CommandExecutionContext.CREATE();
commandExecutionContext->parameters = parameters;
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Getting ready to call command");
#endif
if (!useHelp)
{
ADC.MemoryUtil.Call(command->func_Execute, (void *)commandExecutionContext);
}
else
{
ADC.MemoryUtil.Call(command->func_GetHelp, (void *)commandExecutionContext);
}
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Done calling command");
#endif
//Free up what we used
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): Freeing contextual stuff");
#endif
if (commandName != trimmedInput)
{
CString8.DISPOSE(commandName);
}
CString8.DISPOSE(trimmedInput);
CString8.DISPOSE(parameters);
CommandExecutionContext.DISPOSE(commandExecutionContext);
#if Prompter_DebuggingVerbosity
Diagnostics.Message("Prompter::HandleLine(CString8*): RET");
#endif
return(CommandExecutionAttemptResult.Success);
}
public static void AddElectricalDiagnostics(SEGRepository segR, Guid assetId)
{
List<Diagnostics> electrical = DiagnosticsHelper.GetElectricalDiagnostics(segR,assetId).ToList();
int nextIndex = 1;
if(electrical.Count>0)
{
nextIndex = electrical.OrderBy(x => x.Index).Last().Index + 1;
}
using (SEGContext seg = segR.GetContext())
{
DiagnosticsType dtEle = seg.DiagnosticsTypes.FirstOrDefault(a => a.Name == "Electrical");
ItemClass icEle = seg.ItemClasses.FirstOrDefault(a => a.Name == "Electrical");
List<Item> dtEItems = seg.Items.Where(x => x.ItemClassId == icEle.Id).OrderBy(x => x.Index).ToList();
// Asset info
AssetInfo ai = new AssetInfo();
ai.Key = "EDIAG_" + nextIndex + "_INFO1";
ai.Value = "";
ai.AssetId = assetId;
seg.AssetInfos.Add(ai);
ai = new AssetInfo();
ai.Key = "EDIAG_" + nextIndex + "_INFO2";
ai.Value = "";
ai.AssetId = assetId;
seg.AssetInfos.Add(ai);
ai = new AssetInfo();
ai.Key = "EDIAG_" + nextIndex + "_INFO3";
ai.Value = "";
ai.AssetId = assetId;
seg.AssetInfos.Add(ai);
ai = new AssetInfo();
ai.Key = "EDIAG_" + nextIndex + "_INFO4";
ai.Value = "";
ai.AssetId = assetId;
seg.AssetInfos.Add(ai);
// Mechanical Diagnostics
Diagnostics d = new Diagnostics();
d.AreaId = Guid.Empty;
d.AssetId = assetId;
d.Index = nextIndex;
d.DiagnosticsTypeId = dtEle.Id;
seg.Diagnostics.Add(d);
seg.SaveChanges();
foreach (Item i in dtEItems)
{
DiagnosticsDetail dd = new DiagnosticsDetail();
dd.Comments = "";
dd.DiagnosticsId = d.Id;
dd.EntryDate = DateTime.MinValue;
dd.ExecutorId = Guid.Empty;
dd.ImageId = Guid.Empty;
dd.ItemId = i.Id;
dd.Status = "_new_";
dd.VerifierId = Guid.Empty;
dd.VerifyDate = DateTime.MinValue;
seg.DiagnosticsDetails.Add(dd);
}
seg.SaveChanges();
}
}
/// <summary>
/// Collision detection between the bullet and ai
/// </summary>
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Bullet"))
{
var bullet = other.gameObject.GetComponent <Bullet>();
//TODO: Ensure the owner is not colliding with their own bullet
// also make sure that owned AIs can't be hurt by their owners
// bullets.
// Also store the owner of the last bullet that hits so the player to add score to is known.
//Debug.Log("AI player ID: " + Utilities.GetPlayerID(gameObject));
if (bullet.Owner != Utilities.GetPlayerID(gameObject))
{
switch (aiType)
{
case NetworkedAI.AIType.ROGUE:
{
m_parentHealth.InflictDamage(bullet.Damage);
other.gameObject.GetComponent <Bullet>().DestroyOnImpact();
var player = PlayerManager.GetControllablePlayer();
if (player != null && bullet.Owner == Utilities.GetPlayerID(player))
{
player.GetComponent <PlayerScore>().AddScore(1.0f);
}
break;
}
case NetworkedAI.AIType.FLEET:
{
if (bullet.Owner == GetComponentInParent <FleetAI>().OwnerPlayerID)
{
if (Diagnostics.IsActive())
{
Debug.Log("It worked");
}
}
else
{
if (Diagnostics.IsActive())
{
Debug.Log("Non-player attacked fleet ship");
}
m_parentHealth.InflictDamage(bullet.Damage);
other.gameObject.GetComponent <Bullet>().DestroyOnImpact();
var player = PlayerManager.GetControllablePlayer();
if (player != null && bullet.Owner == Utilities.GetPlayerID(player))
{
player.GetComponent <PlayerScore>().AddScore(1.0f);
}
}
break;
}
case NetworkedAI.AIType.PATROL:
//TODO: Implement patrol hit detection logic.
if (bullet.Owner == GetComponentInParent <PatrolAI>().OwnerPlayerID)
{
if (Diagnostics.IsActive())
{
Debug.Log("It worked");
}
}
else
{
if (Diagnostics.IsActive())
{
Debug.Log("Non-player attacked fleet ship");
}
m_parentHealth.InflictDamage(bullet.Damage);
other.gameObject.GetComponent <Bullet>().DestroyOnImpact();
var player = PlayerManager.GetControllablePlayer();
if (player != null && bullet.Owner == Utilities.GetPlayerID(player))
{
player.GetComponent <PlayerScore>().AddScore(1.0f);
}
}
break;
}
}
}
}
