Example #1
0
 //Загрузка списка графиков
 private void LoadGrafics()
 {
     AddEvent("Загрузка списка графиков");
     using (var rec = new DaoRec(Dir + "Grafics.accdb", "GraficsList"))
         while (rec.Read())
         {
             var code = rec.GetString("Code");
             Grafics.Add(code, new Grafic(code, rec.GetInt("Dimension"), rec.GetString("GraficType").ToGraficType()));
         }
 }
Example #2
0
        //Компиляция проекта, возвращает количество ошибок компиляции
        public string CompileProject()
        {
            //OnlyOn = true;
            CountsToZero();
            if (State == State.Project || State == State.Empty)//Если не загружены, то загружаем сигналы
            {
                string s = LoadSignals();
                if (s != "")
                {
                    return(s);
                }
            }
            else
            {
                foreach (var sig in SignalsList)
                {
                    sig.InUse         = false;
                    sig.InUseSource   = false;
                    sig.InUseReceiver = false;
                }
            }
            StartAtom(Atom.CompileProject);
            if (State == State.Closed)
            {
                AddError("Копилятор уже был закрыт");
            }
            else
            {
                try
                {
                    //Обнуления поля Expr и т.п.
                    using (var daodb = new DaoDb(_projectFile))
                    {
                        //daodb.Execute("UPDATE CalcParams SET CalcParams.Expr = Null, CalcParams.ErrMess = Null, CalcParams.UsedUnits = Null, CalcParams.CalcNumber = 0;");
                        foreach (string tab in new[] { "CalcParams", "CalcSubParams" })
                        {
                            using (var rec = new RecDao(daodb, tab))
                                while (rec.Read())
                                {
                                    rec.Put("Expr", (string)null);
                                    try { rec.Put("UsedUnits", (string)null); } catch { }
                                    rec.Put("CalcNumber", 0);
                                    rec.Put("ErrMess", (string)null);
                                    rec.Update();
                                }
                        }
                        CalcParams.Clear();
                        CalcParamsId.Clear();
                        CalcParamsAll.Clear();
                        Grafics.Clear();
                        ArchiveParams.Clear();
                        Prevs.Clear();
                        HandSignals.Clear();
                        CalcParamNumber = 0;

                        Procent = 10;
                        AddEvent("Загрузка графиков");
                        using (var rec = new RecDao(daodb, "SELECT GraficsList.Code, GraficsList.Dimension FROM GraficsList"))
                            while (rec.Read())
                            {
                                var gr = new Grafic(rec.GetString("Code"), rec.GetInt("Dimension"));
                                Grafics.Add(gr.Code, gr);
                            }

                        Procent = 15;
                        AddEvent("Загрузка параметров");
                        string spar = OnlyOn ? "WHERE (CalcOn = True) And (TaskOn = True)" : "";
                        using (var rec = new RecDao(daodb, "SELECT CalcParams.* FROM CalcParams " + spar + " ORDER BY CalcParamId"))
                            while (rec.Read())
                            {
                                new CalcParam(rec, this);
                            }

                        Procent = 25;
                        AddEvent("Загрузка подпараметров");
                        string ssub = OnlyOn ? "WHERE (CalcParams.CalcOn = True) And (CalcParams.TaskOn = True) And (CalcSubParams.CalcOn = True)" : "";
                        using (var rec = new RecDao(daodb, "SELECT CalcSubParams.* FROM CalcParams INNER JOIN CalcSubParams ON CalcParams.CalcParamId = CalcSubParams.OwnerId " + ssub))
                            while (rec.Read())
                            {
                                new CalcParam(rec, this, true);
                            }

                        Procent = 35;
                        AddEvent("Разбор выражений");
                        foreach (var cp in CalcParamsId.Values)
                        {
                            cp.Parse();
                        }

                        IsPrevAbs     = false;
                        IsLastBase    = false;
                        IsLastHour    = false;
                        IsLastDay     = false;
                        IsManyBase    = false;
                        IsManyHour    = false;
                        IsManyDay     = false;
                        IsManyMoments = false;

                        Procent = 45;
                        AddEvent("Компиляция выражений");
                        foreach (var cp in CalcParamsId.Values)
                        {
                            if (cp.Stage == CompileStage.NotStarted)
                            {
                                cp.Compile(null);
                            }

                            /*foreach (var d in cp.MethodsId.Values)
                             *  if (d.Stage == CompileStage.NotStarted)
                             *      d.Compile(null);*/
                        }

                        FindCycleLinks();

                        ErrorsCount   = 0;
                        UsedProviders = new SetS();
                        IsAbsolute    = false;
                        IsPeriodic    = false;
                        IsMoments     = false;

                        Procent = 60;
                        AddEvent("Сохранение результатов компиляции параметров");
                        using (var rec = new RecDao(daodb, "SELECT CalcParams.* FROM CalcParams " + spar + " ORDER BY CalcParamId"))
                            SaveCompile(rec, false);

                        Procent = 70;
                        AddEvent("Сохранение результатов компиляции подпараметров");
                        using (var rec = new RecDao(daodb, "SELECT CalcSubParams.* FROM CalcParams INNER JOIN CalcSubParams ON CalcParams.CalcParamId = CalcSubParams.OwnerId " + ssub + " ORDER BY CalcParams.CalcParamId;"))
                            SaveCompile(rec, true);
                    }

                    Procent = 80;
                    AddEvent("Сохранение списка используемых сигналов и графиков");
                    SaveInUse();

                    Procent = 90;
                    AddEvent("Сохранение архивных параметров");
                    SaveArchive();

                    Procent = 96;
                    AddEvent("Сохранение параметров функций Пред");
                    SavePrevs();

                    Procent = 99;
                    SaveUsedProviders();
                    using (var sys = new SysTabl(_projectFile))
                    {
                        sys.PutSubValue("CompileStatus", "LastTimeCompile", DateTime.Now.ToString());
                        sys.PutSubValue("CompileStatus", "ErrorsCount", ErrorsCount.ToString());
                    }
                }
                catch (Exception ex)
                {
                    AddError("Ошибка компилятора", ex);
                }
            }
            return(FinishAtom(State.Compiled, State.Signals, "Проект: " + _code + ";  Ошибок: " + ErrorsCount + ";" + Different.NewLine
                              + "Параметров: " + CalcParamsId.Count + "; Архивных параметров:" + ArchiveParams.Count + ";  Сигналов: " + SignalsInUseCount));
        }
Example #3
0
        //Чтение списка расчетных параметров
        private void ReadCalcParams()
        {
            CalcParamsCode.Clear();
            CalcParamsId.Clear();
            CalcSubParamsId.Clear();
            Grafics.Clear();
            AddEvent("Загрузка графиков");
            using (var db = new DaoDb(File))
            {
                try
                {
                    const string stSql =
                        "SELECT GraficsList.Code, GraficsList.Dimension, GraficsList.GraficType, GraficsValues.X1, GraficsValues.X2, GraficsValues.X3, GraficsValues.X4, GraficsValues.X5, GraficsValues.X6, GraficsValues.X7, GraficsValues.X8 " +
                        "FROM GraficsList INNER JOIN GraficsValues ON GraficsList.GraficId = GraficsValues.GraficId " +
                        "ORDER BY GraficsList.Code, GraficsValues.X8, GraficsValues.X7, GraficsValues.X6, GraficsValues.X5, GraficsValues.X4, GraficsValues.X3, GraficsValues.X2, GraficsValues.X1;";
                    using (var recg = new ReaderAdo(db, stSql))
                    {
                        //Считывание графиков
                        recg.Read();
                        while (!recg.EOF)
                        {
                            var gr = new Grafic(recg, ThreadCalc);
                            Grafics.Add(gr.Code, gr);
                        }
                    }
                }
                catch (Exception ex)
                {
                    AddError("Ошибка загрузки графика", ex);
                }
                Procent = 10;

                AddEvent("Загрузка параметров");
                try
                {
                    const string stSql = "SELECT * FROM CalcParams WHERE (TaskOn = True) AND (CalcOn = True)";
                    using (var rec = new ReaderAdo(db, stSql))
                        while (rec.Read())
                        {
                            var calc = new CalcParam(this, rec, false);
                            calc.FullCode = calc.Code;
                            CalcParamsId.Add(calc.Id, calc);
                            CalcParamsCode.Add(calc.Code, calc);
                            if (IsError)
                            {
                                return;
                            }
                        }
                }
                catch (Exception ex)
                {
                    AddError("Список расчетных параметров загружен с ошибками, необходима повторная компиляция расчета", ex);
                }
                Procent = 40;

                AddEvent("Загрузка подпараметров");
                try
                {
                    const string stSql =
                        "SELECT CalcSubParams.* FROM CalcParams INNER JOIN CalcSubParams ON CalcParams.CalcParamId = CalcSubParams.OwnerId" +
                        " WHERE (CalcParams.TaskOn=True) AND (CalcParams.CalcOn=True) AND (CalcSubParams.CalcOn=True)";
                    using (var recp = new ReaderAdo(db, stSql))
                        while (recp.Read())
                        {
                            var calc = new CalcParam(this, recp, true);
                            CalcSubParamsId.Add(calc.Id, calc);
                            calc.Owner = CalcParamsId[recp.GetInt("OwnerId")];
                            calc.Owner.Methods.Add(calc.Code, calc);
                            calc.FullCode = calc.Owner.FullCode + "." + calc.Code;
                            if (IsError)
                            {
                                return;
                            }
                        }
                }
                catch (Exception ex)
                {
                    AddError("Список расчетных параметров загружен с ошибками, необходима повторная компиляция расчета", ex);
                }
                Procent = 60;
            }

            AddEvent("Загрузка справочных таблиц");
            Tabls.Clear();
            using (var db = new DaoDb(File).ConnectDao())
                foreach (TableDef t in db.Database.TableDefs)
                {
                    if (t.Name.StartsWith("Tabl_"))
                    {
                        var tabl = new Tabl(int.Parse(t.Name.Substring(5)));
                        Tabls.Add(tabl.Num, tabl);
                        tabl.FieldsCount = 0;
                        foreach (Field f in t.Fields)
                        {
                            if (f.Name.StartsWith("Val_"))
                            {
                                int fnum = int.Parse(f.Name.Substring(4));
                                if (fnum >= tabl.FieldsCount)
                                {
                                    tabl.FieldsCount = fnum + 1;
                                }
                            }
                        }
                        TableDef st = db.Database.TableDefs["Sub" + t.Name];
                        tabl.SubFieldsCount = 0;
                        foreach (Field f in st.Fields)
                        {
                            if (f.Name.StartsWith("SubVal_"))
                            {
                                int fnum = int.Parse(f.Name.Substring(7));
                                if (fnum >= tabl.SubFieldsCount)
                                {
                                    tabl.SubFieldsCount = fnum + 1;
                                }
                            }
                        }
                    }
                }

            if (Tabls.Count > 0)
            {
                using (var db = new DaoDb(File))
                    foreach (var t in Tabls.Values)
                    {
                        using (var rect = new ReaderAdo(db, "SELECT * FROM Tabl_" + t.Num))
                            while (rect.Read())
                            {
                                new TablParam().ParamFromRec(t, rect);
                            }
                        using (var rect = new ReaderAdo(db, "SELECT * FROM SubTabl_" + t.Num))
                            while (rect.Read())
                            {
                                new TablParam().SubParamFromRec(t, rect);
                            }
                    }
            }
            Procent = 75;

            AddEvent("Разбор выражений");
            try
            {
                foreach (var cp in CalcParamsId.Values)
                {
                    if (!Start(cp.Parse))
                    {
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                ThreadCalc.AddError("Список расчетных параметров загружен с ошибками, необходима повторная компиляция расчета", ex);
            }
        }