/// <summary> /// Retourne la fonction d'instance pour un type donné dont le nom est passé en paramètre. /// </summary> /// <param name="functionName"></param> /// <param name="context"></param> /// <returns></returns> public Language.Function GetInstanceFunction(Language.ClankTypeInstance instance, string functionName, List <Language.Evaluable> args, Context context) { string fullName = ""; // Pour les fonctions du bloc state, elles ne sont pas préfixées dans la table. if (instance == null || instance.BaseType.GetFullName() == Language.SemanticConstants.StateClass) { fullName = functionName + Language.Evaluable.GetArgTypesString(args); } else { fullName = instance.BaseType.GetFullName() + "." + functionName + Language.Evaluable.GetArgTypesString(args); } var instanciatedOverloads = InstanciatedFunc(instance); if (instanciatedOverloads.ContainsKey(fullName)) { Language.Function func = instanciatedOverloads[fullName]; // Vérification : la fonction est-elle une méthode d'instance ? if (func.IsStatic) { if (instance != null) { throw new SemanticError("La fonction " + functionName + " n'est pas une méthode d'instance de " + instance.BaseType.GetFullName() + "."); } else { throw new SemanticError("La fonction globale " + functionName + " n'est pas une méthode d'instance."); } } return(instanciatedOverloads[fullName]); } return(null); }
/// <summary> /// Retourne la fonction dont le nom est passé en paramètre. /// </summary> /// <param name="functionName"></param> /// <param name="context"></param> /// <returns></returns> public Language.Function GetFunction(string functionName, Context context) { string fullName = functionName; if (Functions.ContainsKey(fullName)) { Language.Function func = Functions[fullName]; return(Functions[fullName]); } return(null); }
/// <summary> /// Retourne la fonction statique pour un type donné dont le nom est passé en paramètre. /// </summary> /// <param name="functionName"></param> /// <param name="context"></param> /// <returns></returns> public Language.Function GetStaticFunction(Language.ClankTypeInstance instancedType, string functionName, List <Language.Evaluable> args, Context context) { // Obtient le nom complet de la fonction (avec les args). Language.ClankType owner = instancedType.BaseType; string fullName = owner.GetFullName() + "." + functionName + Language.Evaluable.GetArgTypesString(args); var instanciatedOverloads = InstanciatedFunc(instancedType); if (instanciatedOverloads.ContainsKey(fullName)) { Language.Function func = instanciatedOverloads[fullName]; // Vérification : la fonction est-elle statique ? if (!func.IsStatic) { throw new SemanticError("La fonction " + functionName + " n'est pas une méthode statique de " + owner.GetFullName() + "."); } return(instanciatedOverloads[fullName]); } return(null); }
/// <summary> /// Retourne le constructeur (instancié) pour un type donné. /// </summary> public Language.Function GetConstructor(Language.ClankType owner, Language.ClankTypeInstance inst, List <Language.Evaluable> args, Context context) { string fullName = owner.GetFullName() + "." + Language.SemanticConstants.New + Language.Evaluable.GetArgTypesString(args); var instanciedOverloads = InstanciatedFunc(inst); if (instanciedOverloads.ContainsKey(fullName)) { Language.Function func = instanciedOverloads[fullName]; // Vérification : la fonction est-elle bien marquée comme constructeur ? if (!func.IsConstructor) { throw new SemanticError("La fonction " + Language.SemanticConstants.New + " n'est pas un constructeur de " + owner.GetFullName() + "."); } return(func.Instanciate(inst.GenericArguments)); } if (args.Count != 0) { throw new SemanticError("Aucun constructeur de '" + owner.GetFullName() + "' ne matche les arguments de type : " + Language.Evaluable.GetArgTypesString(args) + ". Candidats possibles : " + GetCandidatesStr(inst, Language.SemanticConstants.New)); } // Si le constructeur n'existe pas, on crée le constructeur par défaut. Language.Function cons = new Language.Function() { Modifiers = new List <string>() { Language.SemanticConstants.Public, Language.SemanticConstants.Constructor }, ReturnType = inst, Arguments = new List <Language.FunctionArgument>(), Code = new List <Language.Instruction>(), Owner = owner, Type = inst, Name = Language.SemanticConstants.New }; return(cons); }