public void AddSymbol(AdsSymbol symbol)
{
if (Symbols.ContainsKey(symbol.Name))
{
throw new ArgumentException($"Symbol with the same name ('{symbol.Name}') already exists");
}
//Define Symbol Offset
var offset = GetCurrentDataOffset();
symbol.Offset = offset;
var symbolBytes = symbol.GetBytes();
//Add symbol to list
Symbols.Add(symbol.Name, symbol);
//Add symbol to data
memory.AddData(61451, symbolBytes);
memory.AddData(61449, symbolBytes);
//add symbol handlers
memory.AddData(61443, offset.GetBytes());
memory.AddData(61446, offset.GetBytes());
//Update symbolUploadInfo
memory.SetData(61455, new SymbolUploadInfo(Symbols.Count, GetCurrentSymbolSize()).GetBytes());
//Add Data
memory.AddData(61445, new byte[symbol.Size]);
}
// Function to search the symbol dictionary based on the selected value in the style file, category and/or geometry type ListBoxes
private void Search(string keyword)
{
// Create empty filter dictionary, not used
Dictionary <string, string> filters = new Dictionary <string, string>();
// Clear the current Symbols collection
Symbols.Clear();
// Perform the search applying any selected keywords and filters
IEnumerable <SymbolProperties> symbols = _symbolDictionary.FindSymbols(new List <string>()
{
keyword
}, filters);
var allSymbols = symbols.ToList();
RaisePropertyChanged("Keywords");
Debug.WriteLine(DateTime.Now);
// Add symbols to UI collection
foreach (var s in from symbol in allSymbols select new SymbolViewModel(symbol, _imageSize))
{
Symbols.Add(s);
}
Debug.WriteLine(DateTime.Now);
}
public void Add(char symbol)
{
if (numbers.Contains(symbol))
{
Symbols.Add(symbol);
}
else
{
if (Symbols.Count > 0)
{
return; //Если еще ничего не введено, то первым символом не может быть операнд
}
if (!IsLastSymbolOperandOrPoint) //Последний символ -не операнд и не запятая
{
if (symbol == ',' && MayPutPoint)
{
Symbols.Add(symbol);
}
else if (OperandsCount == 0) // и операнда еще нет
{
Symbols.Add(symbol);
}
}
}
this.Display();
}
public void AddTempo(string tempo)
{
Symbols.Add(new Tempo
{
BeatsPerMinute = Int32.Parse(tempo.Substring(tempo.IndexOf('=') + 1))
});
}
public Operand Call(MethodInfo info, params Operand[] callArgs)
{
if (Ptc.State == PtcState.Disabled)
{
IntPtr funcPtr = Delegates.GetDelegateFuncPtr(info);
OperandType returnType = GetOperandType(info.ReturnType);
Symbols.Add((ulong)funcPtr.ToInt64(), info.Name);
return(Call(Const(funcPtr.ToInt64()), returnType, callArgs));
}
else
{
int index = Delegates.GetDelegateIndex(info);
IntPtr funcPtr = Delegates.GetDelegateFuncPtrByIndex(index);
OperandType returnType = GetOperandType(info.ReturnType);
Symbols.Add((ulong)funcPtr.ToInt64(), info.Name);
return(Call(Const(funcPtr.ToInt64(), true, index), returnType, callArgs));
}
}
public static Boolean loadConfigurationFromConfigurationFile(String fullPath = "matheasy.config.txt")
{
try
{
DataStream ds = FileManager.ReadDataFromFile(fullPath);
String configDataFromFile = ds.Content;
String[] linesFromFile = configDataFromFile.Split(new String[] { "\n", Environment.NewLine, "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
if (linesFromFile.Length == 0)
{
return(false);
}
URL = linesFromFile[0];
for (int i = 1; i < linesFromFile.Length; i++)
{
String[] lineContent = linesFromFile[i].Split(' ');
if (lineContent.Length == 2)
{
Symbols.Add(lineContent[0], lineContent[1]);
}
else
{
return(false);
}
}
return(true);
}
catch (Exception ex)
{
System.Windows.MessageBox.Show(ex.Message);
return(false);
}
}
public LinkerSymbol DefineSymbol(string name, SectionKind kind, int alignment, int size)
{
uint aligned = alignment != 0 ? (uint)alignment : 1;
lock (_lock)
{
if (!symbolLookup.TryGetValue(name, out LinkerSymbol symbol))
{
symbol = new LinkerSymbol(name, aligned, kind);
Symbols.Add(symbol);
symbolLookup.Add(name, symbol);
symbol.IsExternalSymbol = false;
}
symbol.Alignment = aligned;
symbol.SectionKind = kind;
symbol.Stream = (size == 0) ? new MemoryStream() : new MemoryStream(size);
if (size != 0)
{
symbol.Stream.SetLength(size);
}
return(symbol);
}
}
public void saveTags()
{
foreach (var i in Items)
{
Symbols.Add(i.Tag as Symbol);
}
}
public ListModel(IEnumerable <SymbolModel> symbols)
{
foreach (SymbolModel symbol in symbols)
{
Symbols.Add(symbol);
}
}
public Name(string name)
{
id = count;
count++;
this.name = name;
Symbols.Add(this);
}
internal static void AddFunction(Label f)
{
if (!Symbols.ContainsKey(f.Addr))
{
Symbols.Add(f.Addr, f);
}
}
/// <summary>
/// Should return bool
/// </summary>
/// <param name="addr"></param>
/// <param name="confirmed"></param>
/// <returns></returns>
static void AddFunction(N64Ptr addr, bool confirmed)
{
addr = addr | 0x80000000;
// Label already mapped?
if (Symbols.TryGetValue(addr, out Label lbl))
{
if (lbl.Kind != Label.Type.FUNC)
{
if (confirmed || !lbl.Confirmed)
{
lbl.Kind = Label.Type.FUNC;
}
}
if (lbl.Kind == Label.Type.FUNC)
{
lbl.hits++;
if (confirmed)
{
lbl.Confirmed = confirmed;
}
}
}
else
{
Symbols.Add(addr, new Label(Label.Type.FUNC, addr, confirmed));
}
}
public Name()
{
id = count;
count++;
this.name = "tmp" + count.ToString() + "";
Symbols.Add(this);
}
public FolderModel(IEnumerable <string> symbols)
{
foreach (string symbol in symbols)
{
Symbols.Add(symbol);
}
}
private void readFile(string filename)
{
string json = File.ReadAllText(filename);
Rules.AddRange(Rule.FromJson(json));
List <Symbol> temp = new List <Symbol>();
// 找出所有的符号
foreach (var rule in Rules)
{
temp.Add(rule.Left);
temp.AddRange(rule.Right);
}
Symbols.AddRange(temp.Distinct().ToList());
foreach (var sym in Symbols)
{
if (sym.Type == "N")
{
N_Symbols.Add(sym);
}
if (sym.Type == "V")
{
V_Symbols.Add(sym);
}
}
Symbols.Add(D);
}
private void InitDefaultSymbols()
{
Symbols.Add("SP", 0);
Symbols.Add("LCL", 1);
Symbols.Add("ARG", 2);
Symbols.Add("THIS", 3);
Symbols.Add("THAT", 4);
Symbols.Add("R0", 0);
Symbols.Add("R1", 1);
Symbols.Add("R2", 2);
Symbols.Add("R3", 3);
Symbols.Add("R4", 4);
Symbols.Add("R5", 5);
Symbols.Add("R6", 6);
Symbols.Add("R7", 7);
Symbols.Add("R8", 8);
Symbols.Add("R9", 9);
Symbols.Add("R10", 10);
Symbols.Add("R11", 11);
Symbols.Add("R12", 12);
Symbols.Add("R13", 13);
Symbols.Add("R14", 14);
Symbols.Add("R15", 15);
Symbols.Add("SCREEN", 16384);
Symbols.Add("KBD", 24576);
}
public void AddSymbol(Symbol symbol)
{
if (!Symbols.Contains(symbol))
{
Symbols.Add(symbol);
}
}
/// <summary>
/// access a symbol with string
/// </summary>
/// <param name="value"></param>
/// <param name="symbolType"></param>
/// <returns></returns>
public ISymbol GetOrCreateSymbol(string value, SymbolType symbolType)
{
if (symbolType == SymbolType.Terminal)
{
if (value == Terminal.EndOfFile.Value)
{
return(Terminal.EndOfFile);
}
if (value == "")
{
return(Terminal.Epsilon);
}
if (!Symbols.ContainsKey(value))
{
Symbols.Add(value, new Terminal(value));
}
return(Symbols[value]);
}
// else
if (!Symbols.ContainsKey(value))
{
Symbols.Add(value, new Variable(value));
}
return(Symbols[value]);
}
private void OnSearch(object parameter)
{
Dictionary <string, string> filters = new Dictionary <string, string>();
// Clear the current Symbols collection
Symbols.Clear();
// Perform the search applying any selected keywords and filters
IEnumerable <SymbolProperties> symbols = MilitarySymbolDictionary.FindSymbols(filters);
if (!String.IsNullOrWhiteSpace(SearchString))
{
foreach (var ss in SearchString.Split(new char[] { ';', ',' }))
{
if (!String.IsNullOrWhiteSpace(ss))
{
symbols = symbols.Where(s => s.Name.ToLower().Contains(ss.ToLower().Trim()) || s.Keywords.Count(kw => kw.ToLower().Contains(ss.ToLower().Trim())) > 0);
}
}
}
var allSymbols = symbols.ToList();
// Add symbols to UI collection
foreach (var s in from symbol in allSymbols select new SymbolViewModel(symbol, _imageSize))
{
Symbols.Add(s);
}
}
public void AddTimeSignature(string timeSignature)
{
Symbols.Add(new TimeSignature
{
NumberOfBeats = Int32.Parse(timeSignature.Substring(0, timeSignature.IndexOf('/'))),
Measure = Int32.Parse(timeSignature.Substring(timeSignature.IndexOf('/') + 1))
});
}
public void AddSymbol(String symbol)
{
this.EnsureSymbolIsNotSpontaneous(symbol);
this.EnsureSymbolIsValid(symbol);
this.EnsureNotContainsSymbol(symbol);
Symbols.Add(symbol);
}
internal void Add(int position, string character, int characterType, LinearPattern pattern)
{
int width = pattern.GetWidth();
LinearSymbol symbol = new LinearSymbol(character, characterType, pattern, width);
Symbols.Add(position, symbol);
MinimumWidth += width;
}
public void AddSymbol(ISwfCharacter obj, string name)
{
Symbols.Add(new SwfAsset(obj, name)
{
IsSymbol = true,
Name = name
});
}
public void AddSymbol(ushort id, string name)
{
Symbols.Add(new SwfAsset(id, name)
{
IsSymbol = true,
Name = name
});
}
public void Calculate()
{
var in1 = "";
var in2 = "";
double result = 0;
var second = false;
var operand = '+';
foreach (var sym in Symbols)
{
if (operands.Contains(sym))
{
operand = sym;
second = true;
}
if (!second)
{
in1 += sym;
}
else
{
in2 += sym;
}
}
if (operand == '/' && in2 == "0")
{
textBox.Text = "Бесконечность";
Symbols.Clear();
return;
}
try
{
switch (operand)
{
case '+': result = float.Parse(in1) + float.Parse(in2); break;
case '-': result = float.Parse(in1) - float.Parse(in2); break;
case '*': result = float.Parse(in1) * float.Parse(in2); break;
case '/': result = float.Parse(in1) / float.Parse(in2); break;
}
}
catch
{
return;
}
Symbols.Clear();
textBox.Text = (result.ToString());
for (int i = 0; i < result.ToString().Length; i++)
{
Symbols.Add(result.ToString()[i]);
}
}
protected virtual void AddLetters(ISymbol symbol)
{
// Add it to the collection
Symbols.Add(symbol);
if (FirstLetters == 0)
{
FirstLetters = Count;
}
}
public bool AddSymbol(Token token, string type)
{
try {
Symbols.Add(token.Text, new Symbol(token, type));
return(true);
} catch {
return(false);
}
}
protected virtual void AddForename(ISymbol symbol)
{
// Add it to the collection
Symbols.Add(symbol);
if (FirstForename == 0)
{
FirstForename = Count;
}
}
public Line(string line) : this()
{
var symbols = line.Split(' ');
foreach (var item in symbols)
{
Symbols.Add(new Symbol(item));
}
}
protected virtual void AddSuffix(ISymbol symbol)
{
// Add it to the collection
Symbols.Add(symbol);
if (FirstSuffix == 0)
{
FirstSuffix = Count;
}
}
