/// <summary>
/// 修改单个信号设置信息
/// </summary>
/// <param name="name">原信号名称</param>
/// <param name="changesetting">修改后的信号设置信息</param>
/// <returns></returns>
public static bool ChangeValue(string name, OneListSetting changesetting)
{
var onesetting = _Settings.Find((x) => x.SignalName == name);
if (onesetting == null)
{
cards[onesetting.OneCardSetting.cardname.Value].DelChannel(onesetting.OneCardSetting.channel.channel.Value);
CardSettingError.RaiseError(001);
return(false);
}
// setting修改
onesetting = changesetting;
// 采集卡修改
cards[changesetting.OneCardSetting.cardname.Value].SetSamplerate(changesetting.OneCardSetting.channel.channel.Value, changesetting.OneCardSetting.samplerate);
cards[changesetting.OneCardSetting.cardname.Value].SetValuesRange(changesetting.OneCardSetting.channel.channel.Value, changesetting.OneCardSetting.range.Value);
// 数据库修改
var info = CollectDataSet.GetSignal(name);
SignalInfo new_info = new SignalInfo();
new_info.cardname = changesetting.OneCardSetting.cardname.Value;
new_info.name = changesetting.SignalName;
new_info.position = changesetting.SensorPosition;
new_info.resolution = (ushort)cards[changesetting.OneCardSetting.cardname.Value].GetResolution();
new_info.sensortype = changesetting.SensorType;
new_info.signalrange = changesetting.OneCardSetting.range.Value;
new_info.detectequipment = changesetting.DetectEquipment;
new_info.resolutiondouble = cards[changesetting.OneCardSetting.cardname.Value].GetDoubleResolution(changesetting.OneCardSetting.range.Value, out new_info.basevalue);
CollectDataSet.ChgSignal(info, new_info);
ListChanged?.Invoke("Chg", changesetting);
return(true);
}
public static T Emit <T>(Node emitter, string signal, params object[] args)
{
T response = default(T);
int length = args != null ? args.Length : 0;
object[] newArgs = new object[length + 1];
System.Array.Copy(args, 0, newArgs, 0, length);
SignalInfo signalInfo = new SignalInfo();
newArgs[length] = signalInfo;
emitter.EmitSignal(signal, newArgs);
if (!signalInfo.IsDataReceived())
{
StringBuilder msg = new StringBuilder(signal).Append(" emitted by ");
msg.Append(emitter.Name).Append(" could not return a value!");
GD.PushError(msg.ToString());
}
else
{
response = signalInfo.GetData <T>();
}
return(response);
}
/// <summary>
/// 添加单行信号设置
/// </summary>
/// <param name="onesetting">单个信号设置</param>
/// <returns>是否添加成功</returns>
public static bool AddSetting(OneListSetting onesetting)
{
// setting添加
_Settings.Add(onesetting);
// 采集卡进行设置采样频率以及电信号范围
cards[onesetting.OneCardSetting.cardname.Value].SetSamplerate(onesetting.OneCardSetting.channel.channel.Value, onesetting.OneCardSetting.samplerate);
cards[onesetting.OneCardSetting.cardname.Value].SetValuesRange(onesetting.OneCardSetting.channel.channel.Value, onesetting.OneCardSetting.range.Value);
// 将该行信号设置添加到数据库母表，并建立对应子表
SignalInfo info = new SignalInfo();
info.cardname = onesetting.OneCardSetting.cardname.Value;
info.name = onesetting.SignalName;
info.position = onesetting.SensorPosition;
info.resolution = (ushort)cards[onesetting.OneCardSetting.cardname.Value].GetResolution();
info.sensortype = onesetting.SensorType;
info.signalrange = onesetting.OneCardSetting.range.Value;
info.detectequipment = onesetting.DetectEquipment;
info.resolutiondouble = cards[onesetting.OneCardSetting.cardname.Value].GetDoubleResolution(onesetting.OneCardSetting.range.Value, out info.basevalue);
CollectDataSet.AddSignal(info);
// 事件
ListChanged?.Invoke("Add", onesetting);
return(true);
}
public ActionResult ClosePosition([FromQuery] int account, [FromQuery] int Magic, [FromQuery] int Ticket)
{
try
{
SignalInfo signalPos = null;
if (Ticket > 0)
{
signalPos = MainService.CreateSignal(SignalFlags.Terminal, account,
EnumSignals.SIGNAL_CLOSE_POSITION, 0);
}
else
{
signalPos = MainService.CreateSignal(SignalFlags.Expert, Magic, EnumSignals.SIGNAL_CLOSE_POSITION,
0);
}
signalPos.Value = Ticket;
signalPos.SetData(Magic.ToString());
//signalPos.Data = Magic.ToString();
MainService.PostSignalTo(signalPos);
var terminals = MainService.Container.Resolve <ITerminalEvents>();
if (terminals != null)
{
terminals.DeletePosition(Ticket);
}
return(Ok());
}
catch (Exception e)
{
log.Error(e.ToString());
return(Problem(e.ToString(), "Error", StatusCodes.Status500InternalServerError));
}
}
// Deliver a signal to a particular thread.
public void Deliver(long thread, int signal)
{
lock (this)
{
if (thread == -1)
{
/* This signal was delivered process-wide */
process_signals |= (((uint)1) << signal);
return;
}
SignalInfo current = info;
while (current != null)
{
if (current.thread == thread)
{
current.pending |= (((uint)1) << signal);
return;
}
current = current.next;
}
current = new SignalInfo();
current.thread = thread;
current.pending = (((uint)1) << signal);
current.nextToTest = 0;
current.next = info;
info = current;
Monitor.PulseAll(this);
}
}
protected override void OnReceived(byte[] buffer, long offset, long size)
{
string message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
try
{
#if DEBUG
log.Debug("Incoming: " + message);
#endif
string[] strings = message.Split(new char[] { (char)0x1A });
foreach (var str in strings)
{
if (string.IsNullOrEmpty(str))
{
continue;
}
SignalInfo signal = JsonConvert.DeserializeObject <SignalInfo>(str);
if (signal != null)
{
handler.PostSignal(signal, mServer);
}
}
}
catch (Exception e)
{
log.Error($"OnReceived: {message } e={e.ToString()}");
}
}
static void OnMarshal(IntPtr closure, ref GLib.Value retval, uint argc, IntPtr argsPtr,
IntPtr ihint, IntPtr data)
{
object [] args = new object[argc - 1];
object o = ((GLib.Value)Marshal.PtrToStructure(argsPtr, typeof(GLib.Value))).Val;
for (int i = 1; i < argc; i++)
{
IntPtr struct_ptr = (IntPtr)((long)argsPtr + (i * gvalue_struct_size));
GLib.Value argument = (GLib.Value)Marshal.PtrToStructure(struct_ptr, typeof(GLib.Value));
args[i - 1] = argument.Val;
}
if (data == IntPtr.Zero)
{
Console.Error.WriteLine("No available data");
return;
}
ObjectSignalKey k = (ObjectSignalKey)((GCHandle)data).Target;
if (k != null)
{
SignalInfo si = (SignalInfo)SignalHandlers[k];
GLib.SignalArgs arg = (GLib.SignalArgs)Activator.CreateInstance(si.ArgsType);
arg.Args = args;
si.RegisteredHandler.DynamicInvoke(new object[] { o, arg });
if (arg.RetVal != null)
{
retval.Val = arg.RetVal;
}
}
}
public ActionResult ListenSignal()
{
try
{
using (var reader = new StreamReader(Request.Body))
{
var response = reader.ReadToEndAsync();
if (string.IsNullOrEmpty(response.Result))
{
return(Ok());
}
SignalInfo signal = JsonConvert.DeserializeObject <SignalInfo>(response.Result);
if (signal == null)
{
return(Problem("NULL Signal passed as a parameter", "Error", StatusCodes.Status500InternalServerError));
}
var result = MainService.ListenSignal(signal.ObjectId, signal.Flags);
return(Ok(result));
}
}
catch (Exception e)
{
log.Error(e.ToString());
return(Problem(e.ToString(), "Error", StatusCodes.Status500InternalServerError));
}
}
private void FireOnFrame(SignalInfo info)
{
// Get image data
int width, height, stride;
Assert(GetParameter(channel, "ImageSizeX", out width));
Assert(GetParameter(channel, "ImageSizeY", out height));
Assert(GetParameter(channel, "BufferPitch", out stride));
// Get image address
IntPtr buffer;
Assert(GetParameter(info.Handle, "SurfaceAddr", out buffer));
// Send to our listeners
var handler = this.OnFrame;
if (handler != null)
{
handler(this, new FrameEventArgs
{
Buffer = buffer,
Width = width,
Height = height,
Stride = stride,
});
}
}
/// <summary>
/// 更新信号数据表
/// </summary>
/// <param name="dao">数据对象</param>
/// <returns>成功/失败</returns>
public bool Update(SignalInfo dao)
{
SqlStatement stmt = _session.CreateSqlStatement();
stmt.AppendString("update SignalInfo set ");
stmt.AppendString("GroupID=");
stmt.AppendParameter(_session.MakeInParameter("GroupID", dao.GroupID, SqlDbType.UniqueIdentifier));
stmt.AppendString(",Category=");
stmt.AppendParameter(_session.MakeInParameter("Category", dao.Category, SqlDbType.Int));
stmt.AppendString(",StationName=");
stmt.AppendParameter(_session.MakeInParameter("StationName", dao.StationName, SqlDbType.NVarChar));
stmt.AppendString(",SignalName=");
stmt.AppendParameter(_session.MakeInParameter("SignalName", dao.SignalName, SqlDbType.NVarChar));
stmt.AppendString(",SignalMileage=");
stmt.AppendParameter(_session.MakeInParameter("SignalMileage", dao.SignalMileage, SqlDbType.NVarChar));
stmt.AppendString(",SignalType=");
stmt.AppendParameter(_session.MakeInParameter("SignalType", dao.SignalType, SqlDbType.Int));
stmt.AppendString(",IsolationType=");
stmt.AppendParameter(_session.MakeInParameter("IsolationType", dao.IsolationType, SqlDbType.Int));
stmt.AppendString(",SectionName=");
stmt.AppendParameter(_session.MakeInParameter("SectionName", dao.SectionName, SqlDbType.NVarChar));
stmt.AppendString(",SectionCarrirer=");
stmt.AppendParameter(_session.MakeInParameter("SectionCarrirer", dao.SectionCarrirer, SqlDbType.NVarChar));
stmt.AppendString(",SectionLength=");
stmt.AppendParameter(_session.MakeInParameter("SectionLength", dao.SectionLength, SqlDbType.Int));
stmt.AppendString(",SectionAttribute=");
stmt.AppendParameter(_session.MakeInParameter("SectionAttribute", dao.SectionAttribute, SqlDbType.NVarChar));
stmt.AppendString(",Remark=");
stmt.AppendParameter(_session.MakeInParameter("Remark", dao.Remark, SqlDbType.NVarChar));
stmt.AppendString(" where ");
stmt.AppendString("ID=");
stmt.AppendParameter(_session.MakeInParameter("ID", dao.ID, SqlDbType.Int));
stmt.StatementType = SqlStatementType.Update;
return(_session.Excecute(stmt).RowsAffected > 0);
}
public ActionResult SendSignal()
{
Task <string> response = null;
try
{
using (var reader = new StreamReader(Request.Body))
{
response = reader.ReadToEndAsync();
if (string.IsNullOrEmpty(response.Result))
{
return(Problem("Empty data passed as a parameter", "Error",
StatusCodes.Status500InternalServerError));
}
var signal = SignalInfo.Create(response.Result);
var result = MainService.SendSignal(signal);
return(Ok(result));
}
}
catch (Exception e)
{
if (response != null && !string.IsNullOrEmpty(response.Result))
{
log.Error($"Result error:{response.Result} {e}");
}
else
{
log.Error(e.ToString());
}
return(Problem(e.ToString(), "Error", StatusCodes.Status500InternalServerError));
}
}
public override async Task Execute(IJobExecutionContext context)
{
if (Begin(context))
{
SetMessage("Job Locked");
Exit(context);
return;
}
try
{
thisJobDetail = context.JobDetail;
sched = context.Scheduler;
SignalInfo signal_UpdateRates =
MainService.thisGlobal.CreateSignal(SignalFlags.AllTerminals, 0, EnumSignals.SIGNAL_UPDATE_RATES, 0);
signal_UpdateRates.Data = MainService.thisGlobal.GetRatesList();
MainService.thisGlobal.PostSignalTo(signal_UpdateRates);
SetMessage("ExcahngeRatesJob Finished.");
}
catch (Exception ex)
{
SetMessage($"ERROR: {ex.ToString()}");
}
Exit(context);
await Task.CompletedTask;
}
public bool CheckTradeAllowed(SignalInfo signal)
{
var acc = todayStat.Accounts.Find(c => (c.Number == signal.ObjectId));
if (acc != null)
{
decimal balance = new decimal(0);
decimal.TryParse((string)signal.Data, out balance);
if (balance > 0)
{
acc.Balance = balance;
}
CheckRiskForAccount(ref acc);
signal.Value = acc.StopTrading?1:0;
signal.Data = acc.StopReason;
if (acc.StopTrading && !String.IsNullOrEmpty(acc.StopReason))
{
IWebLog log = Program.Container.Resolve <IWebLog>();
if (log != null)
{
log.Log(acc.StopReason);
}
}
return(acc.StopTrading);
}
return(true);
}
protected virtual void DoCreateNewFile(int nrSignals, bool overwrite)
{
Debug.Assert((nrSignals > 0), EdfConstants.NrSignalsShouldBeMoreThan0);
if (Active)
{
throw new DataFileIsOpenException(DataFileConsts.DataFileIsOpen);
}
if (!UseMemoryStream)
{
if (FileName.Trim() == string.Empty)
{
throw new DataFileException(EdfConstants.NoFileName);
}
if (File.Exists(FileName))
{
if (!overwrite)
{
throw new DataFileExistsException(DataFileConsts.DataFileDataExists);
}
File.Delete(FileName);
}
}
OpenReadOnly = false;
FileInfo = null;
SignalInfo.Clear();
Creating = true;
}
public HttpResponseMessage ClosePosition([FromUri] int account, [FromUri] int Magic, [FromUri] int Ticket)
{
try
{
SignalInfo signalPos = null;
if (Ticket > 0)
{
signalPos = MainService.CreateSignal(SignalFlags.Terminal, account, EnumSignals.SIGNAL_CLOSE_POSITION);
}
else
{
signalPos = MainService.CreateSignal(SignalFlags.Expert, Magic, EnumSignals.SIGNAL_CLOSE_POSITION);
}
signalPos.Value = Ticket;
signalPos.Data = Magic.ToString();
MainService.PostSignalTo(signalPos);
var terminals = MainService.Container.Resolve <ITerminalEvents>();
if (terminals != null)
{
terminals.DeletePosition(Ticket);
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception e)
{
log.Error(e.ToString());
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.ToString()));
}
}
public HttpResponseMessage ListenSignal(HttpRequestMessage request)
{
try
{
var response = request.Content.ReadAsStringAsync();
if (string.IsNullOrEmpty(response.Result))
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
SignalInfo signal = JsonConvert.DeserializeObject <SignalInfo>(response.Result);
if (signal == null)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError,
"Broken Signal passed as a parameter"));
}
var result = MainService.ListenSignal(signal.ObjectId, signal.Flags);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
catch (Exception e)
{
log.Error(e.ToString());
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
public void PostSignalTo(SignalInfo signal)
{
var to = (SignalFlags)signal.Flags;
if (to == SignalFlags.AllTerminals)
{
foreach (var que in signalQue)
{
que.Value.Enqueue(signal);
}
}
else if (to == SignalFlags.Expert || to == SignalFlags.Terminal)
{
PostSignal(signal);
}
else if (to == SignalFlags.Server)
{
var handler = Container.Resolve <ISignalHandler>();
handler?.PostSignal(signal, null);
}
else if (to == SignalFlags.Cluster)
{
var advisers = GetAdvisersByMetaSymbolId(signal.ObjectId);
if (Utils.HasAny(advisers))
{
foreach (var adv in advisers)
{
signal.Flags = (long)SignalFlags.Expert;
signal.ObjectId = adv.Id;
PostSignal(signal);
}
}
}
}
protected override void OnReceived(byte[] buffer, long offset, long size)
{
var message = Encoding.UTF8.GetString(buffer, (int)offset, (int)size);
try
{
#if DEBUG
log.Debug("Incoming: " + message);
#endif
var strings = message.Split(new[] { (char)0x1A });
foreach (var str in strings)
{
if (string.IsNullOrEmpty(str))
{
continue;
}
var signal = SignalInfo.Create(str);
handler.PostSignal(signal, mServer);
}
}
catch (Exception e)
{
log.Error($"OnReceived: {message} e={e}");
}
}
protected bool SignalModified()
{
if ((Active || Creating) && (SignalInfo.Count > 0))
{
return(SignalInfo.Any(aSignalInfo => aSignalInfo.Modified));
}
return(false);
}
protected bool CheckSignals()
{
if (!Active && !Creating)
{
return(false);
}
return(SignalInfo.All(aSignalInfo => aSignalInfo.DataValid));
}
protected void PostSignal(SignalInfo signal)
{
ConcurrentQueue <SignalInfo> que;
if (signalQue.TryGetValue(signal.ObjectId, out que))
{
que.Enqueue(signal);
}
}
public void DoLog(SignalInfo signal)
{
var message = new StringBuilder();
message.Append("<" + signal.ObjectId + ">:");
message.Append("(" + signal.Sym + "):");
message.Append(signal.Data);
log.Log(message.ToString());
log.Info(message);
}
public static SignalViewModel Create(SignalInfo signalInfo, string fileName)
{
return(new SignalViewModel
{
Characteristics = new SignalCharacteristicsViewModel(signalInfo.Characteristics),
FileName = fileName,
SignalMetadata = new SignalMetadataViewModel(signalInfo.SignalData.Metadata),
Points = new List <SignalDataPoint>(signalInfo.SignalData.Values.Select((p, counter) => new SignalDataPoint(counter.ToString(), p)).ToList())
});
}
public SignalInfo CreateSignal(SignalFlags flags, long ObjectId, EnumSignals Id, long chartId)
{
var signal = new SignalInfo();
signal.Flags = (long)flags;
signal.Id = (int)Id;
signal.ObjectId = ObjectId;
signal.Value = 1;
signal.ChartId = chartId;
return(signal);
}
public void MarketOrder(SignalInfo signal, IExpert adv)
{
try
{
if (adv == null)
{
return;
}
// decimal priceInOrder = Math.Round(tool.LastPrice + tool.Step * 5, tool.PriceAccuracy);
// decimal priceInOrder = 0;// Math.Round(tool.LastPrice, tool.PriceAccuracy);
int qty = (int)adv.Volume();
var portfolio = Portfolios.Where(x => x.Name == adv.AccountName()).FirstOrDefault();
if (!Trader.RegisteredPortfolios.Contains(portfolio))
{
Trader.RegisterPortfolio(portfolio);
}
Order order = new Order();
order.Type = OrderTypes.Market;
var securities = Securities.Where(x => x.Code == adv.Symbol());
if (securities != null && securities.Count() > 0)
{
order.Security = securities.FirstOrDefault();
}
else
{
order.Security = new Security();
order.Security.Code = adv.Symbol();
order.Security.Id = adv.Symbol() + "@FORTS";
}
order.Comment = adv.Comment();
order.Portfolio = portfolio;
if (!Trader.RegisteredSecurities.Contains(order.Security))
{
Trader.RegisterSecurity(order.Security);
Trader.RegisterTrades(order.Security);
}
order.Volume = qty;
order.Direction = signal.Value == 0 ? Sides.Buy : Sides.Sell;
Log(
$"Expert <{adv.AccountName()}> On {adv.Symbol()} {order.Direction.ToString()} Register order: lots=" +
qty);
Trader.RegisterOrder(order);
}
catch (Exception e)
{
Log($"Expert <{adv.AccountName()}> Error registering order: " + e);
}
}
// Suspend the current thread until a signal arrives.
public int Suspend(long thread, uint blocked)
{
lock (this)
{
// Get the signal information block for this thread.
SignalInfo current = info;
while (current != null)
{
if (current.thread == thread)
{
break;
}
current = current.next;
}
if (current == null)
{
current = new SignalInfo();
current.thread = thread;
current.pending = 0;
current.nextToTest = 0;
current.next = info;
info = current;
}
// Wait until an unblocked signal is delivered to us.
int signal = 0;
for (;;)
{
uint available =
(current.pending | process_signals);
if ((available & ~blocked) != 0)
{
// We use "nextToTest" to create fairness
// between multiple signals that arrive at
// the thread.
uint test = (((uint)1) << current.nextToTest);
while ((available & ~blocked & test) == 0)
{
current.nextToTest =
(current.nextToTest + 1) & 31;
test = (((uint)1) << current.nextToTest);
}
current.pending &= ~test;
process_signals &= ~test;
signal = current.nextToTest;
current.nextToTest =
(current.nextToTest + 1) & 31;
break;
}
Monitor.Wait(this);
}
return(signal);
}
}
private async Task <SignalViewModel> ProcessSignal(string fileName)
{
string fullPath = this.GetFileFullPath(fileName);
ISignalProcessorService signalProcessor = _signalProcessorServiceFactory.Create(fullPath);
SignalInfo signalInfo = await signalProcessor.ProcessFileAsync();
SignalViewModel signalViewModel = SignalViewModelBuilder.Create(signalInfo, fileName);
return(signalViewModel);
}
public override async Task Execute(IJobExecutionContext context)
{
if (Begin(context))
{
SetMessage("Job Locked");
Exit(context);
return;
}
try
{
thisJobDetail = context.JobDetail;
sched = context.Scheduler;
// MainService.thisGlobal.ClearPositions();
//PositionInfo position = new PositionInfo();
//position.Lots = 1;
//position.Type = 0;
//position.Symbol = "BRENT";
//SignalInfo signal_Order = MainService.thisGlobal.CreateSignal(SignalFlags.Cluster, 1, EnumSignals.SIGNAL_MARKET_MANUAL_ORDER);
//signal_Order.Value = 0;
//long ticket = NotRandom.Next() * 1000;
//PositionInfo pos = new PositionInfo { Symbol = "GOLD", Ticket = ticket, Lots = 0.01, Profit = new decimal(5) };
//var termNotify = MainService.thisGlobal.Container.Resolve<ITerminalEvents>();
//if (termNotify != null)
// termNotify.InsertPosition(pos);
SignalInfo signal_History =
MainService.thisGlobal.CreateSignal(SignalFlags.AllTerminals, 0, EnumSignals.SIGNAL_DEALS_HISTORY);
signal_History.Value = 0;
MainService.thisGlobal.PostSignalTo(signal_History);
// while(!context.CancellationToken.IsCancellationRequested)
// {
// Thread.Sleep(500);
// }
SetMessage("TestJob Finished.");
}
catch (Exception ex)
{
SetMessage($"ERROR: {ex}");
}
Exit(context);
await Task.CompletedTask;
}
/// <summary>
/// 获取指定大小的一页信号数据表集合
/// </summary>
/// <param name="pageIndex">当前页码</param>
/// <param name="pageSize">分页大小</param>
/// <param name="rowsCount">总记录条数</param>
/// <returns>分页数据</returns>
public ObservableCollection <SignalInfo> SelectAllCollection(int pageIndex, int pageSize, int rowsCount)
{
ObservableCollection <SignalInfo> datas = new ObservableCollection <SignalInfo>();
GenDataReader reader = Session.ExcecuteReader(_dal.SelectAllSqlStatement(), pageIndex, pageSize, rowsCount);
while (reader.Read())
{
SignalInfo dao = new SignalInfo();
_dal.DataReaderToEntity(reader, dao);
datas.Add(dao);
}
reader.Close();
return(datas);
}
protected override void DoCreateNewFile(int nrSignals, bool overwrite)
{
base.DoCreateNewFile(nrSignals, overwrite);
FileInfo.StrictChecking = StrictChecking;
for (int i = 0; i < nrSignals; i++)
{
EdfSignalInfo newSignalDef = (EdfSignalInfo)CreateSignalInfo();
newSignalDef.StrictChecking = StrictChecking;
SignalInfo.Add(newSignalDef);
}
DoOpenFile();
FileInfo.NrSignals = nrSignals;
FileInfo.NrDataRecords = 0;
}
protected void SetupInferior()
{
IntPtr data = IntPtr.Zero;
try {
check_error (mono_debugger_server_get_signal_info (
server_handle, out data));
signal_info = (SignalInfo) Marshal.PtrToStructure (
data, typeof (SignalInfo));
has_signals = true;
} finally {
g_free (data);
}
target_info = GetTargetMemoryInfo (address_domain);
try {
string cwd;
string[] cmdline_args;
string application = GetApplication (out cwd, out cmdline_args);
exe = process.OperatingSystem.LoadExecutable (
target_info, application, start.LoadNativeSymbolTable);
} catch (Exception e) {
if (error_handler != null)
error_handler (this, String.Format (
"Can't read symbol file {0}", start.TargetApplication), e);
else
Console.WriteLine ("Can't read symbol file {0}: {1}",
start.TargetApplication, e);
return;
}
arch = process.Architecture;
}
static bool handleSignals(XmlNode node, ElementInfo ei)
{
if (ei.signals == null)
ei.signals = new ArrayList ();
XmlElement elt = node as XmlElement;
if (elt == null)
return true;
foreach (XmlElement signal in elt.ChildNodes) {
if (IsHidden (signal))
continue;
SignalInfo si = new SignalInfo ();
si.name = signal["name"].InnerText;
si.managed_name = (signal["managed_name"] != null) ? signal["managed_name"].InnerText : null;
si.return_type = signal["return-type"].InnerText;
si.object_type = signal["object-type"].InnerText;
XmlElement parms = signal["params"];
if (parms != null) {
si.parameters = new ArrayList ();
foreach (XmlElement parm in parms.ChildNodes) {
SignalParameter par = new SignalParameter ();
par.type = parm.InnerText;
if (parm.Attributes["name"] == null)
throw new Exception ("All signal parameters need the 'name' attribute");
par.name = parm.Attributes["name"].InnerText;
si.parameters.Add (par);
}
}
ei.signals.Add (si);
}
return true;
}
public void setSignalInfo(SignalInfo signalInfo)
{
this.signalInfo = signalInfo;
}
public SignalResult(int signal, SignalInfo signalInfo)
{
this.signal = signal;
this.signalInfo = signalInfo;
}
