/// <summary>
/// Génère le code représentant une référence vers l'instance de type
/// passé en paramètre, préfixé d'un namespace si besoin.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
string GenerateTypeInstanceNamePrefixed(ClankTypeInstance type)
{
if (type.BaseType.IsEnum || !type.BaseType.IsBuiltIn)
{
return("::" + GenerateTypeInstanceName(type));
}
return(GenerateTypeInstanceName(type));
}
/// <summary>
/// Génère le code représentant l'instance de type passé en paramètre.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
static string GenerateTypeInstanceName(ClankTypeInstance type)
{
if (type.IsGeneric)
{
return(GenerateTypeName(type.BaseType));
}
return(GenerateTypeName(type.BaseType));
}
/// <summary>
/// Cherche le type des éléments d'un type de collection donné.
/// </summary>
/// <param name="collectionType"></param>
/// <returns></returns>
ClankTypeInstance SeekElementType(ClankTypeInstance collectionType)
{
if (collectionType.BaseType.JType != JSONType.Array)
{
return(collectionType);
}
else
{
return(SeekElementType(collectionType.GenericArguments.First()));
}
}
/// <summary>
/// Ajoute un type includable à la collection de types donnée.
/// </summary>
void AddToSet(HashSet <ClankType> types, ClankTypeInstance type)
{
if (type.IsGeneric)
{
foreach (var arg in type.GenericArguments)
{
AddToSet(types, arg);
}
}
if (type.BaseType.IsBuiltIn | type.BaseType.IsEnum | type.BaseType.IsMacro)
{
return;
}
if (!types.Contains(type.BaseType))
{
types.Add(type.BaseType);
}
}
/// <summary>
/// Génère le code représentant l'instance de type passé en paramètre.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
string GenerateTypeInstanceName(ClankTypeInstance type)
{
if (type.IsGeneric || type.IsArray)
{
StringBuilder b = new StringBuilder();
foreach (ClankTypeInstance tArg in type.GenericArguments)
{
b.Append(GenerateTypeInstanceName(tArg));
if (tArg != type.GenericArguments.Last())
{
b.Append(",");
}
}
if (!type.BaseType.IsMacro)
{
return(GenerateTypeName(type.BaseType) + "<" + b.ToString() + ">");
}
else
{
// Si on a un type macro on va remplacer :
// $(T) => type concerné
string nativeFuncName = GenerateTypeName(type.BaseType);
// Remplace les params génériques par leurs valeurs.
for (int i = 0; i < type.BaseType.GenericArgumentNames.Count; i++)
{
nativeFuncName = nativeFuncName.Replace(SemanticConstants.ReplaceChr + "(" + type.BaseType.GenericArgumentNames[i] + ")",
GenerateTypeInstanceName(type.GenericArguments[i]));
}
return(nativeFuncName);
}
}
return(GenerateTypeName(type.BaseType));
}
/// <summary>
/// Génère le code d'un appel de "macro" fonction.
/// </summary>
/// <param name="call"></param>
/// <returns></returns>
string GenerateMacroFunctionCall(FunctionCall call)
{
StringBuilder builder = new StringBuilder();
Clank.Core.Model.MacroContainer.MacroFunction func;
Clank.Core.Model.MacroContainer macros = m_project.Macros;
ClankTypeInstance owner = null;
if (call.Src == null)
{
// Fonction "globale".
func = macros.FindFunctionByName(call.Func.Name);
}
else
{
if (call.IsConstructor)
{
owner = call.Func.ReturnType;
}
else
{
owner = call.Src.Type;
}
Model.MacroContainer.MacroClass klass = macros.FindClassByType(owner.BaseType);
func = klass.Functions[call.Func.GetFullName()]; // TODO : GetFullName() ??
}
// Vérification
if (!func.LanguageToFunctionName.ContainsKey(LANG_KEY))
{
throw new InvalidOperationException("Le nom de la macro fonction '" + func.Function.GetFullName() + "' n'est pas renseigné pour le langage '" + LANG_KEY + "'");
}
// Nom de la fonctin native dont les paramètres sont entourés par des $
string nativeFuncName = func.LanguageToFunctionName[LANG_KEY];
// Remplace les paramètres par leurs values.
for (int i = 0; i < call.Func.Arguments.Count; i++)
{
nativeFuncName = nativeFuncName.Replace(SemanticConstants.ReplaceChr + "(" + call.Func.Arguments[i].ArgName + ")",
GenerateEvaluable(call.Arguments[i]));
}
// Remplace les params génériques par leurs valeurs (si fonction non globale)
if (owner != null)
{
for (int i = 0; i < call.Func.Owner.GenericArgumentNames.Count; i++)
{
nativeFuncName = nativeFuncName.Replace(SemanticConstants.ReplaceChr + "(" + call.Func.Owner.GenericArgumentNames[i] + ")",
GenerateTypeInstanceName(owner.GenericArguments[i]));
}
}
// Remplace @self par le nom de la variable.
if (call.Src != null)
{
nativeFuncName = nativeFuncName.Replace(SemanticConstants.SelfKW, GenerateEvaluable(call.Src));
}
builder.Append(nativeFuncName);
return(builder.ToString().Replace(".[", "["));
}
