public GeneratorOptions(GeneratorFlags flags) { HasGasFormatter = (flags & GeneratorFlags.NoGasFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasIntelFormatter = (flags & GeneratorFlags.NoIntelFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasMasmFormatter = (flags & GeneratorFlags.NoMasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasNasmFormatter = (flags & GeneratorFlags.NoNasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; }
/// <summary> /// Creates a new instance of the generator. /// </summary> public Generator(GeneratorFlags flags) { OutputDir = "Services"; Flags = flags; CodeDomProviderLanguage = CodeDomProviderLanguageCSharp; CodeDomProviderLanguage = CodeFileExtensionCSharp; }
static GeneratorContext CreateGeneratorContext(GeneratorFlags flags, HashSet <string> includeCpuid, HashSet <string> excludeCpuid) { var dir = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(typeof(Program).Assembly.Location))))))); if (dir is null || !File.Exists(Path.Combine(dir, "csharp", "Iced.sln"))) { throw new InvalidOperationException(); } return(new GeneratorContext(dir, flags, includeCpuid, excludeCpuid)); }
static GeneratorOptions CreateGeneratorOptions(GeneratorFlags flags) { var dir = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(typeof(Program).Assembly.Location))))))); if (dir is null || !File.Exists(Path.Combine(dir, "csharp", "Iced.sln"))) { throw new InvalidOperationException(); } return(new GeneratorOptions(dir, flags)); }
public GeneratorOptions(GeneratorFlags flags) { HasGasFormatter = (flags & GeneratorFlags.NoGasFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasIntelFormatter = (flags & GeneratorFlags.NoIntelFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasMasmFormatter = (flags & GeneratorFlags.NoMasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasNasmFormatter = (flags & GeneratorFlags.NoNasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; IncludeVEX = (flags & GeneratorFlags.NoVEX) == 0; IncludeEVEX = (flags & GeneratorFlags.NoEVEX) == 0; IncludeXOP = (flags & GeneratorFlags.NoXOP) == 0; Include3DNow = (flags & GeneratorFlags.No3DNow) == 0; }
public GeneratorOptions(GeneratorFlags flags, HashSet <string> includeCpuid, HashSet <string> excludeCpuid) { HasGasFormatter = (flags & GeneratorFlags.NoGasFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasIntelFormatter = (flags & GeneratorFlags.NoIntelFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasMasmFormatter = (flags & GeneratorFlags.NoMasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasNasmFormatter = (flags & GeneratorFlags.NoNasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; IncludeVEX = (flags & GeneratorFlags.NoVEX) == 0; IncludeEVEX = (flags & GeneratorFlags.NoEVEX) == 0; IncludeXOP = (flags & GeneratorFlags.NoXOP) == 0; Include3DNow = (flags & GeneratorFlags.No3DNow) == 0; IncludeCpuid = includeCpuid; ExcludeCpuid = excludeCpuid; }
public GeneratorContext(string baseDir, GeneratorFlags flags, HashSet <string> includeCpuid, HashSet <string> excludeCpuid) { Types = new GenTypes(new GeneratorOptions(flags, includeCpuid, excludeCpuid)); UnitTestsDir = GetAndVerifyPath(baseDir, "UnitTests", "Intel"); langDirs = new string[Enum.GetValues(typeof(TargetLanguage)).Length]; for (int i = 0; i < langDirs.Length; i++) { string path = (TargetLanguage)i switch { TargetLanguage.CSharp => GetAndVerifyPath(baseDir, "csharp", "Intel", "Iced"), TargetLanguage.Rust => GetAndVerifyPath(baseDir, "rust", "iced-x86", "src"), TargetLanguage.RustJS => GetAndVerifyPath(baseDir, "rust", "iced-x86-js", "src"), _ => throw new InvalidOperationException(), }; langDirs[i] = path; } CSharpTestsDir = GetAndVerifyPath(baseDir, "csharp", "Intel", "Iced.UnitTests"); }
private Char[] CreateCharactersPool() { List <Char> chars = new List <Char>(65); if (CharacterClasses.HasFlag(CharacterClass.UpperLetters)) { chars.AddRange(PoolUpperCase.ToCharArray()); if (GeneratorFlags.HasFlag(GeneratorFlag.ExcludeLookAlike) == false) { chars.AddRange(PoolUpperCaseConflict.ToCharArray()); } } if (this.CharacterClasses.HasFlag(CharacterClass.LowerLetters)) { chars.AddRange(PoolLowerCase.ToCharArray()); if (GeneratorFlags.HasFlag(GeneratorFlag.ExcludeLookAlike) == false) { chars.AddRange(PoolLowerCaseConflict.ToCharArray()); } } if (this.CharacterClasses.HasFlag(CharacterClass.Digits)) { chars.AddRange(PoolDigits.ToCharArray()); if (GeneratorFlags.HasFlag(GeneratorFlag.ExcludeLookAlike) == false) { chars.AddRange(PoolDigitsConflict.ToCharArray()); } } if (this.CharacterClasses.HasFlag(CharacterClass.SpecialCharacters)) { chars.AddRange(PoolSpecial.ToCharArray()); if (GeneratorFlags.HasFlag(GeneratorFlag.ExcludeLookAlike) == false) { chars.AddRange(PoolSpecialConflict.ToCharArray()); } } if (CharacterClasses.HasFlag(CharacterClass.Space)) { chars.AddRange(PoolSpace.ToCharArray()); } return(chars.ToArray()); }
public GeneratorOptions(string baseDir, GeneratorFlags flags) { HasGasFormatter = (flags & GeneratorFlags.NoGasFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasIntelFormatter = (flags & GeneratorFlags.NoIntelFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasMasmFormatter = (flags & GeneratorFlags.NoMasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; HasNasmFormatter = (flags & GeneratorFlags.NoNasmFormatter) == 0 && (flags & GeneratorFlags.NoFormatter) == 0; UnitTestsDir = GetAndVerifyPath(baseDir, "UnitTests", "Intel"); langDirs = new string[Enum.GetValues(typeof(TargetLanguage)).Length]; for (int i = 0; i < langDirs.Length; i++) { string path = (TargetLanguage)i switch { TargetLanguage.CSharp => GetAndVerifyPath(baseDir, "csharp", "Intel", "Iced"), TargetLanguage.Rust => GetAndVerifyPath(baseDir, "rust", "iced-x86", "src"), _ => throw new InvalidOperationException(), }; langDirs[i] = path; } CSharpTestsDir = GetAndVerifyPath(baseDir, "csharp", "Intel", "Iced.UnitTests"); }
/// <summary> /// Generates new password to SecureString. /// </summary> /// <returns>Password.</returns> public SecureString GenerateSecure() { var pool = string.IsNullOrEmpty(this.CharactersPool) ? CreateCharactersPool() : this.CharactersPool.ToCharArray(); var secureString = new SecureString(); if (this.GeneratorFlags.HasFlag(GeneratorFlag.ShuffleChars)) { ShuffleCharsArray(pool); } for (int i = 0; i < PasswordLength; i++) { int random = GetNextRandom(pool.Length); secureString.AppendChar(pool[random]); } if (GeneratorFlags.HasFlag(GeneratorFlag.MakeReadOnly)) { secureString.MakeReadOnly(); } return(secureString); }
public GeneratorContext(string baseDir, GeneratorFlags flags, HashSet <string> includeCpuid, HashSet <string> excludeCpuid) =>
private static BlockSyntax CallNativePointerOverload(MethodDeclarationSyntax nativePointerOverload, GeneratorFlags flags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform) { Func <ParameterSyntax, IdentifierNameSyntax> getLocalSubstituteName = p => SyntaxFactory.IdentifierName(p.Identifier.ValueText + "Local"); var invocationArguments = new Dictionary <ParameterSyntax, ArgumentSyntax>(); foreach (var p in nativePointerOverload.ParameterList.Parameters) { var refOrOut = p.Modifiers.FirstOrDefault(m => m.IsKind(SyntaxKind.RefKeyword) || m.IsKind(SyntaxKind.OutKeyword)); invocationArguments[p] = SyntaxFactory .Argument(SyntaxFactory.IdentifierName(p.Identifier)) .WithRefOrOutKeyword(refOrOut); } var prelude = new List <StatementSyntax>(); var postlude = new List <StatementSyntax>(); var fixedStatements = new List <FixedStatementSyntax>(); foreach (var parameter in nativePointerOverload.ParameterList.Parameters.Where(p => p.Type is PointerTypeSyntax)) { var parameterName = SyntaxFactory.IdentifierName(parameter.Identifier); var localVarName = getLocalSubstituteName(parameter); FriendlyFlags friendlyFlags; if (flags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(parameter, out friendlyFlags)) { if (friendlyFlags.HasFlag(FriendlyFlags.Array)) { var fixedArrayDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(parameterName)); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedArrayDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { if (friendlyFlags.HasFlag(FriendlyFlags.Optional)) { var nullableType = (PointerTypeSyntax)parameter.Type; var hasValueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .HasValue))); var valueExpression = SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(Nullable <int> .Value))); var defaultExpression = SyntaxFactory.DefaultExpression(nullableType.ElementType); var varStatement = SyntaxFactory.VariableDeclaration(nullableType.ElementType).AddVariables( SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.ConditionalExpression( hasValueExpression, valueExpression, defaultExpression)))); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { // someParam = someParamLocal; var assignBackToParameter = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, localVarName); var conditionalStatement = SyntaxFactory.IfStatement( hasValueExpression, SyntaxFactory.ExpressionStatement(assignBackToParameter)); postlude.Add(conditionalStatement); } invocationArguments[parameter] = invocationArguments[parameter].WithExpression( SyntaxFactory.ConditionalExpression( hasValueExpression, SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, localVarName), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); } else if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { var fixedDecl = SyntaxFactory.VariableDeclarator(localVarName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause( SyntaxFactory.PrefixUnaryExpression( SyntaxKind.AddressOfExpression, parameterName))); fixedStatements.Add(SyntaxFactory.FixedStatement( SyntaxFactory.VariableDeclaration(parameter.Type).AddVariables(fixedDecl), SyntaxFactory.Block())); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } else { invocationArguments[parameter] = invocationArguments[parameter] .WithExpression(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AddressOfExpression, parameterName)); } } } else if (flags.HasFlag(GeneratorFlags.NativePointerToIntPtr)) { var varStatement = SyntaxFactory.VariableDeclaration(parameter.Type); var declarator = SyntaxFactory.VariableDeclarator(localVarName.Identifier); if (parameter.Modifiers.Any(m => m.IsKind(SyntaxKind.OutKeyword))) { var assignment = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, parameterName, SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(localVarName))), null)); postlude.Add(SyntaxFactory.ExpressionStatement(assignment)); } else { var voidStarPointer = SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(parameter.Identifier), SyntaxFactory.IdentifierName(nameof(IntPtr.ToPointer))), SyntaxFactory.ArgumentList()); var typedPointer = parameter.Type.Equals(VoidStar) ? (ExpressionSyntax)voidStarPointer : SyntaxFactory.CastExpression(parameter.Type, voidStarPointer); declarator = declarator.WithInitializer(SyntaxFactory.EqualsValueClause(typedPointer)); } varStatement = varStatement.AddVariables(declarator); prelude.Add(SyntaxFactory.LocalDeclarationStatement(varStatement)); invocationArguments[parameter] = invocationArguments[parameter].WithExpression(localVarName); } } var invocationExpression = SyntaxFactory.InvocationExpression( SyntaxFactory.IdentifierName(nativePointerOverload.Identifier.ValueText), SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList( from p in nativePointerOverload.ParameterList.Parameters select invocationArguments[p]))); IdentifierNameSyntax resultVariableName = null; StatementSyntax invocationStatement; if (nativePointerOverload.ReturnType != null && (nativePointerOverload.ReturnType as PredefinedTypeSyntax)?.Keyword.Kind() != SyntaxKind.VoidKeyword) { resultVariableName = SyntaxFactory.IdentifierName("result"); // TODO: ensure this is unique. invocationStatement = SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration(nativePointerOverload.ReturnType) .AddVariables( SyntaxFactory.VariableDeclarator(resultVariableName.Identifier) .WithInitializer(SyntaxFactory.EqualsValueClause(invocationExpression)))); } else { invocationStatement = SyntaxFactory.ExpressionStatement(invocationExpression); } var block = SyntaxFactory.Block() .AddStatements(prelude.ToArray()) .AddStatements(invocationStatement) .AddStatements(postlude.ToArray()); if (resultVariableName != null) { ExpressionSyntax returnedValue = nativePointerOverload.ReturnType is PointerTypeSyntax ? (ExpressionSyntax)SyntaxFactory.ObjectCreationExpression( IntPtrTypeSyntax, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(resultVariableName))), null) : resultVariableName; block = block.AddStatements(SyntaxFactory.ReturnStatement(returnedValue)); } if (fixedStatements.Count > 0) { StatementSyntax outermost = block; foreach (var statement in fixedStatements) { outermost = statement.WithStatement(outermost); } block = SyntaxFactory.Block(outermost); } return(block); }
private static ParameterListSyntax TransformParameterList(ParameterListSyntax list, GeneratorFlags generatorFlags, IReadOnlyDictionary <ParameterSyntax, FriendlyFlags> parametersToFriendlyTransform) { var resultingList = list.ReplaceNodes( WhereIsPointerParameter(list.Parameters), (n1, n2) => { // Remove all attributes n2 = n2.WithAttributeLists(SyntaxFactory.List <AttributeListSyntax>()); FriendlyFlags friendlyFlags; if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToFriendly) && parametersToFriendlyTransform.TryGetValue(n1, out friendlyFlags)) { var pointerType = (PointerTypeSyntax)n2.Type; var alteredParameter = n2.WithDefault(null); if (friendlyFlags.HasFlag(FriendlyFlags.Array)) { alteredParameter = alteredParameter .WithType(SyntaxFactory.ArrayType(pointerType.ElementType, OneDimensionalUnspecifiedLengthArray)); } else { if (friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(SyntaxFactory.NullableType(pointerType.ElementType)); } if (friendlyFlags.HasFlag(FriendlyFlags.Out)) { SyntaxKind modifier = friendlyFlags.HasFlag(FriendlyFlags.Optional) || friendlyFlags.HasFlag(FriendlyFlags.In) ? SyntaxKind.RefKeyword : SyntaxKind.OutKeyword; if (!friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(pointerType.ElementType); } alteredParameter = alteredParameter .AddModifiers(SyntaxFactory.Token(modifier)); } else if (!friendlyFlags.HasFlag(FriendlyFlags.Optional)) { alteredParameter = alteredParameter .WithType(pointerType.ElementType); } } return(alteredParameter); } else if (generatorFlags.HasFlag(GeneratorFlags.NativePointerToIntPtr)) { return(n2 .WithType(IntPtrTypeSyntax) .WithDefault(null)); } else { return(n2); } }); return(resultingList); }