Add IsDefined builtin and AddToPool/#pool

ColorzCore/ColorzCore.csproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -108,6 +108,9 @@
     <Compile Include="Raws\Raw.cs" />
     <Compile Include="IO\Log.cs" />
     <Compile Include="IO\IncludeFileSearcher.cs" />
+    <Compile Include="Parser\Macros\IsDefined.cs" />
+    <Compile Include="Parser\Macros\AddToPool.cs" />
+    <Compile Include="Preprocessor\Directives\PoolDirective.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

ColorzCore/Parser/EAParser.cs

@@ -46,6 +46,9 @@ class EAParser
         }
         public ImmutableStack<bool> Inclusion { get; set; }
 
+        public List<List<Token>> PooledLines { get; private set; }
+        private long poolLabelCounter;
+
         private readonly DirectiveHandler directiveHandler;
 
         private Stack<Tuple<int, bool>> pastOffsets; // currentOffset, offsetInitialized
@@ -79,6 +82,9 @@ public EAParser(Dictionary<string, IList<Raw>> raws, Log log, DirectiveHandler d
             Definitions = new Dictionary<string, Definition>();
             Inclusion = ImmutableStack<bool>.Nil;
             this.directiveHandler = directiveHandler;
+
+            PooledLines = new List<List<Token>>();
+            poolLabelCounter = 0;
         }
 
         public bool IsReservedName(string name)
@@ -761,6 +767,12 @@ public bool ExpandIdentifier(MergeableGenerator<Token> tokens)
             return ret;
         }
 
+        public string MakePoolLabelName()
+        {
+            // The presence of $ in the label name guarantees that it can't be a user label
+            return string.Format("__POOLED${0}", poolLabelCounter++);
+        }
+
         public void Message(Location? loc, string message)
         {
             log.Message(Log.MsgKind.MESSAGE, loc, message);

ColorzCore/Parser/Macros/AddToPool.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using ColorzCore.Lexer;
+
+namespace ColorzCore.Parser.Macros
+{
+    class AddToPool : BuiltInMacro
+    {
+        /*
+         * Macro Usage:
+         * AddToPool(tokens...): adds token to pool, and expands to label name referring to those tokens
+         * AddToPool(tokens..., alignment): adds token to pool and make sure pooled tokens are aligned given alignment        
+         */
+
+        public EAParser ParentParser { get; private set; }
+
+        public AddToPool(EAParser parent)
+        {
+            ParentParser = parent;
+        }
+
+        public override IEnumerable<Token> ApplyMacro(Token head, IList<IList<Token>> parameters)
+        {
+            List<Token> line = new List<Token>(6 + parameters[0].Count);
+
+            string labelName = ParentParser.MakePoolLabelName();
+
+            if (parameters.Count == 2)
+            {
+                // Add Alignment directive 
+
+                line.Add(new Token(TokenType.IDENTIFIER, head.Location, "ALIGN"));
+                line.Add(parameters[1][0]);
+                line.Add(new Token(TokenType.SEMICOLON, head.Location, ";"));
+            }
+
+            // TODO: Make label declaration global (when this feature gets implemented)
+            // This way the name will be available as long as it is pooled (reguardless of pool scope)
+
+            line.Add(new Token(TokenType.IDENTIFIER, head.Location, labelName));
+            line.Add(new Token(TokenType.COLON, head.Location, ":"));
+
+            line.AddRange(parameters[0]);
+            line.Add(new Token(TokenType.NEWLINE, head.Location, "\n"));
+
+            ParentParser.PooledLines.Add(line);
+
+            yield return new Token(TokenType.IDENTIFIER, head.Location, labelName);
+        }
+
+        public override bool ValidNumParams(int num)
+        {
+            return num == 1 || num == 2;
+        }
+    }
+}

ColorzCore/Parser/Macros/IsDefined.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using ColorzCore.Lexer;
+
+namespace ColorzCore.Parser.Macros
+{
+    class IsDefined : BuiltInMacro
+    {
+        public EAParser ParentParser { get; private set; }
+
+        public IsDefined(EAParser parent)
+        {
+            ParentParser = parent;
+        }
+
+        public override IEnumerable<Token> ApplyMacro(Token head, IList<IList<Token>> parameters)
+        {
+            if (parameters[0].Count != 1)
+            {
+                // TODO: err somehow
+                yield return MakeFalseToken(head.Location);
+            }
+            else
+            {
+                Token token = parameters[0][0];
+
+                if ((token.Type == TokenType.IDENTIFIER) && IsReallyDefined(token.Content))
+                {
+                    yield return MakeTrueToken(head.Location);
+                }
+                else
+                {
+                    yield return MakeFalseToken(head.Location);
+                }
+            }
+        }
+
+        public override bool ValidNumParams(int num)
+        {
+            return num == 1;
+        }
+
+        protected bool IsReallyDefined(string name)
+        {
+            return ParentParser.Definitions.ContainsKey(name) || ParentParser.Macros.ContainsName(name);
+        }
+
+        protected static Token MakeTrueToken(DataTypes.Location location)
+        {
+            return new Token(TokenType.NUMBER, location, "1");
+        }
+
+        protected static Token MakeFalseToken(DataTypes.Location location)
+        {
+            return new Token(TokenType.NUMBER, location, "0");
+        }
+    }
+}

ColorzCore/Parser/Macros/MacroCollection.cs

@@ -17,7 +17,12 @@ public MacroCollection(EAParser parent)
         {
             Macros = new Dictionary<string, Dictionary<int, IMacro>>();
             Parent = parent;
-            BuiltInMacros = new Dictionary<string, BuiltInMacro> { { "String", String.Instance } };
+
+            BuiltInMacros = new Dictionary<string, BuiltInMacro> {
+                { "String", new String() },
+                { "IsDefined", new IsDefined(parent) },
+                { "AddToPool", new AddToPool(parent) },
+            };
         }
 
         public bool HasMacro(string name, int paramNum)

ColorzCore/Parser/Macros/String.cs

@@ -9,12 +9,6 @@ namespace ColorzCore.Parser.Macros
 {
     class String : BuiltInMacro
     {
-        private static String instance = new String();
-
-        public static String Instance { get { return instance; } }
-
-        private String() { }
-
         public override IEnumerable<Token> ApplyMacro(Token head, IList<IList<Token>> parameters)
         {
             yield return new Token(TokenType.IDENTIFIER, head.Location, "BYTE");

ColorzCore/Preprocessor/DirectiveHandler.cs

@@ -29,8 +29,9 @@ public DirectiveHandler(IncludeFileSearcher includeSearcher, IncludeFileSearcher
                 { "ifndef", new IfNotDefinedDirective() },
                 { "else", new ElseDirective() },
                 { "endif", new EndIfDirective() },
-                { "define", new DefineDirective() }, //TODO: pool
-                { "undef", new UndefineDirective() }
+                { "define", new DefineDirective() },
+                { "pool", new PoolDirective() },
+                { "undef", new UndefineDirective() },
             };
         }
 

ColorzCore/Preprocessor/Directives/PoolDirective.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using ColorzCore.DataTypes;
+using ColorzCore.Lexer;
+using ColorzCore.Parser;
+using ColorzCore.Parser.AST;
+
+namespace ColorzCore.Preprocessor.Directives
+{
+    class PoolDirective : IDirective
+    {
+        public int MinParams => 0;
+        public int? MaxParams => 0;
+        public bool RequireInclusion => true;
+
+        public Maybe<ILineNode> Execute(EAParser p, Token self, IList<IParamNode> parameters, MergeableGenerator<Token> tokens)
+        {
+            foreach (List<Token> line in p.PooledLines)
+            {
+                tokens.PrependEnumerator(line.GetEnumerator());
+            }
+
+            p.PooledLines.Clear();
+
+            return new Nothing<ILineNode>();
+        }
+    }
+}