예제 #1
0
 public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
 {
     if (syntaxNode is ClassDeclarationSyntax classSyntax)
     {
         ClassDeclarations.Add(classSyntax);
     }
 }
 public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
 {
     // Any partial class
     if (syntaxNode is ClassDeclarationSyntax {
         Modifiers : { Count : > 0 } modifiers
     } classSyntax&& modifiers.Any(SyntaxKind.PartialKeyword))
     {
         ClassDeclarations.Add(classSyntax);
     }
 }
예제 #3
0
 public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
 {
     if (IsSyntaxTargetForGeneration(context.Node))
     {
         ClassDeclarationSyntax classSyntax = GetSemanticTargetForGeneration(context);
         if (classSyntax != null)
         {
             ClassDeclarations.Add(classSyntax);
         }
     }
 }
예제 #4
0
        /// <summary>
        /// Ajoute des déclarations à ce Container à partir d'un block Access.
        /// </summary>
        /// <param name="block"></param>
        void AddDeclarationsFromMacroBlock(Language.NamedBlockDeclaration block, Semantic.TypeTable table)
        {
            foreach (Language.Instruction instruction in block.Instructions)
            {
                if (instruction is Language.ClassDeclaration)
                {
                    Language.ClassDeclaration classDecl = (Language.ClassDeclaration)instruction;
                    MacroClass classMacro = new MacroClass();

                    // Récupération du type en language Clank.Core.
                    Language.ClankType type = table.Types[classDecl.GetFullName()];
                    classMacro.Type = type;


                    bool foundName = false;
                    // Parse les instructions à la recherche de :
                    //  - une fonction Name qui retourne un string et qui contient des variables de type string
                    //  - d'autres fonctions qui ne contiennent que des variables de type string.
                    foreach (Language.Instruction funcDeclInstruction in classDecl.Instructions)
                    {
                        Language.FunctionDeclaration funcDecl = funcDeclInstruction as Language.FunctionDeclaration;
                        if (funcDecl != null)
                        {
                            if (funcDecl.Func.Name == "name")
                            {
                                // Nom de la classe
                                foundName = true;
                                classMacro.LanguageToTypeName = ParseLanguageTranslations(funcDecl);
                            }
                            else
                            {
                                // Ajout de la fonction.
                                MacroFunction func = new MacroFunction();
                                func.Function = funcDecl.Func;
                                func.LanguageToFunctionName = ParseLanguageTranslations(funcDecl);
                                classMacro.Functions.Add(func.Function.GetFullName(), func);
                            }
                        }
                        else if (funcDeclInstruction is Language.PlaceholderInstruction)
                        {
                        }
                        else
                        {
                            ParsingLog.AddWarning("Seules les déclarations de fonctions sont autorisées dans les classes de block macro. Obtenu : " +
                                                  funcDeclInstruction.GetType().Name + ".",
                                                  instruction.Line, instruction.Character, instruction.Source);
                        }
                    }
                    ClassDeclarations.Add(classMacro);
                    // Erreur si pas de nom de classe trouvé :
                    if (!foundName)
                    {
                        ParsingLog.AddError("Fonction 'string name()' attendue dans la déclaration de macro du type '" + type.Name + "'.",
                                            instruction.Line, instruction.Character, instruction.Source);
                    }
                }
                else if (instruction is Language.FunctionDeclaration)
                {
                    Language.FunctionDeclaration funcDecl = (Language.FunctionDeclaration)instruction;
                    MacroFunction func = new MacroFunction();
                    func.Function = funcDecl.Func;
                    func.LanguageToFunctionName = ParseLanguageTranslations(funcDecl);
                    FunctionDeclarations.Add(func);
                }
                else
                {
                    ParsingLog.AddWarning("Déclaration de classe attendue dans le block macro. Obtenu : " + instruction.GetType() + ".",
                                          instruction.Line, instruction.Character, instruction.Source);
                }
            }
        }
예제 #5
0
        public override ClassDeclaration GlobalClassSearch(string name)
        {
            var classDeclaration = ClassDeclarations.FindByKey(name);

            return(classDeclaration ?? ParentScope?.GlobalClassSearch(name));
        }