using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Bird
{
public enum NamespaceDeclType : byte
{
Declare,
Use
}
public class NamespaceDecl
{
public NamespaceScope Scope;
public NamespaceDeclType Type;
public List<CodeString> Names;
public CodeString Inner;
public Namespace Namespace;
public NamespaceScope NewScope;
public NamespaceDecl(NamespaceScope Scope, NamespaceDeclType Type,
List<CodeString> Names, CodeString Inner = new CodeString())
{
this.Scope = Scope;
this.Type = Type;
this.Names = Names;
this.Inner = Inner;
if (Names == null || Names.Count == 0 || !Names[0].IsValid)
throw new ArgumentException("Name not specified", "Names");
}
public bool Declare(bool AddUsingLate = false)
{
var State = Scope.State;
var Rec = State.Language.NamespaceDeclRecognizer;
for (var i = 0; i < Names.Count; i++)
{
if (!Names[i].IsValidIdentifierName)
{
State.Messages.Add(MessageId.NotValidName, Names[i]);
return false;
}
}
if (Type == NamespaceDeclType.Declare)
{
var Options = new GetIdOptions();
Options.Func = x => x is Namespace;
Namespace = Scope.Namespace;
NewScope = Scope;
for (var i = 0; i < Names.Count; i++)
{
Namespace = Identifiers.GetMember(State, Namespace, Names[i], Options) as Namespace;
if (Namespace == null)
{
Namespace = new Namespace(NewScope, Names[i]);
if (!NewScope.DeclareIdentifier(Namespace))
return false;
}
var OldScope = NewScope;
var NewInner = i == Names.Count - 1 ? Inner : new CodeString();
NewScope = new NamespaceScope(OldScope, NewInner, Namespace);
OldScope.Children.Add(NewScope);
Namespace.AddScope(NewScope);
}
}
else
{
var Options = GetIdOptions.Default;
Options.Func = x => x is Namespace;
Namespace = Identifiers.Recognize(Scope, Names[0], Options) as Namespace;
if (Namespace == null) return false;
for (var i = 1; i < Names.Count; i++)
{
Namespace = Identifiers.GetMember(State, Namespace, Names[i]) as Namespace;
if (Namespace == null) return false;
}
if (!AddUsingLate)
Scope.UsedNamespaces.Add(Namespace);
}
return true;
}
}
public class NamespaceDeclList : List<NamespaceDecl>
{
public static NamespaceDeclList Create(NamespaceScope Scope)
{
var Ret = new NamespaceDeclList();
var Rec = Scope.State.Language.NamespaceDeclRecognizer;
if (Rec != null)
{
if (!Rec.Recognize(Scope, Ret)) return null;
if (!Ret.Resolve()) return null;
}
return Ret;
}
public static NamespaceDeclList CreateAndDeclareRecursively(IdContainer Container)
{
var Ret = new NamespaceDeclList();
if (Container.State.Language.NamespaceDeclRecognizer != null)
{
if (!CreateAndDeclareRecursively(Container, Ret))
return null;
if (!Ret.Resolve()) return null;
}
return Ret;
}
static bool CreateAndDeclareRecursively(IdContainer Container, NamespaceDeclList Out)
{
var RetValue = true;
var State = Container.State;
var Scope = Container as NamespaceScope;
for (var i = 0; i < Container.Children.Count; i++)
{
var e = Container.Children[i];
if (!CreateAndDeclareRecursively(e, Out))
RetValue = false;
}
if (Scope != null && Scope.Code.IsValid)
{
var NewList = new NamespaceDeclList();
var Rec = State.Language.NamespaceDeclRecognizer;
if (!Rec.Recognize(Scope, NewList) || !NewList.Declare())
RetValue = false;
for (var i = 0; i < NewList.Count; i++)
{
var Decl = NewList[i];
if (Decl.Type == NamespaceDeclType.Declare)
{
if (!CreateAndDeclareRecursively(Decl.NewScope, Out))
RetValue = false;
}
Out.Add(Decl);
}
}
return RetValue;
}
public bool Declare()
{
var RetValue = true;
for (var i = 0; i < Count; i++)
{
var Decl = this[i];
if (Decl.Type == NamespaceDeclType.Declare && !Decl.Declare())
RetValue = false;
}
return RetValue;
}
public bool Resolve()
{
var RetValue = true;
for (var i = 0; i < Count; i++)
{
var Decl = this[i];
if (Decl.Type == NamespaceDeclType.Use && !Decl.Declare(true))
RetValue = false;
}
for (var i = 0; i < Count; i++)
{
var Decl = this[i];
if (Decl.Type == NamespaceDeclType.Use)
Decl.Scope.UsedNamespaces.Add(Decl.Namespace);
}
return RetValue;
}
}
public class ConstDeclaration
{
public IdContainer Container;
public CodeString Name;
public Identifier Type;
public List<Modifier> Mods;
public CodeString Str_Value;
public ExpressionNode Value;
public List<CodeString> Dependencies;
public ConstDeclaration(IdContainer Container, CodeString Name, Identifier Type,
CodeString Str_Value, ExpressionNode Value, List<Modifier> Mods)
{
this.Container = Container;
this.Name = Name;
this.Type = Type;
this.Mods = Mods;
this.Str_Value = Str_Value;
this.Value = Value;
this.Dependencies = null;
}
public ConstDeclaration(IdContainer Container, CodeString Name, Identifier Type, CodeString Str_Value, List<Modifier> Mods)
: this(Container, Name, Type, Str_Value, null, Mods)
{
}
public ConstDeclaration(IdContainer Container, CodeString Name, Identifier Type, ExpressionNode Value, List<Modifier> Mods)
: this(Container, Name, Type, new CodeString(), Value, Mods)
{
}
PluginRoot GetPlugin()
{
return new PluginForConstants(Container, true);
}
public bool CalcValue()
{
var Plugin = GetPlugin();
Value = Expressions.CreateExpression(Str_Value, Plugin);
Dependencies = Plugin.GetPlugin<IdRecognizerPlugin>().Dependencies.List;
return Value != null;
}
public SimpleRecResult Declare()
{
var State = Container.State;
if (!Name.IsValidIdentifierName)
{
State.Messages.Add(MessageId.NotValidName, Name);
return SimpleRecResult.Failed;
}
if (Value == null)
{
if (Type.RealId is AutomaticType)
{
State.Messages.Add(MessageId.Untyped, Name);
return SimpleRecResult.Failed;
}
var Var = Container.CreateAndDeclareVariable(Name, Type, Mods);
return Var == null ? SimpleRecResult.Failed : SimpleRecResult.Succeeded;
}
if ((Value = Value.CallNewNode(GetPlugin())) == null)
return SimpleRecResult.Failed;
if (Value is ConstExpressionNode)
{
var ConstVal = Value as ConstExpressionNode;
if (Type.RealId is AutomaticType) Type = ConstVal.Type;
if (!ConstVal.Value.CheckBounds(State, Type, Str_Value))
return SimpleRecResult.Failed;
var Var = Container.CreateAndDeclareVariable(Name, Type, Mods);
if (Var == null) return SimpleRecResult.Failed;
Var.ConstInitValue = ConstVal.Value;
return SimpleRecResult.Succeeded;
}
return SimpleRecResult.Unknown;
}
}
public class ConstDeclarationList : List<ConstDeclaration>
{
public static ConstDeclarationList Create(NonCodeScope Scope)
{
var Ret = new ConstDeclarationList();
var Rec = Scope.State.Language.ConstDeclRecognizer;
return Rec != null && !Rec.Recognize(Scope, Ret) ? null : Ret;
}
public static ConstDeclarationList CreateAndDeclareRecursively(IdContainer Container)
{
var Ret = new ConstDeclarationList();
if (Container.State.Language.ConstDeclRecognizer != null)
{
if (!CreateAndDeclareRecursively(Container, Ret))
return null;
if (!CalcValue(Ret)) return null;
if (!Ret.Resolve()) return null;
}
return Ret;
}
static bool CreateAndDeclareRecursively(IdContainer Container, ConstDeclarationList Out)
{
var RetValue = true;
var State = Container.State;
var Scope = Container as NonCodeScope;
if (Scope != null && Scope.Code.IsValid)
{
if (!State.Language.ConstDeclRecognizer.Recognize(Scope, Out))
RetValue = false;
}
for (var i = 0; i < Container.Children.Count; i++)
{
var e = Container.Children[i];
if (!CreateAndDeclareRecursively(e, Out))
RetValue = false;
}
return RetValue;
}
public static bool CalcValue(List<ConstDeclaration> List)
{
var RetValue = true;
for (var i = 0; i < List.Count; i++)
{
var e = List[i];
if (e.Value == null && e.Str_Value.IsValid && !e.CalcValue())
RetValue = false;
}
return RetValue;
}
public bool Resolve()
{
var RetValue = true;
var List = new List<ConstDeclaration>(this);
var Count = 1;
while (Count > 0)
{
Count = 0;
for (var i = 0; i < List.Count; i++)
{
var Res = List[i].Declare();
if (Res == SimpleRecResult.Succeeded) Count++;
if (Res == SimpleRecResult.Failed) RetValue = false;
if (Res != SimpleRecResult.Unknown)
{
List.RemoveAt(i);
i--;
}
}
}
if (List.Count > 0)
{
RetValue = false;
foreach (var e in List)
{
var State = e.Container.State;
if (e.Dependencies != null && e.Dependencies.Count > 0)
{
foreach (var IdName in e.Dependencies)
State.Messages.Add(MessageId.UnknownId, IdName);
}
else
{
State.Messages.Add(MessageId.CannotCalcConst, e.Str_Value);
}
}
}
return RetValue;
}
}
public class AliasDeclaration
{
public IdContainer Container;
public CodeString NewName;
public CodeString OldName;
public List<Modifier> Mods;
public AliasDeclaration(IdContainer Container, CodeString NewName, CodeString OldName,
List<Modifier> Mods = null)
{
this.Container = Container;
this.NewName = NewName;
this.OldName = OldName;
this.Mods = Mods;
}
public SimpleRecResult Declare()
{
var Options = new GetIdOptions(GetIdMode.Everywhere, false);
var Id = Container.RecognizeIdentifier(OldName, Options);
if (Id == null) return SimpleRecResult.Unknown;
var Alias = new IdentifierAlias(Container, NewName, Id);
if (Mods != null && !Modifiers.Apply(Mods, Alias))
return SimpleRecResult.Failed;
if (!Container.DeclareIdentifier(Alias))
return SimpleRecResult.Failed;
return SimpleRecResult.Succeeded;
}
}
public class AliasDeclarationList : List<AliasDeclaration>
{
public bool RecognizeRecursively(IdContainer Container)
{
var RetValue = true;
var State = Container.State;
var Scope = Container as NonCodeScope;
if (State.Language.AliasDeclRecognizer == null)
return true;
if (Scope != null && Scope.Code.IsValid)
{
if (!State.Language.AliasDeclRecognizer.Recognize(Scope, this))
RetValue = false;
}
for (var i = 0; i < Container.Children.Count; i++)
{
if (!RecognizeRecursively(Container.Children[i]))
RetValue = false;
}
return RetValue;
}
public bool Recognize(NonCodeScope Scope)
{
var State = Scope.State;
if (State.Language.AliasDeclRecognizer != null)
{
if (!State.Language.AliasDeclRecognizer.Recognize(Scope, this))
return false;
}
return true;
}
public bool Recognize(TypeDeclarationList List)
{
var RetValue = true;
for (var i = 0; i < List.Count; i++)
{
var NewType = List[i].DeclaredType as StructuredType;
if (NewType == null) continue;
if (!Recognize(NewType.StructuredScope))
RetValue = false;
}
return RetValue;
}
public bool ExecuteOnce(out bool Found)
{
Found = false;
var RetValue = true;
for (var i = 0; i < Count; i++)
{
var Res = this[i].Declare();
if (Res != SimpleRecResult.Unknown)
{
if (Res == SimpleRecResult.Failed)
RetValue = false;
Found = true;
RemoveAt(i);
i--;
}
}
return RetValue;
}
public bool Declare(bool All = true)
{
bool Loop;
do
{
if (!ExecuteOnce(out Loop))
return false;
} while (Loop);
return All ? ShowMessages() : true;
}
public bool ShowMessages()
{
var RetValue = true;
for (var i = 0; i < Count; i++)
{
var Decl = this[i];
var State = Decl.Container.State;
State.Messages.Add(MessageId.UnknownId, Decl.OldName);
RetValue = false;
}
return RetValue;
}
}
public enum TypeDeclType
{
Class,
Struct,
Enum,
Flag,
}
public class TypeDeclaration
{
public TypeDeclType Type;
public IdContainer Container;
public CodeString Name;
public StructureBase[] Bases;
public List<Modifier> Mods;
public CodeString Inner;
public Type DeclaredType;
public TypeDeclaration(IdContainer Container, CodeString Name, TypeDeclType Type,
StructureBase[] Bases, CodeString Inner, List<Modifier> Mods)
{
this.Container = Container;
this.Name = Name;
this.Bases = Bases;
this.Type = Type;
this.Mods = Mods;
this.Inner = Inner;
}
public SimpleRecResult Declare()
{
var State = Container.State;
var Arch = State.Arch;
//------------------------------------------------------------------
if (Type == TypeDeclType.Struct || Type == TypeDeclType.Class)
{
var NewType = (StructuredType)null;
if (Type == TypeDeclType.Struct)
{
NewType = new StructType(Container, Name);
if (Bases.Length > 0)
{
for (var i = 0; i < Bases.Length; i++)
State.Messages.Add(MessageId.CannotInherit, Bases[i].Name);
return SimpleRecResult.Failed;
}
}
else
{
NewType = new ClassType(Container, Name);
}
if (!Modifiers.Apply(Mods, NewType)) return SimpleRecResult.Failed;
if (!Container.DeclareIdentifier(NewType)) return SimpleRecResult.Failed;
NewType.BaseStructures = Bases;
NewType.StructuredScope = new StructuredScope(Container, Inner, NewType);
Container.Children.Add(NewType.StructuredScope);
DeclaredType = NewType;
return SimpleRecResult.Succeeded;
}
//------------------------------------------------------------------
else if (Type == TypeDeclType.Enum || Type == TypeDeclType.Flag)
{
var NewType = (EnumType)null;
if (Bases.Length == 1)
{
if (Type == TypeDeclType.Flag) NewType = new FlagType(Container, Name, Bases[0].Name);
else NewType = new EnumType(Container, Name, Bases[0].Name);
if (Bases[0].Base != null)
NewType.Children[0] = Bases[0].Base;
if (Bases[0].Flags != StructureBaseFlags.None)
{
State.Messages.Add(MessageId.NotExpected, Bases[0].Declaration);
return SimpleRecResult.Failed;
}
}
else if (Bases.Length > 1)
{
for (var i = 1; i < Bases.Length; i++)
State.Messages.Add(MessageId.NotExpected, Bases[i].Declaration);
return SimpleRecResult.Failed;
}
else
{
if (Type == TypeDeclType.Flag) NewType = new FlagType(Container, Name, new CodeString());
else NewType = new EnumType(Container, Name, new CodeString());
}
if (!Modifiers.Apply(Mods, NewType)) return SimpleRecResult.Failed;
if (!Container.DeclareIdentifier(NewType)) return SimpleRecResult.Failed;
NewType.EnumScope = new EnumScope(Container, Inner, NewType);
Container.Children.Add(NewType.EnumScope);
DeclaredType = NewType;
return SimpleRecResult.Succeeded;
}
//------------------------------------------------------------------
else
{
throw new ApplicationException();
}
}
}
public class TypeDeclarationList : List<TypeDeclaration>
{
public static TypeDeclarationList Create(NonCodeScope Scope)
{
var Ret = new TypeDeclarationList();
var Rec = Scope.State.Language.TypeDeclRecognizer;
return Rec != null && !Rec.Recognize(Scope, Ret) ? null : Ret;
}
public static TypeDeclarationList CreateAndDeclareRecursively(IdContainer Container)
{
var Ret = new TypeDeclarationList();
if (Container.State.Language.TypeDeclRecognizer != null)
{
if (!CreateAndDeclareRecursively(Container, Ret))
return null;
}
return Ret;
}
static bool CreateAndDeclareRecursively(IdContainer Container, TypeDeclarationList Out)
{
var RetValue = true;
var State = Container.State;
var Scope = Container as NonCodeScope;
if (Scope != null && Scope.Code.IsValid)
{
var NewList = new TypeDeclarationList();
var Rec = State.Language.TypeDeclRecognizer;
if (!Rec.Recognize(Scope, NewList) || !NewList.Declare())
RetValue = false;
Out.AddRange(NewList);
}
for (var i = 0; i < Container.Children.Count; i++)
{
var e = Container.Children[i];
if (!CreateAndDeclareRecursively(e, Out))
RetValue = false;
}
return RetValue;
}
public bool Declare()
{
var RetValue = true;
for (var i = 0; i < Count; i++)
{
var Res = this[i].Declare();
if (Res != SimpleRecResult.Succeeded)
{
if (Res == SimpleRecResult.Failed) RetValue = false;
else throw new ApplicationException();
}
}
return RetValue;
}
}
public enum VarDeclConvMode : byte
{
Nothing = 0,
Normal = 1,
Assignment = 2,
}
public struct VarDeclaration
{
public CodeString Declaration;
public CodeString Name;
public CodeString InitString;
public CodeString TypeName;
public Identifier Type;
public List<Modifier> Modifiers;
public VarDeclaration(CodeString Declaration, CodeString TypeName, Identifier Type,
CodeString Name, CodeString InitString, List<Modifier> Modifiers = null)
{
this.Declaration = Declaration;
this.TypeName = TypeName;
this.InitString = InitString;
this.Type = Type;
this.Name = Name;
this.Modifiers = Modifiers;
}
public ExpressionNode GetVal(PluginRoot Plugin, BeginEndMode Mode = BeginEndMode.Both)
{
return Expressions.CreateExpression(InitString, Plugin, Mode);
}
public bool CheckName(CompilerState State)
{
if (Name.IsValid && !Name.IsValidIdentifierName)
{
State.Messages.Add(MessageId.NotValidName, Declaration);
return false;
}
return true;
}
public Variable ToVariable(IdContainer Container, bool Declare = false)
{
if (!CheckName(Container.State))
return null;
var Ret = Container.CreateVariable(Name, Type, Modifiers);
if (Ret == null) return null;
if (Declare && !Container.DeclareIdentifier(Ret))
return null;
Ret.InitString = InitString;
return Ret;
}
public FunctionParameter ToFuncParam(PluginRoot Plugin, VarDeclConvMode Mode = VarDeclConvMode.Nothing)
{
if (!CheckName(Plugin.State))
return null;
var Ret = new FunctionParameter(Plugin.Container, Name, Type);
Ret.Declaration = Declaration;
Ret.InitString = InitString;
if (Modifiers != null && !Bird.Modifiers.Apply(Modifiers, Ret))
return null;
if (Mode != VarDeclConvMode.Nothing)
{
if (!Ret.CalcValue(Plugin, BeginEndMode.Both, Mode == VarDeclConvMode.Assignment))
return null;
}
return Ret;
}
public Variable ToVariable(PluginRoot Plugin, BeginEndMode BEMode = BeginEndMode.Both,
VarDeclConvMode Mode = VarDeclConvMode.Nothing, bool UsePlugin = false, bool Declare = false, bool EnableUntyped = false)
{
if (!CheckName(Plugin.State))
return null;
Variable Ret;
if (UsePlugin)
{
Ret = Plugin.CreateVariable(Type, Name);
if (Ret == null) return null;
Ret.InitString = InitString;
if (Declare && !Plugin.DeclareIdentifier(Ret))
return null;
}
else
{
Ret = ToVariable(Plugin.Container, Declare);
if (Ret == null) return null;
}
if (Mode != VarDeclConvMode.Nothing)
{
if (!Ret.CalcValue(Plugin, BEMode, Mode == VarDeclConvMode.Assignment, EnableUntyped))
return null;
}
return Ret;
}
public Property ToProperty(IdContainer Container)
{
if (!CheckName(Container.State)) return null;
return Container.CreateProperty(Name, Type, null, Modifiers);
}
}
[Flags]
public enum VarDeclarationListFlags : byte
{
None,
EnableUnnamed = 1,
EnableAutoType = 2,
EnableMessages = 4,
EnableInitValue = 8,
EnableVoidOnly = 16,
Default = EnableAutoType | EnableMessages | EnableInitValue,
}
public class VarDeclarationList : List<VarDeclaration>
{
public List<Modifier> DefaultModifiers;
public VarDeclarationList(List<Modifier> DefaultModifiers = null)
{
this.DefaultModifiers = DefaultModifiers;
}
public static VarDeclarationList Create(IdContainer Container, CodeString Code, List<Modifier> DefaultModifiers = null,
VarDeclarationListFlags Flags = VarDeclarationListFlags.Default)
{
var Ret = new VarDeclarationList(DefaultModifiers);
var Rec = Container.State.Language.VarDeclRecognizer;
if (Rec != null)
{
var EnableMessages = (Flags & VarDeclarationListFlags.EnableMessages) != 0;
if (!Rec.Recognize(Container, Code, EnableMessages, Ret)) return null;
if (!Ret.Process(Container, Flags)) return null;
}
else
{
throw new ApplicationException("A variable declaration recognizer is not avaiable");
}
return Ret;
}
public bool IsDefined(string Name, int Until = -1)
{
if (Until == -1) Until = Count;
for (var i = 0; i < Until; i++)
if (this[i].Name.IsEqual(Name)) return true;
return false;
}
public bool IsDefined(CodeString Name, int Until = -1)
{
if (Until == -1) Until = Count;
for (var i = 0; i < Until; i++)
if (this[i].Name.IsEqual(Name)) return true;
return false;
}
public bool Process(IdContainer Container, VarDeclarationListFlags Flags = VarDeclarationListFlags.Default)
{
var RetValue = true;
var State = Container.State;
var Type = (Identifier)null;
var FirstIsVoid = false;
for (var i = 0; i < Count; i++)
{
var e = this[i];
if (FirstIsVoid)
{
State.Messages.Add(MessageId.NotExpected, e.Declaration);
RetValue = false;
continue;
}
if (e.Name.IsValid)
{
if (!e.Name.IsValidIdentifierName)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.NotValidName, e.Name);
RetValue = false;
}
if (IsDefined(e.Name, i))
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.IdAlreadyDefined, e.Name);
RetValue = false;
}
}
else if ((Flags & VarDeclarationListFlags.EnableUnnamed) == 0)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.MustBeNamed, e.Declaration);
RetValue = false;
}
if (e.TypeName.IsValid)
{
Type = e.Type;
Type.SetUsed();
var RType = Type.RealId as Type;
if (RType is AutomaticType)
{
if ((Flags & VarDeclarationListFlags.EnableAutoType) == 0)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.Untyped, e.TypeName);
RetValue = false;
}
}
else if (RType == null || (RType.TypeFlags & TypeFlags.CanBeVariable) == 0)
{
if (RType is VoidType && (Flags & VarDeclarationListFlags.EnableVoidOnly) != 0)
{
if (e.Name.IsValid)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.NotExpected, e.Name);
RetValue = false;
continue;
}
else if (e.InitString.IsValid)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.NotExpected, e.InitString);
RetValue = false;
continue;
}
FirstIsVoid = true;
}
else
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.CannotBeThisType, e.TypeName);
RetValue = false;
}
}
}
else
{
if (Type != e.Type) throw new ApplicationException();
}
if (e.InitString.IsValid && (Flags & VarDeclarationListFlags.EnableInitValue) == 0)
{
if ((Flags & VarDeclarationListFlags.EnableMessages) != 0)
State.Messages.Add(MessageId.CannotHaveInitVal, e.InitString);
RetValue = false;
}
}
return RetValue;
}
public Variable[] ToVariables(PluginRoot Plugin, BeginEndMode BEMode = BeginEndMode.Both,
VarDeclConvMode Mode = VarDeclConvMode.Nothing, bool UsePlugin = false, bool Declare = false, bool EnableUntyped = false)
{
var Ret = new Variable[Count];
for (var i = 0; i < Count; i++)
{
if ((BEMode & BeginEndMode.Begin) != 0) Plugin.Reset();
Ret[i] = this[i].ToVariable(Plugin, BEMode, Mode, UsePlugin, Declare, EnableUntyped);
}
return Ret;
}
public Variable[] ToVariables(IdContainer Container, bool Declare = false, bool EnableUntyped = false)
{
var Ret = new Variable[Count];
for (var i = 0; i < Count; i++)
Ret[i] = this[i].ToVariable(Container, Declare);
return Ret;
}
public FunctionParameter[] ToFuncParams(PluginRoot Plugin, VarDeclConvMode Mode = VarDeclConvMode.Nothing)
{
var Ret = new FunctionParameter[Count];
for (var i = 0; i < Count; i++)
{
Plugin.Reset();
Ret[i] = this[i].ToFuncParam(Plugin, Mode);
}
return Ret;
}
public ConstDeclaration[] ToConstDecls(IdContainer Container, List<Modifier> Mods = null)
{
var Ret = new ConstDeclaration[Count];
for (var i = 0; i < Count; i++)
{
var e = this[i];
Ret[i] = new ConstDeclaration(Container, e.Name, e.Type, e.InitString, Mods);
}
return Ret;
}
public TupleType ToTupleType(IdContainer Container, bool EnableMessages = true)
{
var State = Container.State;
var Members = new List<Identifier>();
for (var i = 0; i < Count; i++)
{
var Decl = this[i];
if (Decl.InitString.IsValid)
{
if (EnableMessages)
State.Messages.Add(MessageId.CannotHaveInitVal, Decl.InitString);
return null;
}
var RType = Decl.Type.RealId as Type;
if ((RType.TypeFlags & TypeFlags.CanBeVariable) == 0)
{
if (EnableMessages)
State.Messages.Add(MessageId.CannotBeThisType, Decl.TypeName);
return null;
}
var Var = new MemberVariable(Container, Decl.Name, Decl.Type);
Var.Access = Decl.Type.Access;
Members.Add(Var);
}
return new TupleType(Container, Members);
}
public bool VerifyInitVal(IdContainer Container)
{
var RetValue = true;
var State = Container.State;
for (var i = 0; i < Count; i++)
{
var e = this[i];
if (!e.InitString.IsValid)
{
State.Messages.Add(MessageId.MustHaveInitVal, e.Name);
RetValue = false;
}
}
return RetValue;
}
}
}