示例#1
0
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <HostExtenderRef>()
            .Property(x => x.ExtenderIndex)
            .ByRegexPattern(CommonRegexPatterns._HEXINT32, CommonConverters.HexInt32Converter)
            .WithPostfix(new LiteralToken("="));

            Syntax
            .Entity <HostExtenderRef>()
            .Property(x => x.ExtenderGuid)
            .ByRegexPattern(CommonRegexPatterns._GUID)
            .WithPostfix(new LiteralToken(";"));

            Syntax
            .Entity <HostExtenderRef>()
            .Property(x => x.LibName)
            .ByRegexPattern("VBE[\x21-\x3A\x3C-\xFF]*")
            .WithPostfix(new LiteralToken(";"));

            Syntax
            .Entity <HostExtenderRef>()
            .Property(x => x.CreationFlags)
            .ByRegexPattern(CommonRegexPatterns._HEXINT32, CommonConverters.HexInt32Converter)
            .WithPostfix(CommonTokens.NWLN);
        }
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <ProjectWindow>()
            .Property(x => x.WindowLeft)
            .ByRegexPattern(CommonRegexPatterns._INT32)
            .WithPostfix(new LiteralToken(", "));

            Syntax
            .Entity <ProjectWindow>()
            .Property(x => x.WindowTop)
            .ByRegexPattern(CommonRegexPatterns._INT32)
            .WithPostfix(new LiteralToken(", "));

            Syntax
            .Entity <ProjectWindow>()
            .Property(x => x.WindowRight)
            .ByRegexPattern(CommonRegexPatterns._INT32)
            .WithPostfix(new LiteralToken(", "));

            Syntax
            .Entity <ProjectWindow>()
            .Property(x => x.WindowBottom)
            .ByRegexPattern(CommonRegexPatterns._INT32)
            .WithPostfix(new LiteralToken(", "));

            Syntax
            .Entity <ProjectWindow>()
            .Property(x => x.WindowState)
            .ByRegexPattern("[CZI]{0,1}");     // todo: documentation not quite clear to me.. is could there be two chars? e.g. CZ ?
        }
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <ProjectWindowState>()
            .Property(x => x.CodeWindow)
            .ByRegisteredTypes(typeof(ProjectWindow));

            Syntax
            .Entity <ProjectWindowState>()
            .Property(x => x.DesignerWindow)
            .ByRegisteredTypes(typeof(ProjectWindow))
            .WithPrefix(new LiteralToken(", "))
            .IsOptional();
        }
示例#4
0
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <ProjectDocModule>()
            .Property(x => x.ModuleIdentifier)
            .ByRegexPattern(CommonRegexPatterns._ANYCHAR + "{0,31}")
            .WithPrefix(new LiteralToken("Document="));

            Syntax
            .Entity <ProjectDocModule>()
            .Property(x => x.DocTlibVer)
            .ByRegexPattern(CommonRegexPatterns._HEXINT32, CommonConverters.HexInt32Converter)
            .WithPrefix(new LiteralToken(@"/"));
        }
示例#5
0
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <ProjectWindowRecord>()
            .Property(x => x.ModuleIdentifier)
            .ByRegexPattern(CommonRegexPatterns._ANYCHAR + "{0,31}")
            .WithPostfix(new LiteralToken("="));

            Syntax
            .Entity <ProjectWindowRecord>()
            .Property(x => x.ProjectWindowState)
            .ByRegisteredTypes(typeof(ProjectWindowState))
            .WithPostfix(CommonTokens.NWLN);
        }
示例#6
0
 public static void Setup(ISyntax Syntax)
 {
     Syntax
     .Entity <ProjectWorkspace>()
     .EnumerableProperty(x => x.ProjectWindowRecords)
     .ByRegisteredTypes(typeof(ProjectWindowRecord));
 }
示例#7
0
 public static void Setup(ISyntax Syntax)
 {
     Syntax
     .Entity <ProjectDesignerModule>()
     .Property(x => x.ModuleIdentifier)
     .ByRegexPattern(CommonRegexPatterns._ANYCHAR + "{0,31}")
     .WithPrefix(new LiteralToken("BaseClass="));
 }
示例#8
0
 public static void Setup(ISyntax Syntax)
 {
     Syntax
     .Entity <HostExtenders>()
     .EnumerableProperty(x => x.HostExtenderRef)
     .ByRegisteredTypes(typeof(HostExtenderRef))
     .WithPrefix(new LiteralToken("[Host Extender Info]") + CommonTokens.NWLN);
 }
 public static void Setup(ISyntax Syntax)
 {
     Syntax
     .Entity <ProjectPackage>()
     .Property(x => x.GUID)
     .ByRegexPattern(CommonRegexPatterns._GUID)
     .WithPrefix(new LiteralToken("Package="));
 }
示例#10
0
 public static void Setup(ISyntax Syntax)
 {
     Syntax
     .Entity <ProjectId>()
     .Property(x => x.ProjectCLSID)
     .ByRegexPattern(CommonRegexPatterns._GUID)
     .WithPrefix(new LiteralToken("ID=\""))
     .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);
 }
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <VBAPROJECTText>()
            .Property(x => x.ProjectProperties)
            .ByRegisteredTypes(typeof(ProjectProperties))
            .WithPostfix(CommonTokens.NWLN);

            Syntax
            .Entity <VBAPROJECTText>()
            .Property(x => x.HostExtenders)
            .ByRegisteredTypes(typeof(HostExtenders));

            Syntax
            .Entity <VBAPROJECTText>()
            .Property(x => x.ProjectWorkspace)
            .ByRegisteredTypes(typeof(ProjectWorkspace))
            .WithPrefix(CommonTokens.NWLN + new LiteralToken("[Workspace]") + CommonTokens.NWLN)
            .IsOptional();
        }
        public static void Setup(ISyntax Syntax)
        {
            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectId)
            .ByRegisteredTypes(typeof(ProjectId));

            Syntax
            .Entity <ProjectProperties>()
            .EnumerableProperty(x => x.ProjectItems)
            .ByRegisteredTypes(typeof(ProjectDocModule), typeof(ProjectStdModule), typeof(ProjectClassModule), typeof(ProjectDesignerModule), typeof(ProjectPackage))
            .WithPostfix(CommonTokens.NWLN);

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectHelpFile)
            .ByRegexPattern(CommonRegexPatterns._PATH)
            .WithPrefix(new LiteralToken("HelpFile="))
            .WithPostfix(CommonTokens.NWLN)
            .IsOptional();

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectExeName32)
            .ByRegexPattern(CommonRegexPatterns._PATH)
            .WithPrefix(new LiteralToken("ExeName32="))
            .WithPostfix(CommonTokens.NWLN)
            .IsOptional();

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectName)
            .ByRegexPattern(@"(" + CommonRegexPatterns._QUOTEDCHAR + "){1,128}")
            .WithPrefix(new LiteralToken("Name=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectHelpId)
            .ByRegexPattern(CommonRegexPatterns._INT32)
            .WithPrefix(new LiteralToken("HelpContextID=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectDescription)
            .ByRegexPattern(@"(" + CommonRegexPatterns._QUOTEDCHAR + "){0,2000}")
            .WithPrefix(new LiteralToken("Description=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN)
            .IsOptional();

            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x._ProjectVersionCompat32)
            .ByRegexPattern("")
            .WithPrefix(new LiteralToken("VersionCompatible32=") + CommonTokens.DQUOTE + new LiteralToken("393222000") + CommonTokens.DQUOTE + CommonTokens.NWLN)
            .IsOptional();

            // p 24
            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectProtectionState)
            .ByRegexPattern("(" + CommonRegexPatterns._HEXDIG + "){22,28}")
            .WithPrefix(new LiteralToken("CMG=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);

            // p 25
            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectPassword)
            .ByRegexPattern("(" + CommonRegexPatterns._HEXDIG + "){16,}")
            .WithPrefix(new LiteralToken("DPB=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);


            // p 25
            Syntax
            .Entity <ProjectProperties>()
            .Property(x => x.ProjectVisibilityState)
            .ByRegexPattern("(" + CommonRegexPatterns._HEXDIG + "){16,22}")
            .WithPrefix(new LiteralToken("GC=") + CommonTokens.DQUOTE)
            .WithPostfix(CommonTokens.DQUOTE + CommonTokens.NWLN);
        }