Add support for hexadecimal colour codes (#15).

Compiler/Compiler.cs

@@ -69,13 +69,31 @@ public static List<CompileResult> Compile(Dictionary<string, IroVariable> vars,
                 //Switch on all the values in that set and define style based on the keys.
                 foreach (var styleProperty in styleDefinition)
                 {
-                    //Is the value a string?
-                    if (styleProperty.Value.Type != VariableType.Value)
+                    //Is the value for a colour, or another random property?
+                    string value;
+                    if (styleProperty.Key == "color" || styleProperty.Key == "colour"
+                        || styleProperty.Key == "background_color" || styleProperty.Key == "background_colour")
                     {
-                        Error.CompileWarning("Failed to create style with name '" + style.Key + ", non-string value defined in the style object.");
-                        continue;
+                        //For a colour, so it must be hex or string type.
+                        if (styleProperty.Value.Type != VariableType.Value && styleProperty.Value.Type != VariableType.Hex)
+                        {
+                            Error.CompileWarning("Failed to create style with name '" + style.Key + ", colour values must be of type hex or string.");
+                            continue;
+                        }
+
+                        //It is, grab value out.
+                        value = (styleProperty.Value is IroValue) ? ((IroValue)styleProperty.Value).Value : ((IroHex)styleProperty.Value).Value;
+                    }
+                    else
+                    {
+                        //Ensure property is a value type, then grab value out.
+                        if (styleProperty.Value.Type != VariableType.Value)
+                        {
+                            Error.CompileWarning("Failed to create style with name '" + style.Key + "', non-string value defined in the style object.");
+                            continue;
+                        }
+                        value = ((IroValue)styleProperty.Value).Value;
                     }
-                    string value = ((IroValue)styleProperty.Value).Value;
 
                     //Switch on the property.
                     switch (styleProperty.Key)

Data Structures/Parsing/IroScope.cs

@@ -40,6 +40,7 @@ public enum VariableType
         Array,
         Regex,
         Value,
+        Hex,
         Set,
         Include,
         Reference

Data Structures/Parsing/IroValues.cs

@@ -20,6 +20,28 @@ public IroValue(string val)
             Value = val;
         }
     }
+
+    //Represents a single hexadecimal value in Iro.
+    public class IroHex : IroVariable
+    {
+        public string Value;
+
+        private IroHex(string hexVal)
+        {
+            base.Type = VariableType.Hex;
+            Value = hexVal;
+        }
+
+        //Attempts to parse the given string into an Iro hex value.
+        //On failure, returns null.
+        public static IroHex Parse(string hexVal)
+        {
+            //Ensure the value conforms to the standard.
+            if (!hexVal.StartsWith('#') || (hexVal.Length != 4 && hexVal.Length != 7))
+                return null;
+            return new IroHex(hexVal);
+        }
+    }
 
     public class IroRegex : IroVariable
     {

Grammar/iro.g4

@@ -4,6 +4,10 @@ grammar iro;
 @parser::header {#pragma warning disable 3021}
 @lexer::header {#pragma warning disable 3021}
 
+@lexer::members {
+  private bool rhsmode = false;
+}
+
 /*
  * Parser Rules
  */
@@ -31,6 +35,7 @@ include: COLON_SYM IDENTIFIER QUOTE_SYM IDENTIFIER QUOTE_SYM SEMICOLON_SYM;
 
 //Definition, possible right hand sides of attribute.
 definition: ARRAY_SYM? (EQUALS_SYM | REG_EQUALS_SYM) (definition_ident //Literal (eg. myname)
+			| HEX_VALUE
 			| regex //Regular expression.
 			| constant_ref //Reference to a defined const (eg. $${__MYCONST}).
 			| array
@@ -58,7 +63,7 @@ REGEX: L_BRACKET (~[()\n\r] | '\\(' | '\\)' | REGEX)* R_BRACKET ('|' | '?' | '*'
 //Operators & symbols.
 ESCAPED_BRACKET: '\\(' | '\\)';
 REG_EQUALS_SYM: '\\=';
-EQUALS_SYM: '=';
+EQUALS_SYM: '=' {rhsmode=true;};
 ARRAY_SYM: '[]';
 COMMA_SYM: ',';
 L_SQUARE_BRACKET: '[';
@@ -75,11 +80,16 @@ R_BRACKET: ')';
 //An identifier.
 IDENTIFIER: [A-Za-z0-9_.-]+;
 
+//A hexadecimal colour value.
+HEX_VALUE: {rhsmode}? '#' [0-9A-Za-z]+;
+
 //Comments start with "#" in Iro.
-COMMENT: '#' (.)*? '\n' -> channel(HIDDEN);
+//Only valid when not in RHS mode.
+COMMENT: {!rhsmode}? '#' (.)*? '\n' -> channel(HIDDEN);
 
 //Ignore all newlines and whitespace.
-WS:	[ \n\r\t]+ -> channel(HIDDEN);
+WS:	[ \r\t]+ -> channel(HIDDEN);
+ENDL: '\n' {rhsmode=false;} -> channel(HIDDEN);
 
 //Capture token for unknowns.
 UNKNOWN_SYMBOL: .;

Visitors/AttributeVisitor.cs

@@ -91,15 +91,28 @@ public override IroVariable VisitDefinition([NotNull] iroParser.DefinitionContex
             //Normal equality type?
             else if (context.EQUALS_SYM() != null)
             {
-                //Must be a normal identifier.
-                if (context.definition_ident() == null)
+                //Yes, if it's a normal definition identifier return it.
+                if (context.definition_ident() != null)
+                {
+                    return new IroValue(context.definition_ident().IDENTIFIER().GetText());
+
+                }
+                else if (context.HEX_VALUE() != null)
                 {
-                    Error.Fatal(context, "Value provided for standard non-regex variable must be a string.");
+                    //Not a normal definition identifier. Hex value!
+                    var hex = IroHex.Parse(context.HEX_VALUE().GetText());
+                    if (hex == null) 
+                    {
+                        Error.Fatal(context, "Invalid hexadecimal value provided, must be of the format '#NNN or #NNNNNN'.");
+                        return null;
+                    }
+                    return hex;
+                }
+                else
+                {
+                    Error.Fatal(context, "Value provided for standard non-regex variable must be a string or hexadecimal value.");
                     return null;
                 }
-
-                //Return the value.
-                return new IroValue(context.definition_ident().IDENTIFIER().GetText());
             }
 
             //Unknown.