public override void Generate(ILGenerator generator, Symbols symbols)
{
//Save the previous variables
var currentVariables = new List<string>();
foreach (var item in symbols.Variables)
{
currentVariables.Add(item.Key);
generator.Emit(OpCodes.Ldsfld, symbols.Variables[item.Key]);
}
DeclarationBlock.Generate(generator, symbols);
InstructionsBlock.Generate(generator, symbols);
LocalBuilder returnValue = null;
if (InstructionsBlock.ExpressionType.Type != TypesEnumeration.Void)
{
returnValue = generator.DeclareLocal(symbols.GetRealType(InstructionsBlock.ExpressionType.ILName));
generator.Emit(OpCodes.Stloc, returnValue);
}
currentVariables.Reverse();
//load in the variables it's previous values
currentVariables.ForEach(x => generator.Emit(OpCodes.Stsfld, symbols.Variables[x]));
if (InstructionsBlock.ExpressionType.Type != TypesEnumeration.Void)
generator.Emit(OpCodes.Ldloc, returnValue);
}
private static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMap(
MetadataReader reader,
Symbols.Metadata.PE.MetadataDecoder metadataDecoder)
{
var result = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>();
foreach (var handle in reader.TypeDefinitions)
{
var def = reader.GetTypeDefinition(handle);
if (!def.Namespace.IsNil)
{
continue;
}
if (!reader.StringStartsWith(def.Name, GeneratedNames.AnonymousNamePrefix))
{
continue;
}
var metadataName = reader.GetString(def.Name);
short arity;
var name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out arity);
int index;
if (GeneratedNames.TryParseAnonymousTypeTemplateName(name, out index))
{
var builder = ArrayBuilder<string>.GetInstance();
if (TryGetAnonymousTypeKey(reader, def, builder))
{
var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
var key = new AnonymousTypeKey(builder.ToImmutable());
var value = new AnonymousTypeValue(name, index, type);
result.Add(key, value);
}
builder.Free();
}
}
return result;
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
if (symbols.Records.ContainsKey(Alias.ILName))
symbols.Records.Add(Identifier.ILName, symbols.Records[Alias.ILName]);
else
symbols.ArraysTypes.Add(Identifier.ILName, symbols.ArraysTypes[Alias.ILName]);
}
public void BindFixtureSymbols(Symbols symbols, DbCommand dc)
{
foreach (String paramName in ExtractParamNames(dc.CommandText))
{
AddInput(dc, paramName, symbols.GetValueOrDefault(paramName, null));
}
}
public override void Generate(ILGenerator generator, Symbols s)
{
var Is_False = generator.DefineLabel();
var End = generator.DefineLabel();
LeftOperand.Generate(generator, s);
//Pregunto si hay un 0 en el tope d la pila
generator.Emit(OpCodes.Ldc_I4_0);
//Si es verdad salto para la etiqueta es falso
generator.Emit(OpCodes.Beq, Is_False);
RightOperand.Generate(generator, s);
//Pregunto si hay un 0 en el tope d la pila
generator.Emit(OpCodes.Ldc_I4_0);
//Si es verdad salto para la etiqueta es falso
generator.Emit(OpCodes.Beq, Is_False);
//Si hay un 1 en el tope es porque no salte para el label que me dice si hay algun false ,
//por lo q el primer operando es true y entonces es true el and
generator.Emit(OpCodes.Ldc_I4_1);
generator.Emit(OpCodes.Br, End);
generator.MarkLabel(Is_False);
generator.Emit(OpCodes.Ldc_I4_0);
generator.MarkLabel(End);
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
for (int i = 0; i < Count; i++)
{
this[i].Generate(generator, symbols);
if (i < Count - 1 && this[i].ExpressionType.Type != TypesEnumeration.Void) generator.Emit(OpCodes.Pop);
}
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
Index.Generate(generator, symbols);
generator.Emit(OpCodes.Ldelem, symbols.GetRealType(Index.ILName));
if (NextNested != null)
NextNested.Generate(generator, symbols);
}
public void SetUp()
{
symbols = A.Fake<Symbols>();
tokenizer = A.Fake<Tokenizer>();
executor = A.Fake<Executor>();
sut = new Interpreter(symbols, tokenizer, executor);
}
public void SetUp()
{
sut = new StatementRunner();
symbols = new SymbolsTable();
core = A.Fake<WebCoreRepository>();
context = new Context(symbols, core);
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
//FieldIdentifier.Generate(generator, symbols);
generator.Emit(OpCodes.Ldfld, symbols.Variables[FieldIdentifier.ILName]);
if (NextNested != null)
NextNested.Generate(generator, symbols);
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
var typeFeild = symbols.Variables[Record.ILName];
generator.Emit(OpCodes.Ldsfld, typeFeild);
//NextNested.FieldIdentifier.Generate(generator, symbols);
generator.Emit(OpCodes.Ldfld, symbols.Variables[NextNested.FieldIdentifier.ILName]);
if (NextNested.NextNested != null)
NextNested.NextNested.Generate(generator, symbols);
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
var varVariable = symbols.Variables[ArrayIdentifier.ILName];
generator.Emit(OpCodes.Ldsfld, varVariable);
NextNested.Index.Generate(generator, symbols);
generator.Emit(OpCodes.Ldelem, symbols.GetRealType(NextNested.Index.ILName));
if (NextNested.NextNested != null)
NextNested.NextNested.Generate(generator, symbols);
}
public static void GenerateCode(LanguageNode root, string path)
{
var s = new Symbols(path);
var generator = s.MainMethod.GetILGenerator();
root.Generate(generator, s);
generator.Emit(OpCodes.Ret);
s.ProgramType.CreateType();
s.Assembly.SetEntryPoint(s.MainMethod);
s.Assembly.Save(s.AssemblyName.Name + ".exe");
}
public static ControlFlowGraph DoBuildControlFlowGraph(IMethodBody cil, Symbols symbols)
{
ReadOnlyDictionary<ControlFlowBlock, ReadOnlyCollection<IILOp>> blocks2parts;
var cfg = CreateCarcass.DoCreateCarcass(cil, out blocks2parts);
foreach (var cfb in blocks2parts.Keys)
{
InitialDecompilation.DoPrimaryDecompilation(cfb, blocks2parts[cfb], symbols);
}
return cfg;
}
public override void Generate(ILGenerator generator, Symbols s)
{
LeftOperand.Generate(generator, s);
RightOperand.Generate(generator, s);
if (LeftOperand.ExpressionType.Type == TypesEnumeration.String)
{
generator.Emit(OpCodes.Call, typeof(string).GetMethod("Compare", new []{typeof(string), typeof(string)}));
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Ceq);
}
else
generator.Emit(OpCodes.Ceq);
}
public static DataTable GetDataTable(Symbols symbols, String query,IDbEnvironment environment, int rsNo)
{
DbCommand dc = environment.CreateCommand(query, CommandType.Text);
if (Options.ShouldBindSymbols())
environment.BindFixtureSymbols(symbols, dc);
DbDataAdapter oap = environment.DbProviderFactory.CreateDataAdapter();
oap.SelectCommand = dc;
var ds = new DataSet();
oap.Fill(ds);
dc.Dispose();
return ds.Tables[rsNo - 1];
}
public override void Generate(ILGenerator generator, Symbols s)
{
LeftOperand.Generate(generator, s);
RightOperand.Generate(generator, s);
if (LeftOperand.ExpressionType.Type == TypesEnumeration.Integer)
generator.Emit(OpCodes.Clt);
else
{
generator.Emit(OpCodes.Call, typeof(String).GetMethod("CompareTo", new Type[] { typeof(string) }));
generator.Emit(OpCodes.Ldc_I4_M1);
generator.Emit(OpCodes.Ceq);
}
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
var recordBuilder = symbols.ModuleBuilder.DefineType(Identifier.ILName, TypeAttributes.Public);
symbols.Records.Add(Identifier.ILName, recordBuilder);
foreach (var item in FieldDeclarationList)
{
item.ILName = Identifier.ILName + item.Field.ILName;
Type _type = symbols.GetRealType(item.TypeName.ILName);
FieldBuilder fieldBuilder = recordBuilder.DefineField(item.ILName,
_type,
FieldAttributes.Public);
symbols.Variables.Add(item.ILName, fieldBuilder);
}
recordBuilder.CreateType();
}
private void GenerateFieldAccess(FieldNestedNode current, ILGenerator generator, Symbols symbols)
{
if (current.NextNested != null)
{
generator.Emit(OpCodes.Ldfld, symbols.Variables[current.FieldIdentifier.ILName]);
if (current.NextNested is FieldNestedNode)
GenerateFieldAccess((FieldNestedNode)current.NextNested, generator, symbols);
else
GenerateIndexAccess((IndexNestedNode)current.NextNested, generator, symbols);
}
else
{
Expr.Generate(generator, symbols);
generator.Emit(OpCodes.Stfld, symbols.Variables[current.FieldIdentifier.ILName]);
}
}
public static void DoRestoreOpAssignOperators(ControlFlowGraph cfg, Symbols symbols)
{
var dirty = true;
var dfa = new DfaHelper(cfg);
while (dirty)
{
dirty = false;
foreach (var atom in dfa.Atoms())
{
if (dirty |= TryMatchPattern1(dfa, atom)) break;
if (dirty |= TryMatchPattern2(dfa, atom)) break;
if (dirty |= TryMatchPattern3(dfa, atom)) break;
if (dirty |= TryMatchPattern4(dfa, atom)) break;
}
}
}
public static void SetParameterValue(Symbols symbols, String name, Object value)
{
if (value == null || "null".Equals(value.ToString().ToLower()))
{
symbols.Save(name, DBNull.Value);
}
else if (value != null && value.ToString().StartsWith("<<"))
{
string varname = value.ToString().Substring(2);
if (!name.Equals(varname))
{
symbols.Save(name, symbols.GetValueOrDefault(varname, null));
}
}
else
symbols.Save(name, value);
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
if (Identifier is IdNode)
{
var lvalue = symbols.Variables[Identifier.ILName];
Expr.Generate(generator, symbols);
generator.Emit(OpCodes.Stsfld, lvalue);
}
else
{
var variable = symbols.Variables[Identifier.ILName];
generator.Emit(OpCodes.Ldsfld, variable);
if (Identifier is AccessFieldNode)
GenerateFieldAccess(((AccessFieldNode)Identifier).NextNested, generator, symbols);
else
GenerateIndexAccess(((ArrayItemNode)Identifier).NextNested, generator, symbols);
}
}
public override void Generate(ILGenerator generator, Symbols s)
{
var Is_True = generator.DefineLabel();
var End = generator.DefineLabel();
LeftOperand.Generate(generator, s);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Bne_Un, Is_True);
RightOperand.Generate(generator, s);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Bne_Un, Is_True);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Br, End);
generator.MarkLabel(Is_True);
generator.Emit(OpCodes.Ldc_I4_1);
generator.MarkLabel(End);
}
public override void Generate(ILGenerator generator, Symbols s)
{
LeftOperand.Generate(generator, s);
RightOperand.Generate(generator, s);
if (LeftOperand.ExpressionType.Type == TypesEnumeration.String)
{
generator.Emit(OpCodes.Call, typeof(string).GetMethod("Compare", new[] { typeof(string), typeof(string) }));
var peek = generator.DeclareLocal(typeof (int));
generator.Emit(OpCodes.Stloc, peek);
generator.Emit(OpCodes.Ldloc,peek);
generator.Emit(OpCodes.Ldloc, peek);
generator.Emit(OpCodes.Mul);
}
else
{
generator.Emit(OpCodes.Ceq);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Ceq);
}
}
protected override void OnStart()
{
EURUSDSymbol = Symbols.GetSymbol(EURUSDSymbolCode);
USDCHFSymbol = Symbols.GetSymbol(USDCHFSymbolCode);
ExitAtBreakEven = false;
///<summary>
/// This statement is to ensure the ExitAtBreakEven flag is set correctly if the application is restarted in the middle of a trade.
/// Specifically, if TotalBuyPips or TotalSellPips is greater than the TakeProfitInPip value the profit is taken and the pair closed,
/// leaving the remaining pair. The ExitAtBreakEven flag is set to true to close the remaining pair off as soon as possible.
///
/// If the application stops and is estarted the status of the ExitAtBreakEven flag is lost. his check will set the ExitAtBreakEven flag
/// to true if any pair ( buy or sell, but not both) is still active.
///</summary>
if ((Positions.FindAll(BuyLabel).Length > 0 && Positions.FindAll(SellLabel).Length == 0) || (Positions.FindAll(BuyLabel).Length == 0 && Positions.FindAll(SellLabel).Length > 0))
{
ExitAtBreakEven = true;
}
Print("Break even flag = ", ExitAtBreakEven);
}
public override void Generate(ILGenerator generator, Symbols s)
{
// Definir los lables necesarios
var loopLabel = generator.DefineLabel();
var endLabel = generator.DefineLabel();
// Guardar el posible break que podria existir en el codigo
s.NestedCylesBreakJumps.Push(endLabel);
// Salto a la evaluacion de la condicion
generator.MarkLabel(loopLabel);
Condition.Generate(generator, s);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Beq, endLabel);
// Codigo del cuerpo
Loop.Generate(generator, s);
// looping
generator.Emit(OpCodes.Br, loopLabel);
generator.MarkLabel(endLabel);
// Verificar que en el tope de la pila quede el resultado apropiado
s.NestedCylesBreakJumps.Pop();
}
public void DoesNotIncludeDocs()
{
Method method = new Method
(
isAbstract: true, name: "myMethod",
docs: new Docs(custom: new Dictionary <string, string> {
{ "foo", "bar" }
})
);
Symbols.MapMethodName("myInterfaceFqn", "myMethod", "MyMethod");
string actual = Render(method);
string expected =
@"[JsiiMethod(name: ""myMethod"")]
public void MyMethod()
{
InvokeInstanceVoidMethod(new object[]{});
}";
Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
}
private static bool TryParseSpecialCharacter(
Buffer buffer,
char expectedCharacter,
Symbols expectedSymbol,
out ParseResult result)
{
var position = buffer.Cursor;
if (buffer.TryNext(out var @char) && @char == expectedCharacter)
{
result = new ParseResult(new TerminalSymbol(
expectedSymbol,
@char));
return(true);
}
buffer.Reset(position);
result = new ParseResult($"'{expectedCharacter}' expected at position: {position + 1}");
return(false);
}
public async Task Symbols_ValidationVerifyMissingAssemblyIndexEntryCausesFailure(string isSymbolsString)
{
var isSymbols = bool.Parse(isSymbolsString);
using (var testContext = new SleetTestContext())
{
var context = testContext.SleetContext;
context.SourceSettings.SymbolsEnabled = true;
var service = new Symbols(context);
// Add packages
await AddPackageAsync(isSymbols, testContext, service);
// Corrupt feed
var path = SymbolsIndexUtility.GetAssemblyToPackageIndexPath("a.dll", "A7F83EF08000");
var assemblyPackageIndex = new AssetIndexFile(testContext.SleetContext, path, new PackageIdentity("a", NuGetVersion.Parse("1.0.0")));
var exists = await assemblyPackageIndex.File.Exists(context.Log, context.Token);
exists.Should().BeTrue();
// Swap package <-> symbols to corrupt
if (isSymbols)
{
await assemblyPackageIndex.AddAssetsAsync(await assemblyPackageIndex.GetSymbolsAssetsAsync());
}
else
{
await assemblyPackageIndex.AddSymbolsAssetsAsync(await assemblyPackageIndex.GetAssetsAsync());
}
// Validate
var messages = await service.ValidateAsync();
var hasErrors = messages.Any(e => e.Level == LogLevel.Error);
hasErrors.Should().BeTrue();
}
}
// Function to search the symbol dictionary based on the selected value in the style file, category and/or geometry type ListBoxes
private void Search()
{
Dictionary <string, string> filters = new Dictionary <string, string>();
// Set Category filter
if (!string.IsNullOrEmpty((string)cmbCategory.SelectedValue))
{
filters["CATEGORY"] = cmbCategory.SelectedValue.ToString();
}
// Clear the current Symbols collection
Symbols.Clear();
// Perform the search applying any selected keywords and filters
IEnumerable <SymbolProperties> symbols = _symbolDictionary.FindSymbols(SelectedKeywords, filters);
var allSymbols = symbols.ToList();
// Update the list of applicable keywords (excluding any keywords that are not on the current result set)
if (SelectedKeywords == null || SelectedKeywords.Count == 0)
{
_keywords = _symbolDictionary.Keywords.Where(k => !IsSymbolId(k)).ToList();
}
else
{
IEnumerable <string> allSymbolKeywords = allSymbols.SelectMany(s => s.Keywords);
_keywords = allSymbolKeywords.Distinct()
.Except(SelectedKeywords)
.Where(k => !IsSymbolId(k))
.ToList();
}
RaisePropertyChanged("Keywords");
// Add symbols to UI collection
foreach (var s in from symbol in allSymbols select new SymbolViewModel(symbol, _imageSize))
{
Symbols.Add(s);
}
}
/// <summary>
/// replaces $ variables with a c# statement
/// the routine also implements some checks to see if $variables are matching with production symbols
/// errors are added to the Error object.
/// </summary>
/// <param name="nts">non terminal and its production rule</param>
/// <returns>a formated codeblock</returns>
private string FormatCodeBlock(NonTerminalSymbol nts)
{
string codeblock = nts.CodeBlock;
if (nts == null)
{
return("");
}
Regex var = new Regex(@"\$(?<var>[a-zA-Z_0-9]+)(\[(?<index>[^]]+)\])?", RegexOptions.Compiled);
Symbols symbols = nts.DetermineProductionSymbols();
Match match = var.Match(codeblock);
while (match.Success)
{
Symbol s = symbols.Find(match.Groups["var"].Value);
if (s == null)
{
break; // error situation
}
string indexer = "0";
if (match.Groups["index"].Value.Length > 0)
{
indexer = match.Groups["index"].Value;
}
string replacement = "Me.GetValue(tree, TokenType." + s.Name + ", " + indexer + ")";
codeblock = codeblock.Substring(0, match.Captures[0].Index) + replacement + codeblock.Substring(match.Captures[0].Index + match.Captures[0].Length);
match = var.Match(codeblock);
}
codeblock = " " + codeblock.Replace("\n", "\r\n ");
return(codeblock);
}
public StrategyViewModel(StrategiesViewModel parent, StrategyModel model, MarketService markets, AccountService accounts, SettingService settings)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
_parent = parent;
Model = model;
_markets = markets;
_accounts = accounts;
_settings = settings;
StartCommand = new RelayCommand(() => DoRunStrategy(), () => true);
StopCommand = new RelayCommand(() => { }, () => false);
CloneCommand = new RelayCommand(() => DoCloneStrategy(), () => true);
CloneAlgorithmCommand = new RelayCommand(() => DoCloneAlgorithm(), () => !string.IsNullOrEmpty(Model.AlgorithmName));
ExportCommand = new RelayCommand(() => DoExportStrategy(), () => true);
DeleteCommand = new RelayCommand(() => _parent?.DoDeleteStrategy(this), () => true);
DeleteAllTracksCommand = new RelayCommand(() => DoDeleteTracks(null), () => true);
DeleteSelectedTracksCommand = new RelayCommand <IList>(m => DoDeleteTracks(m), m => true);
UseParametersCommand = new RelayCommand <IList>(m => DoUseParameters(m), m => true);
AddSymbolCommand = new RelayCommand(() => DoAddSymbol(), () => true);
DeleteSymbolsCommand = new RelayCommand <IList>(m => DoDeleteSymbols(m), m => SelectedSymbol != null);
ImportSymbolsCommand = new RelayCommand(() => DoImportSymbols(), () => true);
ExportSymbolsCommand = new RelayCommand <IList>(m => DoExportSymbols(m), trm => SelectedSymbol != null);
TrackDoubleClickCommand = new RelayCommand <TrackViewModel>(m => DoSelectItem(m));
MoveUpSymbolsCommand = new RelayCommand <IList>(m => OnMoveUpSymbols(m), m => SelectedSymbol != null);
MoveDownSymbolsCommand = new RelayCommand <IList>(m => OnMoveDownSymbols(m), m => SelectedSymbol != null);
SortSymbolsCommand = new RelayCommand(() => Symbols.Sort(), () => true);
Model.NameChanged += StrategyNameChanged;
Model.MarketChanged += MarketChanged;
Model.AlgorithmNameChanged += AlgorithmNameChanged;
DataFromModel();
Model.EndDate = DateTime.Now;
}
public void IncludesBase()
{
ClassType classType = new ClassType
(
"myFqn",
"myPackage",
"myClass",
"myNamespace",
false,
initializer: new Method(true, false, false),
@base: new TypeReference("myBaseTypeFqn")
);
Symbols.MapTypeName("myBaseTypeFqn", "MyBaseType", JsonModel.Spec.TypeKind.Class);
string actual = Render(classType);
string expected =
@"namespace MyNamespace
{
[JsiiClass(typeof(MyClass), ""myFqn"", ""[]"")]
public class MyClass : MyBaseType
{
public MyClass(): base(new DeputyProps(new object[]{}))
{
}
protected MyClass(ByRefValue reference): base(reference)
{
}
protected MyClass(DeputyProps props): base(props)
{
}
}
}";
Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
}
internal static void DataDisassembly(StreamWriter sw, BinaryReader br, Section section, IEnumerable <Overlay.RelocationWord> rel)
{
WriteSectionName(sw, section);
sw.WriteLine();
br.BaseStream.Position = section.Offset;
pc = section.VRam;
List <byte> byteChain = new();
N64Ptr end = section.VRam + section.Size;
N64Ptr chainStart = pc;
while (pc < end)
{
if (Symbols.ContainsKey(pc))
{
DumpByteChain(sw, chainStart, ref byteChain);
chainStart = pc;
sw.Write($"{Symbols[pc]}: ");
}
if (rel.Any(x => x.Offset == br.BaseStream.Position))
{
DumpByteChain(sw, chainStart, ref byteChain);
N64Ptr lbl = br.ReadBigInt32();
pc += 4;
chainStart = pc;
sw.WriteLine($".word {Symbols[lbl]}");
}
else
{
byteChain.Add(br.ReadByte());
pc += 1;
}
}
DumpByteChain(sw, chainStart, ref byteChain);
sw.WriteLine();
}
public void AddAccessibilitySpec(Bookmark bmk, AccessibilitySpec spec)
{
// Just store wildcards for now
if (spec.IsWildcard())
{
m_AccessibilitySpecs.Add(spec);
return;
}
Symbol s;
if (spec.IsMemberSpec())
{
s = Members.DefineSymbol(spec.GetExplicitName(), bmk);
}
else
{
s = Symbols.DefineSymbol(spec.GetExplicitName(), bmk);
}
// Mark obfuscation for this symbol
s.Accessibility = spec.GetAccessibility();
}
public void Run()
{
// Configure your credentials for IQConnect in user environment variable or app.config !!!
// Check the documentation for more information.
// Run IQConnect launcher
IQFeedLauncher.Start();
// Connect the LookupClient created from the constructor
LookupClient.Connect();
// Add 100 symbols to the concurrent queue
foreach (var symbol in MarketData.GetSymbols().Take(100))
{
Symbols.Enqueue(symbol);
}
// Create required directories for saving files
CreateDirectories();
// Download data for all added symbols
Start();
}
private void LoadSymbols()
{
Symbols[] allSymbols = Resources.LoadAll <Symbols>("Symbols");
if (allSymbols.Length < symbolsInGame)
{
Debug.LogError("not enough symbols to load into game");
return;
}
HashSet <Symbols> gameSymbols = new HashSet <Symbols>();
for (int i = 0; i < symbolsInGame; i++)
{
Symbols nextSymbol = allSymbols[Random.Range(0, allSymbols.Length)];
while (gameSymbols.Contains(nextSymbol))
{
nextSymbol = allSymbols[Random.Range(0, allSymbols.Length)];
}
gameSymbols.Add(nextSymbol);
}
symbols = new Symbols[symbolsInGame];
gameSymbols.CopyTo(symbols);
}
string Render(Method method)
{
ClassType classType = new ClassType
(
"myClassFqn",
"myModule",
"myClass",
"myNamespace",
true,
initializer: new Method(true, false, false),
methods: new[] { method }
);
Symbols.MapTypeToPackage("myClassFqn", "myPackage");
Symbols.MapNamespace("myNamespace", "MyNamespace");
Symbols.MapTypeName("myClassFqn", "MyClass", JsonModel.Spec.TypeKind.Class);
ClassMethodGenerator generator = new ClassMethodGenerator(classType, method, Symbols, Namespaces);
MethodDeclarationSyntax methodSyntax = generator.CreateMethod();
return(methodSyntax.NormalizeWhitespace(elasticTrivia: true).ToString());
}
public void RecordsReferencedParameterType()
{
Method method = new Method
(
isProtected: false,
isAbstract: true,
name: "myMethod",
parameters: new[]
{
new Parameter
(
name: "myParameter",
type: new TypeReference(fullyQualifiedName: "myParameterTypeFqn")
)
}
);
Symbols.MapParameterName("myParameter", "myParameter");
Render(method);
Namespaces.Received().Add(Arg.Is <TypeReference>(t => t.FullyQualifiedName == "myParameterTypeFqn"));
}
private void RaiseDoubleError(Symbols symbol)
{
string message = string.Empty;
_position = null;
switch (symbol)
{
case Symbols.SIdentificador:
message = DoubleIdentificatorErrorMessage;
break;
case Symbols.SFuncao:
message = DoubleFuncErrorMessage;
break;
case Symbols.SProcedimento:
message = DoubleProcErrorMessage;
break;
}
throw new CompilationException(string.Format(message, _lexical.Position.Line, _lexical.Position.Column, _token.Lexeme));
}
/// <summary>
/// Returns true if SymbolMapping instances are equal
/// </summary>
/// <param name="other">Instance of SymbolMapping to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(SymbolMapping other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
Symbols == other.Symbols ||
Symbols != null &&
Symbols.SequenceEqual(other.Symbols)
) &&
(
Fields == other.Fields ||
Fields != null &&
Fields.SequenceEqual(other.Fields)
));
}
private void AssignPlanetSymbols()
{
Planet[] planets = GetPlanets();
int[] weights = new int[] { 1, 1, 1, -1, -1, -1 };
Symbols[] p1Symbols = new Symbols[] { symbols[0], symbols[1], symbols[12], symbols[8], symbols[9], symbols[4] };
Symbols[] p2Symbols = new Symbols[] { symbols[0], symbols[2], symbols[4], symbols[8], symbols[10], symbols[12] };
Symbols[] p3Symbols = new Symbols[] { symbols[0], symbols[3], symbols[13], symbols[8], symbols[11], symbols[5] };
Symbols[] p4Symbols = new Symbols[] { symbols[0], symbols[1], symbols[5], symbols[8], symbols[9], symbols[13] };
Symbols[] p5Symbols = new Symbols[] { symbols[0], symbols[2], symbols[14], symbols[8], symbols[10], symbols[6] };
Symbols[] p6Symbols = new Symbols[] { symbols[0], symbols[3], symbols[6], symbols[8], symbols[11], symbols[14] };
Symbols[] p7Symbols = new Symbols[] { symbols[0], symbols[1], symbols[15], symbols[8], symbols[9], symbols[7] };
Symbols[] p8Symbols = new Symbols[] { symbols[0], symbols[2], symbols[7], symbols[8], symbols[10], symbols[15] };
planets[0].SetSymbolDict(p1Symbols, weights);
planets[1].SetSymbolDict(p2Symbols, weights);
planets[2].SetSymbolDict(p3Symbols, weights);
planets[3].SetSymbolDict(p4Symbols, weights);
planets[4].SetSymbolDict(p5Symbols, weights);
planets[5].SetSymbolDict(p6Symbols, weights);
planets[6].SetSymbolDict(p7Symbols, weights);
planets[7].SetSymbolDict(p8Symbols, weights);
}
// Any dot that looks like a function call
public AstOpCall DotFunc(string name, AstValue[] args = null)
{
var op = Symbols.FindIdent(name);
if (op.IsComponent)
{
return(DotComponent(op, args));
}
if (op.IsField)
{
return(DotField(op, args));
}
if (op.IsCallable)
{
return(DotFunc(op, args));
}
if (op.IsCallVar)
{
return(DotCallVar(op, args));
}
Parser.ParseError($"function, field or component expected: {name}");
return(null);
}
public static int EncodeSymbol(int varnumber, Symbols symbol, int?qualifier)
{
switch (symbol)
{
case Symbols.InputArgument:
return((int)Symbols.InputArgument + (qualifier ?? 0));
case Symbols.WorkingVariable:
return((int)Symbols.InputArgument + varnumber + (4 * (qualifier ?? 0)));
case Symbols.AssignWorkingVariable:
return((int)Symbols.InputArgument + varnumber + (4 * (qualifier ?? 0)) + 1);
case Symbols.DoubleLiteral:
return((int)Symbols.InputArgument + varnumber + (4 * (qualifier ?? 0)) + 2);
case Symbols.IntegerLiteral:
return((int)Symbols.InputArgument + varnumber + (4 * (qualifier ?? 0)) + 3);
default:
return((int)symbol);
}
}
// recursively add symbols
void AddPositions(int index, string prefix, IList <string> dims)
{
foreach (var frag in dims[index].Split('/'))
{
var name = prefix + frag;
if (index + 1 < dims.Count)
{
AddPositions(index + 1, name, dims);
}
else
{
var sym = Symbols.Find(name);
if (sym == null)
{
Symbols.DefineValue(name, PositionValue.Create(name));
}
else if (!(sym.Kind == SymKinds.VALUE && sym.DataType == DataTypes.Position))
{
_currentparser.Syntax("cannot define {0} as position", name);
}
}
}
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.Append(Kind);
builder.AppendFormat(" Span at {0}::{1} - [{2}]", Start, Length, Content);
builder.Append(" Edit: <");
builder.Append(EditHandler.ToString());
builder.Append(">");
builder.Append(" Gen: <");
builder.Append(CodeGenerator.ToString());
builder.Append("> {");
builder.Append(
String.Join(
";",
Symbols
.GroupBy(sym => sym.GetType())
.Select(grp => String.Concat(grp.Key.Name, ":", grp.Count()))
)
);
builder.Append("}");
return(builder.ToString());
}
public void IncludesReturnTypeForNonVoid()
{
Method method = new Method
(
isProtected: false,
isAbstract: false,
name: "myMethod",
returns: new OptionalValue(type: new TypeReference("myReturnTypeFqn"))
);
Symbols.MapMethodName("myClassFqn", "myMethod", "MyMethod");
Symbols.MapTypeName("myReturnTypeFqn", "MyReturnType", JsonModel.Spec.TypeKind.Class);
string actual = Render(method);
string expected =
@"[JsiiMethod(name: ""myMethod"", returnsJson: ""{\""type\"":{\""fqn\"":\""myReturnTypeFqn\""}}"")]
public virtual MyReturnType MyMethod()
{
return InvokeInstanceMethod<MyReturnType>(new object[]{});
}";
Assert.Equal(expected, actual, ignoreLineEndingDifferences: true);
}
string Render(Property property)
{
ClassType classType = new ClassType
(
fullyQualifiedName: "myClassFqn",
assembly: "myModule",
name: "myClass",
@namespace: "myNamespace",
isAbstract: true,
initializer: new Method(true, false, false),
properties: new[] { property }
);
Symbols.MapTypeToPackage("myClassFqn", "myPackage");
Symbols.MapNamespace("myNamespace", "MyNamespace");
Symbols.MapTypeName("myClassFqn", "MyClass", JsonModel.Spec.TypeKind.Class);
ClassPropertyGenerator generator = new ClassPropertyGenerator(classType, property, Symbols, Namespaces);
PropertyDeclarationSyntax methodSyntax = generator.CreateProperty();
return(methodSyntax.NormalizeWhitespace(elasticTrivia: true).ToString());
}
internal static bool TryGetNUnitSymbols(Compilation compilation, out Symbols nunit)
{
nunit = new Symbols
{
ExpectedException = compilation.GetTypeByMetadataName(ExpectedExceptionAttributeQualifiedName),
TestCase = compilation.GetTypeByMetadataName(TestCaseAttributeQualifiedName),
Text = compilation.GetTypeByMetadataName(TextConstraintsQualifiedName),
Is = compilation.GetTypeByMetadataName(IsConstraintsQualifiedName),
Assert = compilation.GetTypeByMetadataName(AssertQualifiedName),
TestCaseSource = compilation.GetTypeByMetadataName(TestCaseSourceQualifiedName),
ValueSource = compilation.GetTypeByMetadataName(ValueSourceQualifiedName),
Suite = compilation.GetTypeByMetadataName(SuiteAttributeQualifiedName),
RequiredAddin = compilation.GetTypeByMetadataName(RequiredAddinAttributeQualifiedName),
RequiresMTA = compilation.GetTypeByMetadataName(RequiresMTAAttributeQualifiedName),
RequiresSTA = compilation.GetTypeByMetadataName(RequiresSTAAttributeQualifiedName),
TestFixtureSetUp = compilation.GetTypeByMetadataName(TestFixtureSetUpAttributeQualifiedName),
TestFixtureTearDown = compilation.GetTypeByMetadataName(TestFixtureTearDownAttributeQualifiedName),
TestFixture = compilation.GetTypeByMetadataName(TestFixtureAttributeQualifiedName),
Ignore = compilation.GetTypeByMetadataName(IgnoreAttributeQualifiedName),
};
return(nunit.ArePresent);
}
private static MarkerKind mapFrom(Symbols symbol)
{
switch (symbol)
{
case Symbols.None:
return(MarkerKind.Square);
case Symbols.Circle:
return(MarkerKind.Circle);
case Symbols.Diamond:
return(MarkerKind.Diamond);
case Symbols.Triangle:
return(MarkerKind.Triangle);
case Symbols.Square:
return(MarkerKind.Square);
default:
throw new ArgumentOutOfRangeException(nameof(symbol));
}
}
// true predicate to print the line containing the current location
// due to backtracking may be called more than once, so just do once and not off end
public bool PrintLine(Cursor state, bool force = false)
{
if (NewInput != null)
{
return(true); // suppress printing if #include pending
}
var bol = state.Location - state.Column + 1;
if (bol > _input.LastLocation)
{
_input.LineStarts.Add(bol);
Symbols.FindIdent("$lineno$").Value = NumberValue.Create(state.Line);
if (Logger.Level >= 1 || force)
{
Output.WriteLine("{0}{1,3}: {2} {3}",
new string('>', _input.Level),
state.Line, GetLine(state.Subject, bol),
(Logger.Level >= 4) ? " <bol=" + bol.ToString() + ">" : "");
}
_input.LastLocation = bol;
}
return(true);
}
public static PlotOptions.Markers GetMarker(Symbols symbol)
{
switch (symbol)
{
case Symbols.None:
return(PlotOptions.Markers.None);
case Symbols.Circle:
return(PlotOptions.Markers.Circle);
case Symbols.Diamond:
return(PlotOptions.Markers.Diamond);
case Symbols.Triangle:
return(PlotOptions.Markers.Triangle);
case Symbols.Square:
return(PlotOptions.Markers.Square);
default:
throw new ArgumentOutOfRangeException("symbol");
}
}
public GameStatuses CheckIfEndGame(Game game, Symbols lookingForSymbol)
{
if (game.MovesPreview.Count < game.Board.Size * 2 - 1)
{
return(GameStatuses.InProgress);
}
if (
LookRDiagonal(game.Board, lookingForSymbol) ||
LookLDiagonal(game.Board, lookingForSymbol) ||
LookHorizontalVertical(game.Board, lookingForSymbol)
)
{
return(lookingForSymbol == Symbols.O ? GameStatuses.OWin : GameStatuses.XWin);
}
if ((game.Board.Size * game.Board.Size) == game.MovesPreview.Count)
{
return(GameStatuses.Tie);
}
return(GameStatuses.InProgress);
}
// Compile and merge nodes from base game and variant
internal void CompileGameOrVariant(PredefScopes predef, NodeListParser nlp)
{
Logger.WriteLine(1, "CompileGameOrVariant {0} <{1}>", predef, nlp);
Symbols.PushPredefScope(predef);
Symbols.CurrentScope.Push(); // game index will define pieces
if (_game_index == null)
{
_game_index = new GameIndex();
_currentparser = NodeListParser.Create(_game_index.IndexGame(nlp), nlp.Symbols);
}
else
{
_currentparser = NodeListParser.Create(_game_index.MergeVariant(nlp), nlp.Symbols);
}
var codetype = Symbols.PredefScopeDict[predef].CodeType;
_gen.EmitEntry(codetype);
CompileProg(_currentparser);
_gen.EmitExit(false);
Symbols.CurrentScope.Pop();
Symbols.PopPredefScope();
}
public void CheckASTScopeAndType(ASTNode node)
{
node.AppearsInScope = Symbols.CurrentScope;
switch (node.Token.Kind)
{
case TokenKind.Block:
Symbols.NewScope();
break;
case TokenKind.IdentifierToken:
if (node.Parent.Token.Kind == TokenKind.VarDecl)
{
Symbols.AddSymbol(node, node.Parent.Descendants[0].Token.Text);
}
else
{
int symbolScope = FindSymbol(node, Symbols.CurrentScope);
if (symbolScope == -1)
{
Symbols.Diagnostics.Semantic_ReportUndeclaredIdentifier(node.Token, Symbols.CurrentScope.Level);
return;
}
else
{
node.ReferenceScope = symbolScope;
}
}
break;
case TokenKind.AssignmentToken:
case TokenKind.EquivalenceToken:
case TokenKind.NotEqualToken:
case TokenKind.AdditionToken:
TypeChecker.CheckTypes(node);
break;
}
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
if (Arguments != null)
foreach (var arg in Arguments)
arg.Generate(generator, symbols);
generator.Emit(OpCodes.Call, symbols.Routines[this.ILName]);
}
public Interpreter(Symbols symbols, Tokenizer tokenizer, Executor executor)
{
this.symbols = symbols;
this.tokenizer = tokenizer;
this.executor = executor;
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
var iteratorVar = symbols.ProgramType.DefineField(IteratorName.ILName, typeof(int),
FieldAttributes.Public | FieldAttributes.Static);
var highestValueVar = generator.DeclareLocal(typeof(int));
var loop = generator.DefineLabel();
var end = generator.DefineLabel();
symbols.NestedCylesBreakJumps.Push(end);
symbols.Variables.Add(IteratorName.ILName, null);
LowerValue.Generate(generator, symbols);
generator.Emit(OpCodes.Stsfld, iteratorVar);
HighestValue.Generate(generator, symbols);
generator.Emit(OpCodes.Stloc, highestValueVar);
generator.MarkLabel(loop);
symbols.Variables[IteratorName.ILName] = iteratorVar;
generator.Emit(OpCodes.Ldsfld, iteratorVar);
generator.Emit(OpCodes.Ldloc, highestValueVar);
generator.Emit(OpCodes.Bgt, end);
Loop.Generate(generator, symbols);
generator.Emit(OpCodes.Ldsfld, iteratorVar);
generator.Emit(OpCodes.Ldc_I4_1);
generator.Emit(OpCodes.Add);
generator.Emit(OpCodes.Stsfld, iteratorVar);
generator.Emit(OpCodes.Br, loop);
generator.MarkLabel(end);
symbols.Variables.Remove(IteratorName.ILName);
symbols.NestedCylesBreakJumps.Pop();
}
public override void Generate(ILGenerator generator, Symbols symbols)
{
var paramsTypes = Arguments != null ? new Type[Arguments.Count] : System.Type.EmptyTypes;
for (int i = 0; i < paramsTypes.Length; i++)
{
var paramType = symbols.GetRealType(Arguments[i].TypeName.ILName);
var parameter = symbols.ProgramType.DefineField(
Arguments[i].ILName, paramType,
FieldAttributes.Public |
FieldAttributes.Static);
symbols.Variables.Add(Arguments[i].ILName, parameter);
paramsTypes[i] = paramType;
}
var returnType = symbols.GetRealType(ReturnType != null ? ReturnType.ILName : "voidScope0");
var routin = symbols.ProgramType.DefineMethod(Identifier.ILName,
MethodAttributes.Public | MethodAttributes.Static, returnType,
paramsTypes);
var routinIL = routin.GetILGenerator();
symbols.Routines.Add(Identifier.ILName, routin);
for (int i = 0; i < paramsTypes.Length; i++) //l_0000
routinIL.Emit(OpCodes.Ldsfld, symbols.Variables[Arguments[i].ILName]);
//var currentVariables = new List<string>();
//foreach (var item in symbols.Variables)
//{
// currentVariables.Add(item.Key);
// routinIL.Emit(OpCodes.Ldsfld, symbols.Variables[item.Key]);
//}
for (int i = 0; i < paramsTypes.Length; i++)
{
routinIL.Emit(OpCodes.Ldarg, i); //ldarg A_0
routinIL.Emit(OpCodes.Stsfld, symbols.Variables[Arguments[i].ILName]); //l_000b
}
if (this is FunctionDeclarationNode)
((FunctionDeclarationNode)this).Body.Generate(routinIL, symbols);
else
((ProcedureDeclarationNode)this).Body.Generate(routinIL, symbols);
LocalBuilder returnVariable = null;
if (ReturnType != null)
{
returnVariable = routinIL.DeclareLocal(returnType);
routinIL.Emit(OpCodes.Stloc, returnVariable);
}
for (int i = paramsTypes.Length - 1; i >= 0; i--)
routinIL.Emit(OpCodes.Stsfld, symbols.Variables[Arguments[i].ILName]);
//currentVariables.Reverse();
//currentVariables.ForEach(x => routinIL.Emit(OpCodes.Stsfld, symbols.Variables[x]));
if (ReturnType != null)
routinIL.Emit(OpCodes.Ldloc, returnVariable);
routinIL.Emit(OpCodes.Ret);
if (Arguments != null)
foreach (var argument in Arguments)
symbols.Variables.Remove(argument.Field.ILName);
}
public override BoundStatement CreateBlockPrologue(BoundBlock original, out Symbols.LocalSymbol synthesizedLocal)
{
var previous = base.CreateBlockPrologue(original, out synthesizedLocal);
if (original.Syntax.Kind() == SyntaxKind.Block && !original.WasCompilerGenerated)
{
var oBspan = ((BlockSyntax)original.Syntax).OpenBraceToken.Span;
return new BoundSequencePointWithSpan(original.Syntax, previous, oBspan);
}
else if (previous != null)
{
return new BoundSequencePoint(original.Syntax, previous);
}
return null;
}
