public MacroEntry(MacroEntry other)
{
Id = other.Id;
Enabled = other.Enabled;
Type = other.Type;
Binding = new MacroBinding(other.Binding);
Function = other.Function.Clone() as MacroFunction;
Description = other.Description;
}
public void Deserialize(BinaryReader reader)
{
Id = reader.ReadUInt32();
Enabled = reader.ReadBoolean();
Type = (MacroType)reader.ReadUInt32();
Binding.Deserialize(reader);
Function = MacroFunction.FromType(Type);
Function.Deserialize(reader);
Description = reader.ReadString();
}
internal static IValue DefineMagicFunction(ListNode list, Scope scope)
{
var children = list.Children.Skip(1).ToArray();
var nameIdentifier = (IdentifierNode)children[0];
string name = nameIdentifier.Name;
bool noFormalParameters = children.Length == 2;
var arguments = noFormalParameters
? new ListNode(list, new List <SyntaxNode>(), list.Line)
: (ListNode)children[1];
var argNames = arguments.Children.OfType <IdentifierNode>().Select(a => a.Name);
ListNode body = (ListNode)children[noFormalParameters ? 1 : 2];
scope[name] = Value.Nil;
var function = new MacroFunction(body, name, argNames.ToList(), scope);
function.MetaType = MacroMetaType.Instance;
scope[name] = function;
return(function);
}
/// <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);
}
}
}
/// <summary>
/// Defines the given macro function
/// </summary>
/// <param name="functionDefinition">The signature of the macro</param>
/// <param name="macroFunction">The macro function</param>
public void DefineMacroFunction(FunctionDefinition functionDefinition, MacroFunction macroFunction)
{
this.macroFunctions.Add(this.virtualMachine.Binder.FunctionSignature(functionDefinition), macroFunction);
}
