Esempio n. 1
0
        internal static void IncludeFileOpen(ProgramMap map)
        {
            var stopList = new HashSet <string>();

            foreach (var inc in map.Includes)
            {
                var name = inc.Value.OriginName;
                var path = inc.Value.Path + name;

                if (File.Exists(path))
                {
                    if (Data.ContainsKey(name))
                    {
                        if (path != Data[name].FullPath)
                        {
                            Data.Remove(name);
                        }
                    }

                    if (!Data.ContainsKey(name))
                    {
                        var text = File.ReadAllText(path);
                        var item = new NewTabItem().Create(text, name);
                        var pd   = new ProgramData();
                        pd.ParseName    = name;
                        pd.ClosedName   = name;
                        pd.OldName      = name;
                        pd.Name         = name;
                        pd.AddToObjects = false;
                        pd.Item         = item;
                        pd.Path         = inc.Value.Path;
                        pd.FullPath     = path;
                        pd.TextChange   = false;
                        SetVSLSync(pd);
                    }
                }
                else
                {
                    if (Data.ContainsKey(name))
                    {
                        Data.Remove(name);
                    }

                    stopList.Add(inc.Key);
                }
            }

            foreach (var inc in stopList)
            {
                map.Includes.Remove(inc);
            }
        }
Esempio n. 2
0
        internal static void MainFileOpen(ProgramMap map, Dictionary <string, ProgramData> data)
        {
            var name = map.MainName;
            var path = map.MainPath + name;

            if (File.Exists(path))
            {
                if (data.ContainsKey(name))
                {
                    if (path != data[name].FullPath)
                    {
                        CommonData.Status.Add(path + "  " + data[name].FullPath);
                        data.Remove(name);
                    }
                }

                if (!data.ContainsKey(name))
                {
                    var text = File.ReadAllText(path);
                    var item = new NewTabItem().Create(text, name);
                    var pd   = new ProgramData();
                    pd.ParseName    = name;
                    pd.ClosedName   = name;
                    pd.OldName      = name;
                    pd.Name         = name;
                    pd.AddToObjects = false;
                    pd.Item         = item;
                    pd.Path         = map.MainPath;
                    pd.FullPath     = path;
                    pd.TextChange   = false;
                    data.Add(name, pd);
                    //IntellisenseParser.SetVSLSync(pd, data);
                }
            }
            else
            {
                if (data.ContainsKey(name))
                {
                    data.Remove(name);
                }

                map.MainName = "";
            }
        }
Esempio n. 3
0
        internal static void SetVSLSync(ProgramData pData)
        {
            var map   = new ProgramMap(pData.Map.Type);
            var lines = pData.Editor.TextArea.Lines;
            var path  = pData.Path;

            SetVSL(path, lines, map);

            pData.Map = map;

            if (Data.ContainsKey(pData.ParseName))
            {
                Data[pData.ParseName] = pData;
            }
            else
            {
                Data.Add(pData.ParseName, pData);
            }
        }
Esempio n. 4
0
        internal static void MainFileOpen(ProgramMap map)
        {
            var name = map.MainName;
            var path = map.MainPath + name;

            if (File.Exists(path))
            {
                if (Data.ContainsKey(name))
                {
                    if (path != Data[name].FullPath)
                    {
                        Data.Remove(name);
                    }
                }

                if (!Data.ContainsKey(name))
                {
                    var text = File.ReadAllText(path);
                    var item = new NewTabItem().Create(text, name);
                    var pd   = new ProgramData();
                    pd.ParseName    = name;
                    pd.ClosedName   = name;
                    pd.OldName      = name;
                    pd.Name         = name;
                    pd.AddToObjects = false;
                    pd.Item         = item;
                    pd.Path         = map.MainPath;
                    pd.FullPath     = path;
                    pd.TextChange   = false;
                    SetVSLSync(pd);
                }
            }
            else
            {
                if (Data.ContainsKey(name))
                {
                    Data.Remove(name);
                }

                map.MainName = "";
            }
        }
Esempio n. 5
0
        private static async Task SetVSLAsync(string name)
        {
            var prjData = MainWindowVM.Project.GetDictionary();

            if (prjData.ContainsKey(name))
            {
                var pData = prjData[name];
                var map   = new ProgramMap(pData.Map.Type);
                var lines = pData.Editor.TextArea.Lines;
                var path  = pData.Path;

                await Task.Run(() => SetVSL(path, lines, map));

                if (firstOpen)
                {
                    CommonData.Status.Clear();
                    CommonData.Status.Add("PLEASE WAIT PROJECT UPLOADED ... 15 %");
                }


                if (map.Type == BPType.PROGRAM)
                {
                    IncludeFileOpen(map);

                    var imports = new Dictionary <string, Module>();
                    foreach (var imp in map.Imports)
                    {
                        if (!imports.ContainsKey(imp.Key))
                        {
                            imports.Add(imp.Key, imp.Value);
                        }
                    }
                    foreach (var inc in map.Includes)
                    {
                        if (Data.ContainsKey(inc.Value.OriginName))
                        {
                            foreach (var imp in Data[inc.Value.OriginName].Map.Imports)
                            {
                                if (!imports.ContainsKey(imp.Key))
                                {
                                    imports.Add(imp.Key, imp.Value);
                                }
                            }
                        }
                    }

                    map.Imports = imports;

                    ImportFileOpen(map);
                }
                else if (map.Type == BPType.MODULE)
                {
                    map.Includes.Clear();
                    var imports = new Dictionary <string, Module>();
                    foreach (var imp in map.Imports)
                    {
                        if (!imports.ContainsKey(imp.Key))
                        {
                            imports.Add(imp.Key, imp.Value);
                        }
                    }

                    map.Imports = imports;
                    ImportFileOpen(map);
                }
                else if (map.Type == BPType.INCLUDE)
                {
                    if (map.MainName != "")
                    {
                        MainFileOpen(map);
                    }

                    if (Data.ContainsKey(map.MainName))
                    {
                        var mMap    = Data[map.MainName].Map;
                        var tmpName = name.ToLower();

                        if (mMap.Includes.ContainsKey(tmpName))
                        {
                            var includes = new Dictionary <string, Include>();

                            foreach (var inc in mMap.Includes)
                            {
                                if (!includes.ContainsKey(inc.Key) && inc.Key != tmpName)
                                {
                                    includes.Add(inc.Key, inc.Value);
                                }
                            }

                            map.Includes = includes;

                            IncludeFileOpen(map);


                            var imports = new Dictionary <string, Module>();

                            foreach (var imp in mMap.Imports)
                            {
                                if (!imports.ContainsKey(imp.Key))
                                {
                                    imports.Add(imp.Key, imp.Value);
                                }
                            }

                            foreach (var imp in map.Imports)
                            {
                                if (!imports.ContainsKey(imp.Key))
                                {
                                    imports.Add(imp.Key, imp.Value);
                                }
                            }

                            foreach (var inc in map.Includes)
                            {
                                if (Data.ContainsKey(inc.Value.OriginName))
                                {
                                    foreach (var imp in Data[inc.Value.OriginName].Map.Imports)
                                    {
                                        if (!imports.ContainsKey(imp.Key))
                                        {
                                            imports.Add(imp.Key, imp.Value);
                                        }
                                    }
                                }
                            }

                            map.Imports = imports;

                            ImportFileOpen(map);

                            /*
                             * foreach (var v in mMap.Variables)
                             * {
                             *  map.Variables.Add(v);
                             * }
                             *
                             * foreach (var s in mMap.Subroutines)
                             * {
                             *  map.Subroutines.Add(s);
                             * }
                             *
                             * foreach (var l in mMap.Labels)
                             * {
                             *  map.Labels.Add(l);
                             * }
                             */

                            map.Variables.AddRange(mMap.Variables);
                            map.Subroutines.AddRange(mMap.Subroutines);
                            map.Labels.AddRange(mMap.Labels);
                        }
                    }
                }

                if (firstOpen)
                {
                    CommonData.Status.Clear();
                    CommonData.Status.Add("PLEASE WAIT PROJECT UPLOADED ... 95 %");
                }

                pData.Map     = map;
                prjData[name] = pData;
                if (Data.ContainsKey(name))
                {
                    Data[name] = pData;
                }
                else
                {
                    Data.Add(name, pData);
                }

                //stopWatch.Stop();
                //var timer = stopWatch.ElapsedMilliseconds / 1000.0;
                //CommonData.Status.Add("Parser work time: " + timer.ToString() + " sec.");

                /*
                 * CommonData.Status.Add("===============================================");
                 * if (Data.ContainsKey(Data[name].Map.MainName))
                 *  CommonData.Status.Add("Main: 1");
                 * CommonData.Status.Add("Vars: " + Data[name].Map.Variables.Count.ToString());
                 * CommonData.Status.Add("Subs: " + Data[name].Map.Subroutines.Count.ToString());
                 * CommonData.Status.Add("Labels: " + Data[name].Map.Labels.Count.ToString());
                 * CommonData.Status.Add("Include: " + Data[name].Map.Includes.Count.ToString());
                 * CommonData.Status.Add("Import: " + Data[name].Map.Imports.Count.ToString());
                 * CommonData.Status.Add("===============================================");
                 * CommonData.Status.Add("DATA COUNT: " + Data.Count.ToString());
                 */
                if (firstOpen)
                {
                    CommonData.Status.Clear();
                    CommonData.Status.Add("PLEASE WAIT PROJECT UPLOADED ... 100 %");
                    CommonData.Status.Add("PROJECT IS LOADED AND READY.");
                    firstOpen = false;
                }
            }
        }
Esempio n. 6
0
        private static void SetVSL(string path, LineCollection lines, ProgramMap map)
        {
            var func       = false;
            var priv       = false;
            var modSummary = false;
            var start      = -1;
            var end        = -1;

            map.Map.Clear();
            map.Variables.Clear();
            map.Includes.Clear();
            map.Imports.Clear();
            map.Subroutines.Clear();

            int j = 0;

            var tmpSummary = new List <string>();

            foreach (var line in lines)
            {
                j++;
                var txt = line.Text.Trim();

                if (j == 1 && map.Type == BPType.INCLUDE)
                {
                    if (txt.IndexOf("'") == 0 && txt.IndexOf("''''") == -1)
                    {
                        var w = txt.Replace("'", "").Split(new char[] { ' ' }, System.StringSplitOptions.RemoveEmptyEntries);
                        if (w.Length == 2 && (w[0].ToLower() == "#main"))// || w[0].ToLower() == "main"))
                        {
                            map.SetMainFullPath(w[1].Replace(".bp", "") + ".bp", path);
                        }
                    }
                }

                var words = Builder.GetWords(line.Text.Trim());

                if (txt.IndexOf("''''") == 0)
                {
                    tmpSummary.Add(txt.Replace("''''", "").Trim());
                    if (j == 1)
                    {
                        modSummary = true;
                    }
                }

                else if (words.Count >= 1)
                {
                    var first    = words[0].Text.ToLower();
                    var firstToc = words[0].Token;

                    if (words.Count == 2)
                    {
                        if (first == "include")
                        {
                            var include = new Include(words[1].OriginText, path);

                            if (!map.Includes.ContainsKey(include.Name) && map.Type == BPType.PROGRAM)
                            {
                                map.Includes.Add(include.Name, include);
                            }

                            tmpSummary.Clear();
                        }
                        else if (first == "import")
                        {
                            var module = new Module(words[1].OriginText, path);

                            if (!map.Imports.ContainsKey(module.Name))
                            {
                                map.Imports.Add(module.Name, module);
                            }

                            tmpSummary.Clear();
                        }
                    }

                    if (first == "function")
                    {
                        func  = true;
                        start = line.DisplayIndex;
                        if (end == -1)
                        {
                            for (int i = start - 1; i < lines.Count; i++)
                            {
                                if (!string.IsNullOrEmpty(lines[i].Text))
                                {
                                    var text = lines[i].Text.Trim().ToLower();
                                    if (text == "endfunction")
                                    {
                                        end = lines[i].DisplayIndex;
                                        break;
                                    }
                                }

                                if (i == lines.Count - 1)
                                {
                                    end = lines[i].DisplayIndex;
                                }
                            }
                        }
                    }
                    else if (first == "endfunction")
                    {
                        func  = false;
                        start = -1;
                        end   = -1;
                        tmpSummary.Clear();
                    }
                    else if (first == "private") //&& map.Type == BPType.MODULE)
                    {
                        priv = true;
                        tmpSummary.Clear();
                    }
                    else if (txt.IndexOf("''''") == -1)
                    {
                        if (first != "number" && first != "number[]" && first != "string" && first != "string[]" && first != "sub")
                        {
                            tmpSummary.Clear();
                        }
                    }
                }
                else
                {
                    if (tmpSummary.Count > 0 && modSummary)
                    {
                        foreach (var l in tmpSummary)
                        {
                            map.Summary.Add(l);
                        }
                        modSummary = false;
                    }


                    tmpSummary.Clear();
                }

                map.Map.Add(line.DisplayIndex, func);

                foreach (var word in words)
                {
                    if (words.Count > 1 && (words[0].Text == "function" || words[0].Text == "sub") && (word.Token == Tokens.SUBNAME || word.Token == Tokens.FUNCNAME))
                    {
                        var count = GetParamCount(words);
                        var tmpF  = new Function(word.OriginText, priv, count);
                        if (tmpSummary.Count > 0)
                        {
                            tmpF.Summary.Add(line.Text.Replace(words[0].OriginText, "").Trim());// + '\n');
                            foreach (var l in tmpSummary)
                            {
                                tmpF.Summary.Add(l);
                            }
                            tmpSummary.Clear();
                        }

                        if (!map.IsContains(tmpF))
                        {
                            map.Subroutines.Add(tmpF);
                        }
                    }
                    else if (word.Token == Tokens.LABELNAME)
                    {
                        var tmpV = new Label(word.OriginText.Replace(":", ""), priv, func, start, end);
                        map.Labels.Add(tmpV);
                    }
                    else if (word.Token == Tokens.VARIABLE)
                    {
                        var tmpV = new Variable(word.OriginText, priv, func, start, end);
                        map.Variables.Add(tmpV);

                        if (tmpSummary.Count > 0)
                        {
                            var first = words[0].Text.Trim().ToLower();
                            if (first == "number" || first == "number[]" || first == "string" || first == "string[]")
                            {
                                tmpV.Summary.Add(line.Text.Replace(words[0].OriginText, "").Trim());// + '\n');
                                foreach (var l in tmpSummary)
                                {
                                    tmpV.Summary.Add(l);
                                }
                                tmpSummary.Clear();
                            }
                        }
                    }
                }
            }
        }
Esempio n. 7
0
        protected override void ParseSection(TsPacket packet, int offset, int length)
        {
            if (length < MinimumProgramMapSize)
                return;

            var i = offset;
            var buffer = packet.Buffer;

            var program_number = (buffer[i] << 8) | buffer[i + 1];
            i += 2;

            var version_number = buffer[i++];

            var current_next_indicator = 0 != (version_number & 1);

            version_number >>= 1;
            version_number &= 0x1f;

            var section_number = buffer[i++];
            var last_section_number = buffer[i++];

            if (last_section_number < section_number)
                return;

            var PCR_PID = ((uint)buffer[i] << 8) | buffer[i + 1];
            i += 2;
            PCR_PID &= 0x1fff;

            _pcrPid = PCR_PID;

            var program_info_length = (buffer[i] << 8) | buffer[i + 1];
            i += 2;
            program_info_length &= 0x0fff;

            if (i - offset + program_info_length >= length)
                return;

            TsDescriptor[] programDescriptors = null;

            if (program_info_length > 0)
            {
                //Debug.WriteLine("TsProgramMapTable.Add() program descriptor for program " + program_number);
                //TsDescriptors.DebugWrite(buffer, i, program_info_length);

                programDescriptors = _descriptorFactory.Parse(buffer, i, program_info_length).ToArray();
            }

            _newProgramDescriptors = programDescriptors;

            i += program_info_length;

            var mappingEnd = offset + length;

            while (i + 5 <= mappingEnd)
            {
                var stream_type = buffer[i++];

                var elementary_PID = ((uint)buffer[i] << 8) | buffer[i + 1];
                i += 2;

                elementary_PID &= 0x1fff;

                var ES_info_length = (buffer[i] << 8) | buffer[i + 1];
                i += 2;

                ES_info_length &= 0x0fff;

                if (i + ES_info_length > mappingEnd)
                    return;

                TsDescriptor[] streamDescriptors = null;

                if (ES_info_length > 0)
                {
                    //Debug.WriteLine("TsProgramMapTable.Add() ES descriptor for PID " + elementary_PID);
                    //TsDescriptors.DebugWrite(buffer, i, ES_info_length);

                    streamDescriptors = _descriptorFactory.Parse(buffer, i, ES_info_length).ToArray();
                }

                i += ES_info_length;

                var streamType = TsStreamType.FindStreamType(stream_type);

                var programMap = new ProgramMap
                {
                    Pid = elementary_PID,
                    StreamType = streamType,
                    StreamDescriptors = streamDescriptors
                };

                _newProgramStreams[elementary_PID] = programMap;
            }

            if (section_number == last_section_number)
                MapProgramStreams();
        }
Esempio n. 8
0
        void ClearProgram(ProgramMap program)
        {
            _decoder.UnregisterHandler(program.Pid);

            var pes = program.Stream;

            if (null != pes)
                pes.Clear();

            var remove = _programStreamMap.Remove(program.Pid);

            Debug.Assert(remove);
        }