예제 #1
0
 public static void Parse(HmdBlockID root, String filename, String importPath, HmdProperties hmdProperties)
 {
     using (FileStream fileStream = new FileStream(filename, FileMode.Open))
     {
         Parse(root, fileStream, importPath, hmdProperties);
     }
 }
예제 #2
0
 public HmdTypeverifydevicesarenotpresent(HmdBlockID blockID, HmdProperties hmdProperties)
 {
     for (int i = 0; i < blockID.ChildCount; i++)
     {
         HmdID childID = blockID.GetChild(i);
         if (childID.isBlock)
         {
             HmdBlockID childBlockID = (HmdBlockID)childID;
             // parse field UsbDevice
             if (childBlockID.idLowerCase.Equals("usbdevice", StringComparison.CurrentCultureIgnoreCase))
             {
                 // set List to not null
                 this.UsbDevice.Add(new HmdTypeusbdevice(childBlockID, hmdProperties));
             }
             else
             {
                 throw new FormatException(String.Format("Unrecognized child block id \"{0}\"", childID.idOriginalCase));
             }
         }
         else
         {
             HmdValueID childValueID = (HmdValueID)childID;
             throw new FormatException(String.Format("Unrecognized child value id \"{0}\"", childID.idOriginalCase));
         }
     }
 }
예제 #3
0
        public String CreateContextString()
        {
            HmdBlockID         currentParent = parent;
            Stack <HmdBlockID> parents       = new Stack <HmdBlockID>();

            while (currentParent != null)
            {
                parents.Push(currentParent);
                currentParent = currentParent.parent;
            }

            if (parents.Count <= 1)
            {
                return(idLowerCase);
            }

            // Pop off the root
            parents.Pop();

            StringBuilder stringBuilder = new StringBuilder();

            while (parents.Count > 0)
            {
                stringBuilder.Append(parents.Pop().idLowerCase);
                stringBuilder.Append('.');
            }
            stringBuilder.Append(idLowerCase);
            return(stringBuilder.ToString());
        }
예제 #4
0
 public static void Iterate(this HmdBlockID blockID, HmdProperties hmdProperties,
                            AtValueIDWithProperties atValueIDWithProperties, AtBlockIDWithProperties atBlockIDWithProperties)
 {
     for (int i = 0; i < blockID.ChildCount; i++)
     {
         HmdID childID = blockID.GetChild(i);
         if (childID.isBlock)
         {
             HmdBlockID           childBlockID           = childID.CastAsBlockID;
             HmdBlockIDProperties childBlockIDProperties = hmdProperties.GetProperties(childBlockID);
             if (childBlockIDProperties == null)
             {
                 throw new InvalidOperationException(String.Format("Found a block id \"{0}\", but it was not defined in the property dictionary", childID.idOriginalCase));
             }
             atBlockIDWithProperties(childBlockID, childBlockIDProperties, hmdProperties);
         }
         else
         {
             HmdValueID           childValueID           = childID.CastAsValueID;
             HmdValueIDProperties childValueIDProperties = hmdProperties.GetProperties(childValueID);
             if (childValueIDProperties == null)
             {
                 throw new InvalidOperationException(String.Format("Found a value id \"{0}\", but it was not defined in the property dictionary", childID.idOriginalCase));
             }
             atValueIDWithProperties(childValueID, childValueIDProperties, hmdProperties);
         }
     }
 }
예제 #5
0
 protected HmdID(Boolean isBlockID, String id, HmdBlockID parent)
 {
     this.isBlock        = isBlockID;
     this.idOriginalCase = id;
     this.idLowerCase    = id.ToLower();
     this.parent         = parent;
 }
예제 #6
0
        public void Validate(HmdBlockID root, HmdProperties hmdProperties)
        {
            debugOutput = HmdDebug.DebugOutput;
            if (root == null)
            {
                throw new ArgumentNullException("root");
            }
            if (hmdProperties == null)
            {
                throw new ArgumentNullException("hmdProperties");
            }

            hmdProperties.ResolveChildParentReferences();

            debugOutput.WriteLine("[Validating HMD file...]");

            hmdProperties.PrintEnums(debugOutput);

            currentBlock = null;
            blockStack   = new Stack <HmdBlockValidator>();

            ValidateBlockID(root, hmdProperties.root, hmdProperties);

            debugOutput.WriteLine("[Done validating HMD file]");
        }
예제 #7
0
 public static void Parse(HmdBlockID root, Stream stream, String importPath, HmdProperties hmdProperties)
 {
     using (StreamReader fileStream = new StreamReader(stream))
     {
         Parse(root, fileStream, importPath, hmdProperties);
     }
 }
예제 #8
0
 public DefaultRootClassName(HmdBlockID blockID, HmdProperties hmdProperties)
 {
     for (int i = 0; i < blockID.ChildCount; i++)
     {
         HmdID childID = blockID.GetChild(i);
         if (childID.isBlock)
         {
             HmdBlockID childBlockID = (HmdBlockID)childID;
             // parse field VerifyDevicesArePresent
             if (childBlockID.idLowerCase.Equals("verifydevicesarepresent", StringComparison.CurrentCultureIgnoreCase))
             {
                 // set List to not null
                 this.VerifyDevicesArePresent.Add(new HmdTypeverifydevicesarepresent(childBlockID, hmdProperties));
             }
             // parse field VerifyDevicesAreNotPresent
             else if (childBlockID.idLowerCase.Equals("verifydevicesarenotpresent", StringComparison.CurrentCultureIgnoreCase))
             {
                 // set List to not null
                 this.VerifyDevicesAreNotPresent.Add(new HmdTypeverifydevicesarenotpresent(childBlockID, hmdProperties));
             }
             else
             {
                 throw new FormatException(String.Format("Unrecognized child block id \"{0}\"", childID.idOriginalCase));
             }
         }
         else
         {
             HmdValueID childValueID = (HmdValueID)childID;
             // parse field Message
             if (childValueID.idLowerCase.Equals("message", StringComparison.CurrentCultureIgnoreCase))
             {
                 this.Message.Add(childValueID.value);
             }
             // parse field UsbSwitch
             else if (childValueID.idLowerCase.Equals("usbswitch", StringComparison.CurrentCultureIgnoreCase))
             {
                 this.UsbSwitch.Add((usbswitch)Enum.Parse(typeof(usbswitch), childValueID.value, true));
             }
             // parse field Sleep
             else if (childValueID.idLowerCase.Equals("sleep", StringComparison.CurrentCultureIgnoreCase))
             {
                 this.Sleep.Add(UInt32.Parse(childValueID.value));
             }
             else
             {
                 throw new FormatException(String.Format("Unrecognized child value id \"{0}\"", childID.idOriginalCase));
             }
         }
     }
 }
예제 #9
0
        public void TestConcreteExample()
        {
            //
            // Parse Properties File
            //
            TextReader    propertiesReader = new System.IO.StringReader("%enum:ExecuteEnum Local Remote Ignore Unsupported;Script{%props:1;Source:enum(File Remote);File:0-1;ListenPort:0-1 int4;}RebootCommand {%props:1;Execute:1 enum(Ignore Unsupported Emulator);RemoteHost:0-1;RemotePort:0-1 int4;}UsbSwitchCommand {	%props:1;	Execute:1 enum ExecuteEnum;	Platform:0-1 enum(Windows Linux);	RemoteHost:0-1;	RemotePort:0-1 int4;}TestCommands {	%props:1;	Execute:1 enum ExecuteEnum;	RemoteHost:0-1;	RemotePort:0-1 int4;}");
            HmdProperties properties       = HmdFileParser.ParsePropertiesFile(propertiesReader, null);

            properties.ResolveChildParentReferences();
            properties.Print(Console.Out);


            HmdEnum hmdEnum;

            hmdEnum = properties.TryGetEnum("ExecuteEnum");
            Assert.IsNotNull(hmdEnum);
            Assert.IsTrue(hmdEnum.IsValidEnumValue("local"));
            Assert.IsTrue(hmdEnum.IsValidEnumValue("remote"));
            Assert.IsTrue(hmdEnum.IsValidEnumValue("IGNORE"));
            Assert.IsTrue(hmdEnum.IsValidEnumValue("unsupported"));

            hmdEnum = properties.TryGetEnum("script.source");
            Assert.IsNotNull(hmdEnum);
            Assert.IsTrue(hmdEnum.IsValidEnumValue("FILE"));
            Assert.IsTrue(hmdEnum.IsValidEnumValue("remote"));

            HmdBlockID fileRoot = new HmdBlockID("THE_ROOT!", null);

            HmdBlockID script = new HmdBlockID("script", fileRoot);

            Assert.IsNotNull(properties.GetProperties(script));

            HmdValueID scriptSource = new HmdValueID("source", "file", script);

            Assert.IsNotNull(properties.GetProperties(scriptSource));



            //
            // Parse Hmd File
            //
            TextReader hmdReader = new System.IO.StringReader("Script {Source:Remote;}RebootCommand {Execute:Unsupported;}UsbSwitchCommand {Execute:Unsupported;}TestCommands {Execute:Local;}");
            HmdBlockID rootID    = new HmdBlockID(String.Empty, null);

            HmdFileParser.Parse(rootID, hmdReader, "", null);


            //HmdValidator.ValidateStatic(rootID, properties);
        }
예제 #10
0
 public static void Iterate(this HmdBlockID blockID, AtValueID atValueID, AtBlockID atBlockID)
 {
     for (int i = 0; i < blockID.ChildCount; i++)
     {
         HmdID id = blockID.GetChild(i);
         if (id.isBlock)
         {
             atBlockID((HmdBlockID)id);
         }
         else
         {
             atValueID((HmdValueID)id);
         }
     }
 }
예제 #11
0
        private void ValidateBlockID(HmdBlockID blockID, HmdBlockIDProperties blockIDProperties, HmdProperties hmdProperties)
        {
            //
            // Check that the current parent is valid
            //
            if (currentBlock == null)
            {
                debugOutput.Write(blockStack.Count, "Checking that \"{0}\" is the root...", blockID.idOriginalCase);
                if (!blockIDProperties.IsRoot)
                {
                    throw new FormatException(String.Format("Block ID \"{0}\" was expected to be the root, but it wasn't?",
                                                            blockIDProperties.idOriginalCase));
                }
                debugOutput.WriteLine("Pass.");
            }
            else
            {
                debugOutput.Write(blockStack.Count, "Checking that \"{0}\" has \"{1}\" as a valid parent...", blockID.idOriginalCase, currentBlock.blockIDProperties.idOriginalCase);
                if (!blockIDProperties.IsValidParent(currentBlock.blockIDProperties))
                {
                    throw new FormatException(String.Format("Block ID \"{0}\" appeared in Block \"{1}\", but this is not allowed with the current properties",
                                                            blockIDProperties.idOriginalCase, currentBlock.blockIDProperties.idOriginalCase));
                }
                debugOutput.WriteLine("Pass.");

                // Add ID to current block validator
                currentBlock.NewChild(blockIDProperties);
            }


            //
            // Verify the Children of the Block ID
            //
            debugOutput.WriteLine(blockStack.Count, "{");

            blockStack.Push(currentBlock);
            currentBlock = new HmdBlockValidator(blockIDProperties);

            blockID.Iterate(hmdProperties, ValidateValueID, ValidateBlockID);

            // Validate Children
            debugOutput.Write(blockStack.Count, "Checking counts of all children for \"{0}\"...", blockID.idOriginalCase);
            currentBlock.ValidateChildren(hmdProperties);
            debugOutput.WriteLine("Pass.");

            currentBlock = blockStack.Pop();
            debugOutput.WriteLine(blockStack.Count, "}} (end of \"{0}\")", blockID.idOriginalCase);
        }
예제 #12
0
        public void SimpleTest()
        {
            String testString = "ABlockID { AValueID: value; AnotherValue: value2; } OtherValue: v; ";

            HmdSingleIDTokenizer tokenizer = new HmdSingleIDTokenizer(new StringReader(testString));
            HmdBlockID           root      = new HmdBlockID(String.Empty, null);

            HmdFileParser.Parse(root, tokenizer, null, null);


            Assert.AreEqual(1, root.ChildCount);
            Assert.IsTrue(root.GetChild(0).isBlock);

            Assert.AreEqual("ABlockID", root.GetChild(0).idOriginalCase);

            HmdBlockID childBlock = root.GetChild(0).CastAsBlockID;

            Assert.AreEqual(2, childBlock.ChildCount);

            Assert.IsFalse(childBlock.GetChild(0).CastAsValueID.isBlock);
            Assert.AreEqual("AValueID", childBlock.GetChild(0).idOriginalCase);
            Assert.AreEqual(" value", childBlock.GetChild(0).CastAsValueID.value);

            Assert.IsFalse(childBlock.GetChild(1).CastAsValueID.isBlock);
            Assert.AreEqual("AnotherValue", childBlock.GetChild(1).idOriginalCase);
            Assert.AreEqual(" value2", childBlock.GetChild(1).CastAsValueID.value);


            root = new HmdBlockID(String.Empty, null);
            tokenizer.Reset();
            HmdFileParser.Parse(root, tokenizer, null, null);

            Assert.AreEqual(1, root.ChildCount);
            Assert.IsFalse(root.GetChild(0).isBlock);

            Assert.AreEqual("OtherValue", root.GetChild(0).idOriginalCase);
            Assert.AreEqual(" v", root.GetChild(0).CastAsValueID.value);
        }
예제 #13
0
 public HmdTypeusbdevice(HmdBlockID blockID, HmdProperties hmdProperties)
 {
     for (int i = 0; i < blockID.ChildCount; i++)
     {
         HmdID childID = blockID.GetChild(i);
         if (childID.isBlock)
         {
             HmdBlockID childBlockID = (HmdBlockID)childID;
             throw new FormatException(String.Format("Unrecognized child block id \"{0}\"", childID.idOriginalCase));
         }
         else
         {
             HmdValueID childValueID = (HmdValueID)childID;
             // parse field LegacyName
             if (childValueID.idLowerCase.Equals("legacyname", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.LegacyName != null)
                 {
                     throw new FormatException("Found multiple value id's \"LegacyName\"");
                 }
                 this.LegacyName = (usbdevicelegacyname)Enum.Parse(typeof(usbdevicelegacyname), childValueID.value, true);
             }
             // parse field Protocol
             else if (childValueID.idLowerCase.Equals("protocol", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Protocol != null)
                 {
                     throw new FormatException("Found multiple value id's \"Protocol\"");
                 }
                 this.Protocol = Byte.Parse(childValueID.value);
             }
             // parse field SubClass
             else if (childValueID.idLowerCase.Equals("subclass", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.SubClass != null)
                 {
                     throw new FormatException("Found multiple value id's \"SubClass\"");
                 }
                 this.SubClass = Byte.Parse(childValueID.value);
             }
             // parse field Class
             else if (childValueID.idLowerCase.Equals("class", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Class != null)
                 {
                     throw new FormatException("Found multiple value id's \"Class\"");
                 }
                 this.Class = Byte.Parse(childValueID.value);
             }
             // parse field Interface
             else if (childValueID.idLowerCase.Equals("interface", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Interface != null)
                 {
                     throw new FormatException("Found multiple value id's \"Interface\"");
                 }
                 this.Interface = Byte.Parse(childValueID.value);
             }
             // parse field SerialNumber
             else if (childValueID.idLowerCase.Equals("serialnumber", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.SerialNumber != null)
                 {
                     throw new FormatException("Found multiple value id's \"SerialNumber\"");
                 }
                 this.SerialNumber = childValueID.value;
             }
             // parse field Product
             else if (childValueID.idLowerCase.Equals("product", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Product != null)
                 {
                     throw new FormatException("Found multiple value id's \"Product\"");
                 }
                 this.Product = childValueID.value;
             }
             // parse field Manufacturer
             else if (childValueID.idLowerCase.Equals("manufacturer", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Manufacturer != null)
                 {
                     throw new FormatException("Found multiple value id's \"Manufacturer\"");
                 }
                 this.Manufacturer = childValueID.value;
             }
             // parse field ProductID
             else if (childValueID.idLowerCase.Equals("productid", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.ProductID != null)
                 {
                     throw new FormatException("Found multiple value id's \"ProductID\"");
                 }
                 this.ProductID = UInt16.Parse(childValueID.value);
             }
             // parse field VendorID
             else if (childValueID.idLowerCase.Equals("vendorid", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.VendorID != null)
                 {
                     throw new FormatException("Found multiple value id's \"VendorID\"");
                 }
                 this.VendorID = UInt16.Parse(childValueID.value);
             }
             // parse field Speed
             else if (childValueID.idLowerCase.Equals("speed", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.Speed != null)
                 {
                     throw new FormatException("Found multiple value id's \"Speed\"");
                 }
                 this.Speed = (usbdevicespeed)Enum.Parse(typeof(usbdevicespeed), childValueID.value, true);
             }
             // parse field PortName
             else if (childValueID.idLowerCase.Equals("portname", StringComparison.CurrentCultureIgnoreCase))
             {
                 // check that field is not set already
                 if (this.PortName != null)
                 {
                     throw new FormatException("Found multiple value id's \"PortName\"");
                 }
                 this.PortName = childValueID.value;
             }
             else
             {
                 throw new FormatException(String.Format("Unrecognized child value id \"{0}\"", childID.idOriginalCase));
             }
         }
     }
 }
예제 #14
0
 public HmdBlockIDProperties GetProperties(HmdBlockID blockID)
 {
     return(blockIDTable.GetProperties(blockID));
 }
예제 #15
0
 public HmdValueID(String idString, String value, HmdBlockID parent)
     : base(IsBlockID, idString, parent)
 {
     this.value = value;
 }
예제 #16
0
 public HmdBlockID(String idString, HmdBlockID parent)
     : base(IsBlockID, idString, parent)
 {
 }
예제 #17
0
 public static void Parse(HmdBlockID root, TextReader reader, String importPath, HmdProperties hmdProperties)
 {
     Parse(root, new HmdTokenizer(reader, 1), importPath, hmdProperties);
 }
예제 #18
0
 public static void ValidateStatic(HmdBlockID root, HmdProperties hmdProperties)
 {
     new HmdValidator().Validate(root, hmdProperties);
 }
예제 #19
0
 public static void Parse(HmdBlockID root, String filename, HmdProperties hmdProperties)
 {
     Parse(root, filename, Path.GetDirectoryName(filename), hmdProperties);
 }
예제 #20
0
        public static void Parse(HmdBlockID root, HmdTokenizer tokenizer,
                                 String importPath, HmdProperties hmdProperties)
        {
            if (root == null)
            {
                throw new ArgumentNullException("root");
            }

            TextWriter debugOutput = HmdDebug.DebugOutput;

            if (debugOutput == null)
            {
                debugOutput = TextWriter.Null;
            }

            if (importPath == null)
            {
                importPath = String.Empty;
            }

            HmdBlockID         parentID      = root;
            Stack <HmdBlockID> parentIDStack = new Stack <HmdBlockID>();

            while (true)
            {
                HmdGlobalToken token = tokenizer.NextGlobalToken();

                //
                // Check for EOF
                //
                if (token.type == HmdGlobalTokenType.EOF)
                {
                    debugOutput.WriteLine("EOF");
                    break;
                }

                if (token.type == HmdGlobalTokenType.ID)
                {
                    String idString = token.text;

                    //
                    // Normal Parse
                    //
                    Boolean isBlockID;
                    Boolean isEmptyID = tokenizer.NextIDType(out isBlockID);

                    if (isBlockID)
                    {
                        debugOutput.WriteLine("Block ID  : {0}", idString);

                        parentIDStack.Push(parentID);
                        HmdBlockID temp = parentID;
                        parentID = new HmdBlockID(idString, temp);
                    }
                    else
                    {
                        debugOutput.WriteLine("Value ID  : {0}", idString);

                        if (isEmptyID)
                        {
                            parentID.AddChild(new HmdValueID(idString, null, parentID));
                        }
                        else
                        {
                            String nextValue = tokenizer.NextValue();
                            debugOutput.WriteLine("Value     : {0}", nextValue);

                            parentID.AddChild(new HmdValueID(idString, nextValue, parentID));
                        }
                    }
                }
                else if (token.type == HmdGlobalTokenType.Directive)
                {
                    String directiveID = token.text;

                    //
                    // Handling Directives
                    //
                    Boolean isBlockID;
                    Boolean isEmptyID = tokenizer.NextIDType(out isBlockID);

                    if (isEmptyID)
                    {
                        throw new NotImplementedException();
                    }
                    else if (!isBlockID)
                    {
                        if (directiveID.Equals("import", StringComparison.CurrentCulture) || directiveID.Equals("pimport", StringComparison.CurrentCulture))
                        {
                            Boolean isPimport = directiveID[0] == 'p';

                            String nextValue = tokenizer.NextValue();

                            debugOutput.WriteLine("{0}  : {1}", isPimport ? "%PImport" : "%Import ", nextValue);

                            if (isPimport && hmdProperties == null)
                            {
                                debugOutput.WriteLine("%PImport  : Ignoring props, so skipping this %pimport");
                            }
                            else
                            {
                                String importFileAndPathName = Path.Combine(importPath, nextValue);

                                using (FileStream importStream = new FileStream(importFileAndPathName, FileMode.Open))
                                {
                                    debugOutput.WriteLine("File Start: {0}", importFileAndPathName);
                                    if (isPimport)
                                    {
                                        ParsePropertiesFile(hmdProperties.root, hmdProperties,
                                                            new HmdTokenizer(new StreamReader(importStream), 1), importPath, true);
                                    }
                                    else
                                    {
                                        Parse(parentID, new HmdTokenizer(new StreamReader(importStream), 1), importPath, hmdProperties);
                                    }
                                    debugOutput.WriteLine("File End  : {0}", importFileAndPathName);
                                }
                            }
                        }
                        else if (directiveID.Equals("enum", StringComparison.CurrentCulture))
                        {
                            throw new FormatException("%enum value directive must be in a %props block directive");
                        }
                        else if (directiveID.Equals("props", StringComparison.CurrentCulture))
                        {
                            throw new FormatException("%props value directive must be in a %props block directive");
                        }
                        else
                        {
                            throw new Exception(String.Format("Parser (line {0}): Unrecognized value directive \"{1}\"",
                                                              token.line, directiveID));
                        }
                    }
                    else
                    {
                        if (directiveID.Equals("props", StringComparison.CurrentCulture))
                        {
                            debugOutput.WriteLine("%Props Blk:");

                            if (hmdProperties == null)
                            {
                                debugOutput.WriteLine("Skipping %props block...");
                                IgnoreCurrentBlock(debugOutput, tokenizer);
                            }
                            else
                            {
                                ParsePropertiesFile(hmdProperties.root, hmdProperties, tokenizer, importPath, false);
                            }
                        }
                        else if (directiveID.Equals("group", StringComparison.CurrentCulture))
                        {
                            throw new FormatException("%group value directive must be in a %props block directive");
                        }
                        else
                        {
                            throw new Exception(String.Format("Parser (line {0}): Unrecognized block directive \"{1}\"",
                                                              token.line, directiveID));
                        }
                    }
                }
                else if (token.type == HmdGlobalTokenType.CloseBrace)
                {
                    if (parentIDStack.Count <= 0)
                    {
                        throw new FormatException(String.Format("Parser (line {0}): Unmatched close brace {1}", token.line, token));
                    }
                    debugOutput.WriteLine("Block End : {0}", parentID.idOriginalCase);

                    HmdBlockID temp = parentID;
                    parentID = parentIDStack.Pop();
                    parentID.AddChild(temp);
                }
                else
                {
                    throw new FormatException(String.Format("Parser (line {0}): Unexpected token {1}", token.line, token));
                }
            }

            if (parentIDStack.Count > 0)
            {
                throw new FormatException(String.Format("Parser (EOF): Block \"{0}\" was not ended with '}'", parentIDStack.Peek().idOriginalCase));
            }
        }