public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            _positionSetAstNode = (PositionSetAstNode)AddChild("PositionSetAstNode", treeNode.ChildNodes[0]);
            _expressionAstNode = (ExpressionAstNode)AddChild("ExpressionAstNode", treeNode.ChildNodes[1]);
        }
 public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, Parsing.PythonOperator operation, IAnalysisSet rhs) {
     var res = AnalysisSet.Empty;
     switch (operation) {
         case PythonOperator.Add:
             foreach (var type in rhs) {
                 if (type.IsOfType(ClassInfo)) {
                     res = res.Union(ClassInfo.Instance);
                 } else {
                     res = res.Union(type.ReverseBinaryOperation(node, unit, operation, SelfSet));
                 }
             }
             break;
         case PythonOperator.Mod:
             if (_supportsMod) {
                 res = SelfSet;
             }
             break;
         case PythonOperator.Multiply:
             foreach (var type in rhs) {
                 if (type.IsOfType(ProjectState.ClassInfos[BuiltinTypeId.Int]) || type.IsOfType(ProjectState.ClassInfos[BuiltinTypeId.Long])) {
                     res = res.Union(ClassInfo.Instance);
                 } else {
                     var partialRes = ConstantInfo.NumericOp(node, this, unit, operation, rhs);
                     if (partialRes != null) {
                         res = res.Union(partialRes);
                     }
                 }
             }
             break;
     }
     return res ?? base.BinaryOperation(node, unit, operation, rhs);
 }
 internal void Parse(Parsing.Parser parser, VccCompilationPart compilationPart)
 {
     this.Parse(parser);
       this.compilationPart = compilationPart;
       this.SetContainingNodes();
       this.isInitialized = true;
 }
Example #4
0
        public override IAnalysisSet BinaryOperation(Node node, AnalysisUnit unit, Parsing.PythonOperator operation, IAnalysisSet rhs) {
            if (_original == null) {
                return base.BinaryOperation(node, unit, operation, rhs);
            }

            return _original.BinaryOperation(node, unit, operation, rhs);
        }
Example #5
0
        public override bool AssignVariable(string name, Parsing.Ast.Node location, AnalysisUnit unit, IAnalysisSet values) {
            if (base.AssignVariable(name, location, unit, values)) {
                Module.ModuleDefinition.EnqueueDependents();
                return true;
            }

            return false;
        }
Example #6
0
        private LambdaExpression _tracingLambda; // the transformed lambda used for tracing/debugging

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Constructor used to create a FunctionCode for code that's been serialized to disk.  
        /// 
        /// Code constructed this way cannot be interpreted or debugged using sys.settrace/sys.setprofile.
        /// 
        /// Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
        /// </summary>
        internal FunctionCode(TotemContext context, Delegate code, Parsing.Ast.ScopeStatement scope, int localCount)
        {
            _normalDelegate = code;
            _lambda = scope;
            _argCount = CalculateArgumentCount();

            // need to take this lock to ensure sys.settrace/sys.setprofile is not actively changing
            lock (_CodeCreateAndUpdateDelegateLock)
            {
                SetTarget(AddRecursionCheck(context, code));
            }

            RegisterFunctionCode(context);
        }
Example #7
0
 public override INamespaceSet GetMember(Parsing.Ast.Node node, Interpreter.AnalysisUnit unit, string name)
 {
     if (name == "__new__") {
         if (_new == null) {
             var func = this._type.GetMember(unit.ProjectEntry.MyScope.InterpreterContext, name);
             if (func != null) {
                 _new = new NewFunction((BuiltinFunctionInfo)unit.ProjectState.GetNamespaceFromObjects(func), ProjectState);
             }
         }
         if (_new != null) {
             return _new.SelfSet;
         }
     }
     return base.GetMember(node, unit, name);
 }
Example #8
0
        public override IAnalysisSet GetIndex(Parsing.Node node, AnalysisUnit unit, IAnalysisSet index) {
            var res = AnalysisSet.Empty;
            if (_function._curArgs != null) {
                foreach (var value in index) {
                    var numIndex = value.Value.GetNumberValue();

                    if (numIndex != null &&
                        numIndex.Value >= 0 &&
                        (numIndex.Value % 1) == 0 &&    // integer number...
                        ((int)numIndex.Value) < _function._curArgs.Args.Length) {
                        res = res.Union(_function._curArgs.Args[(int)numIndex.Value]);
                    }
                }
            }
            return res;
        }
Example #9
0
        public override void SetMember(Parsing.Node node, AnalysisUnit unit, string name, IAnalysisSet value) {
            foreach (var obj in value) {
                // function Class() {
                //     this.abc = 42;
                // }
                //   
                // Class.prototype.foo = function(fn) {
                //     var x = this.abc;
                // }
                // this now includes us.

                UserFunctionValue userFunc = obj.Value as UserFunctionValue;
                if (userFunc != null) {
                    var env = (FunctionEnvironmentRecord)(userFunc.AnalysisUnit._env);

                    env._this.AddTypes(unit, _function._instance.SelfSet, declaringScope: DeclaringModule);
                }
            }
            base.SetMember(node, unit, name, value);
        }
        public void NecessaryExecutableTest8()
        {
            var queryText = @"necessary executable load, shoot, shoot";
            var query     = Parsing.GetQuery(queryText);

            var text = @"initially alive and not loaded
						 load causes loaded
						 impossible shoot if not loaded
					     when Bob shoot causes not alive and not loaded
						 when John shoot causes not alive"                        ;

            var history = Parsing.GetHistory(text);
            var story   = new Story(history);
            var graph   = Graph.Graph.CreateGraph(story, query);

            if (query is ExecutableQueryStatement executableQuery)
            {
                var queryResult = executableQuery.Execute(graph, history);
                Assert.AreEqual(true, queryResult);
            }
        }
Example #11
0
 public void InputButton_Click(object sender, RoutedEventArgs e)
 {
     if (Parsing.SearchMistakes(InputBox.Text))
     {
         Equation = Parsing.StartParsing(InputBox.Text);
         string equationStr = string.Empty;
         for (int i = 0; i < Equation.Count; i++)
         {
             equationStr += Equation[i];
         }
         OutputResult.Text = equationStr;
         DeltaScroll       = 1;
         DeltaX            = 0;
         DeltaY            = 0;
         DrawF();
     }
     else
     {
         OutputResult.Text = "Вы допустили ошибку!";
     }
 }
Example #12
0
    /// <inheritdoc />
    public override async IAsyncEnumerable <string> Execute(string expr, Session session)
    {
        var voucherID = Parsing.Token(ref expr);
        var guids     = new List <string>();
        var guidT     = Guid.Empty;

        // ReSharper disable once AccessToModifiedClosure
        while (Parsing.Token(ref expr, true, s => Guid.TryParse(s, out guidT)) != null)
        {
            guids.Add(guidT.ToString());
        }
        Parsing.Eof(expr);

        var voucher = await session.Accountant.SelectVoucherAsync(voucherID);

        if (voucher == null)
        {
            throw new ApplicationException("找不到记账凭证");
        }

        foreach (var detail in voucher.Details.Where(static vd => vd.Title is 1601 or 1701)
        public void PossibllyExecutableTest9()
        {
            var queryText = @"possibly executable John load, shoot, John shoot";
            var query     = Parsing.GetQuery(queryText);

            var text = @"initially alive and not loaded
						 load causes loaded
						 impossible shoot if not loaded
						 impossible Bob shoot
					     observable not loaded and not alive after John shoot"                    ;

            var history = Parsing.GetHistory(text);
            var story   = new Story(history);
            var graph   = Graph.Graph.CreateGraph(story, query);

            if (query is ExecutableQueryStatement executableQuery)
            {
                var queryResult = executableQuery.Execute(graph, history);
                Assert.AreEqual(true, queryResult);
            }
        }
Example #14
0
        private static void CreateWorkbookForModule(string modulePath, string workbookPath)
        {
            var tables = Parsing.ParseTables(modulePath);

            File.Delete(workbookPath);

            var file = new FileInfo(workbookPath);

            using (var package = new ExcelPackage(file))
            {
                foreach (var table in tables)
                {
                    var worksheet     = package.Workbook.Worksheets.Add(table.Code);
                    var endCoordinate = table.WriteToWorksheet(worksheet, new ExcelCoordinate(1, 1));
                    worksheet.Pretty();
                }

                package.Save();
            }
            Console.WriteLine(file.FullName);
        }
Example #15
0
        public static void FillUserParamsFromString(string theString, string key, UnitOfMeasurementConverters converter,
                                                    Enum theUnit)
        {
            var tbValue = double.NaN;
            var ucKey   = key.ToUpper();

            if (Parsing.TryParseDouble(theString, out tbValue))
            {
                double fieldMinValue = double.NegativeInfinity, fieldMaxValue = double.PositiveInfinity;
                if (QraStateContainer.Instance.IsItemInDatabase(ucKey))
                {
                    fieldMinValue = QraStateContainer.Instance.GetStateDefinedValueObject(ucKey).MinValue;
                    fieldMaxValue = QraStateContainer.Instance.GetStateDefinedValueObject(ucKey).MaxValue;
                }

                QraStateContainer.Instance.Parameters[ucKey] = new NdConvertibleValue(converter, theUnit,
                                                                                      new double[1] {
                    tbValue
                }, fieldMinValue, fieldMaxValue);
            }
        }
Example #16
0
        private void readCustomSampleBanks(string str, SampleBankInfo bankInfo)
        {
            if (string.IsNullOrEmpty(str))
            {
                return;
            }

            string[] split = str.Split(':');

            var bank    = (LegacySampleBank)Parsing.ParseInt(split[0]);
            var addbank = (LegacySampleBank)Parsing.ParseInt(split[1]);

            string stringBank = bank.ToString().ToLowerInvariant();

            if (stringBank == @"none")
            {
                stringBank = null;
            }
            string stringAddBank = addbank.ToString().ToLowerInvariant();

            if (stringAddBank == @"none")
            {
                stringAddBank = null;
            }

            bankInfo.Normal = stringBank;
            bankInfo.Add    = string.IsNullOrEmpty(stringAddBank) ? stringBank : stringAddBank;

            if (split.Length > 2)
            {
                bankInfo.CustomSampleBank = Parsing.ParseInt(split[2]);
            }

            if (split.Length > 3)
            {
                bankInfo.Volume = Math.Max(0, Parsing.ParseInt(split[3]));
            }

            bankInfo.Filename = split.Length > 4 ? split[4] : null;
        }
Example #17
0
        public void ImportModelFileSingleModelObject(string _, string modelFilePath, string expectedDtmi, bool strict)
        {
            string qualifiedModelFilePath = Path.Combine(TestHelpers.TestLocalModelRepository, modelFilePath);
            string strictSwitch           = strict ? "--strict" : "";

            string targetRepo = $"--local-repo \"{testImportRepo.FullName}\"";

            (int returnCode, string standardOut, string standardError) =
                ClientInvokator.Invoke($"import --model-file \"{qualifiedModelFilePath}\" {targetRepo} {strictSwitch}");

            Assert.AreEqual(Handlers.ReturnCodes.Success, returnCode);
            Assert.False(standardError.Contains("Error:"));

            Assert.True(standardError.Contains(Outputs.StandardHeader));
            Assert.True(standardOut.Contains("- Validating models conform to DTDL..."));
            Assert.True(standardOut.Contains($"- Importing model \"{expectedDtmi}\"..."));

            Parsing parsing = new Parsing(null);

            FileInfo modelFile = new FileInfo(Path.GetFullPath(testImportRepo.FullName + "/" + modelFilePath));

            Assert.True(modelFile.Exists);
            DateTime lastWriteTimeUtc = modelFile.LastWriteTimeUtc;

            Assert.AreEqual(expectedDtmi, parsing.GetRootId(modelFile));

            if (strict)
            {
                Assert.True(standardOut.Contains("- Ensuring DTMIs namespace conformance for model"));
            }

            // Import the same model to ensure its skipped.
            (returnCode, standardOut, _) =
                ClientInvokator.Invoke($"import --model-file \"{qualifiedModelFilePath}\" {targetRepo} {strictSwitch}");

            Assert.AreEqual(Handlers.ReturnCodes.Success, returnCode);
            modelFile = new FileInfo(Path.GetFullPath(testImportRepo.FullName + "/" + modelFilePath));
            Assert.AreEqual(lastWriteTimeUtc, modelFile.LastWriteTimeUtc);
            Assert.True(standardOut.Contains($"Skipping \"{expectedDtmi}\". Model file already exists in repository."));
        }
Example #18
0
        public static void UnitlessTextBoxValueChanged(TextBox sender, ref NdConvertibleValue valueObj)
        {
            var testValue = double.NaN;

            if (Parsing.TryParseDouble(sender.Text, out testValue))
            {
                var newValue = new double[1];
                newValue[0] = testValue;
                valueObj.SetValue(UnitlessUnit.Unitless.ToString(), newValue);
                if (sender.ForeColor != Color.Black)
                {
                    sender.ForeColor = Color.Black;
                }
            }
            else
            {
                if (sender.ForeColor != Color.Red)
                {
                    sender.ForeColor = Color.Red;
                }
            }
        }
        public void PossiblyExecutableTest12()
        {
            var queryText = @"possibly executable load, John shoot, shoot";
            var query     = Parsing.GetQuery(queryText);

            var text = @"initially alive and not loaded
						 when Bob load causes loaded
						 impossible shoot if not loaded
						 impossible Eric shoot
						 not loaded after Bob shoot
						 when John shoot releases loaded"                        ;

            var history = Parsing.GetHistory(text);
            var story   = new Story(history);
            var graph   = Graph.Graph.CreateGraph(story, query);

            if (query is ExecutableQueryStatement executableQuery)
            {
                var queryResult = executableQuery.Execute(graph, history);
                Assert.AreEqual(true, queryResult);
            }
        }
Example #20
0
 /// <summary>Converts the string to a BIC.
 /// A return value indicates whether the conversion succeeded.
 /// </summary>
 /// <param name="s">
 /// A string containing a BIC to convert.
 /// </param>
 /// <param name="formatProvider">
 /// The specified format provider.
 /// </param>
 /// <param name="result">
 /// The result of the parsing.
 /// </param>
 /// <returns>
 /// True if the string was converted successfully, otherwise false.
 /// </returns>
 public static bool TryParse(string s, IFormatProvider formatProvider, out BankIdentifierCode result)
 {
     result = BankIdentifierCode.Empty;
     if (string.IsNullOrEmpty(s))
     {
         return(true);
     }
     if (Qowaiv.Unknown.IsUnknown(s, formatProvider as CultureInfo))
     {
         result = BankIdentifierCode.Unknown;
         return(true);
     }
     if (IsValid(s, formatProvider))
     {
         result = new BankIdentifierCode()
         {
             m_Value = Parsing.ClearSpacingAndMarkupToUpper(s)
         };
         return(true);
     }
     return(false);
 }
Example #21
0
        private string FindCommonLetters(string input)
        {
            string boxId1     = string.Empty;
            string boxId2     = string.Empty;
            bool   matchFound = false;

            List <string> boxIds = Parsing.SplitOnNewLine(input).ToList();

            do
            {
                boxId1 = boxIds[0];
                boxIds.RemoveAt(0);
                boxId2 = boxIds.FirstOrDefault(id2 => DoTwoBoxIdsDifferByOnlyOneChar(boxId1, id2) == true);

                if (boxId2 != null)
                {
                    matchFound = true;
                }
            } while (!matchFound);

            return(RemoveUncommonLetterFromTwoBoxIds(boxId1, boxId2));
        }
Example #22
0
        public void C_101_00_hypercubes()
        {
            var tableCode = "c_101.00";

            var metFile = $"{MetricPath}/met.xsd";
            var metrics = Parsing.ParseNames(metFile);

            var dimFile    = $"{DimensionPath}/dim.xsd";
            var dimensions = Parsing.ParseNames(dimFile);

            var expFile    = $"{DomainPath}/exp.xsd";
            var typFile    = $"{DomainPath}/typ.xsd";
            var domains    = Parsing.ParseNames(expFile);
            var typDomains = Parsing.ParseNames(typFile);

            var typedDimensions = Parsing.ParseTypedDimensions(dimFile);

            typDomains.ToList().ForEach(x => domains[x.Key] = x.Value);
            var cubes = Parsing.ParseHypercubes(TaxonomyPath, tableCode, metrics, dimensions, domains, typedDimensions);

            Helper.DumpHypercubes(cubes);
        }
Example #23
0
        private double[] GetCdfInputValuesFromGrid(DataGridViewRow currentRow, out bool allValuesGood)
        {
            allValuesGood = true;

            var result = new double[currentRow.Cells.Count - 1];

            for (var colIndex = 1; colIndex < currentRow.Cells.Count; colIndex++)
            {
                var thevalue = double.NaN;
                var strValue = currentRow.Cells[colIndex].Value.ToString();
                if (Parsing.TryParseDouble(strValue, out thevalue))
                {
                    result[colIndex - 1] = thevalue;
                }
                else
                {
                    allValuesGood = false;
                }
            }

            return(result);
        }
Example #24
0
        protected override void beforeEach()
        {
            _template            = new Template("b/a.spark", "b", "c");
            _template.Descriptor = _viewDescriptor = new SparkDescriptor(_template)
            {
                ViewModel = typeof(ProductModel)
            };

            _parsing = new Parsing
            {
                Master        = "application",
                ViewModelType = _viewDescriptor.ViewModel.FullName
            };

            _request = new AttachRequest <ITemplate>
            {
                Template = _template,
                Logger   = MockFor <ITemplateLogger>()
            };

            MockFor <IParsingRegistrations <ITemplate> >().Expect(x => x.ParsingFor(_template)).Return(_parsing);
        }
Example #25
0
        public object Part1(string input)
        {
            var particles = input.Lines()
                            .Select(Parsing.PatternParser <string, string, string, Particle>(
                                        @"p=<(-?\d+,-?\d+,-?\d+)>, v=<(-?\d+,-?\d+,-?\d+)>, a=<(-?\d+,-?\d+,-?\d+)>",
                                        static (p, v, a) => new Particle(vectorParser(p), vectorParser(v), vectorParser(a))
                                        ))
                            .ToArray();

            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < particles.Length; j++)
                {
                    var particle = particles[j];
                    particles[j] = particle with {
                        pos = particle.pos + particle.vel,
                        vel = particle.vel + particle.acc,
                    };
                }
            }

            return(particles.Select(static (p, i) => (p, i)).Aggregate(static (a, b) => Vector3.Zero.ManhattanDistance(a.p.pos) < Vector3.Zero.ManhattanDistance(b.p.pos) ? a : b).i);
Example #26
0
        public static double[] ExtractArrayFromTextbox(TextBox tb)
        {
            var sResult = tb.Text.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            var result  = new double[sResult.Length];

            for (var index = 0; index < result.Length; index++)
            {
                var parsedValue        = double.NaN;
                var successfullyParsed = Parsing.TryParseDouble(sResult[index], out parsedValue);

                if (successfullyParsed)
                {
                    result[index] = parsedValue;
                }
                else
                {
                    result[index] = double.NaN;
                }
            }

            return(result);
        }
Example #27
0
        protected override List <IChapter> ParseChapterObjects(string html)
        {
            Log.Trace("Entering ParseChapterObjects");

            if (IsChapter)
            {
                Log.Debug("The supplied URI is for a chapter.");

                var chapter = new List <IChapter>();
                chapter.Add(new ChapterDistill(SeriesTitle, Address, HostData, Log));

                return(chapter);
            }
            else
            {
                string path      = HostData.Chapters.Path;
                string pathValue = HostData.Chapters.Value;

                var details = new ChapterParseDetails(
                    path,
                    pathValue,
                    (element, parseDetails) =>
                {
                    return(GenericParseAction <IChapter>
                           (
                               element,
                               parseDetails,
                               HostData.Chapters,
                               (chapterUri) => ChapterParseActionUriSupplied(new DMR11.Core.Net.ValidatedUri(chapterUri), element, parseDetails, html)
                           ));
                },
                    Log,
                    HostVariables
                    );

                return(Parsing.ParseChapters(html, details));
            }
        }
Example #28
0
        private double GetDoubleCellValue(object value)
        {
            var result = double.NaN;

            if (value == null)
            {
                result = 0D;
            }
            else
            {
                var valueType  = value.GetType();
                var doubleType = 0D.GetType();
                var stringType = "".GetType();

                if (valueType == stringType)
                {
                    var strValue = (string)value;
                    if (strValue == null)
                    {
                        result = 0D;
                    }
                    else
                    {
                        result = Parsing.ParseDouble(strValue);
                    }
                }
                else if (valueType == doubleType)
                {
                    result = (double)value;
                }
                else
                {
                    throw new Exception("Type of " + value.GetType().Name + " is unrecognized.");
                }
            }

            return(result);
        }
        public static string InputLoopNumber(string minimum, string maximum, string type, IEnumerable <Person> resultList)
        {
            var min = Parsing.StringToInt(minimum)[0];
            var max = Parsing.StringToInt(maximum)[0];
            var ok  = false;

            while (true)
            {
                if (type.Equals("ID number") && ok == true)
                {
                    PrintResultList(resultList);
                }
                Console.WriteLine("Enter with the " + type + ": ");
                var inputNumber = Console.ReadLine().Trim();
                if (!String.IsNullOrEmpty(inputNumber))
                {
                    var converted = Parsing.StringToInt(inputNumber);
                    if (converted != null && (converted[0] >= min && converted[0] <= max))
                    {
                        return(converted[0].ToString());
                    }
                    else
                    {
                        ok = true;
                        Console.WriteLine("\nInvalid number.\n" +
                                          "It must be an interger number between " +
                                          (Parsing.StringToInt(minimum)[0]).ToString() +
                                          " and " + (Parsing.StringToInt(maximum)[0]).ToString() +
                                          ". \nTry again.");
                    }
                }
                else
                {
                    Console.WriteLine("\nError: Empty field.\nTry again.");
                }
                ClearScreen(false);
            }
        }
        private void readLegacyReplay(Replay replay, StreamReader reader)
        {
            float       lastTime     = 0;
            ReplayFrame currentFrame = null;

            foreach (var l in reader.ReadToEnd().Split(','))
            {
                var split = l.Split('|');

                if (split.Length < 4)
                {
                    continue;
                }

                if (split[0] == "-12345")
                {
                    // Todo: The seed is provided in split[3], which we'll need to use at some point
                    continue;
                }

                var diff = Parsing.ParseFloat(split[0]);
                lastTime += diff;

                // Todo: At some point we probably want to rewind and play back the negative-time frames
                // but for now we'll achieve equal playback to stable by skipping negative frames
                if (diff < 0)
                {
                    continue;
                }

                currentFrame = convertFrame(new LegacyReplayFrame(lastTime,
                                                                  Parsing.ParseFloat(split[1], Parsing.MAX_COORDINATE_VALUE),
                                                                  Parsing.ParseFloat(split[2], Parsing.MAX_COORDINATE_VALUE),
                                                                  (ReplayButtonState)Parsing.ParseInt(split[3])), currentFrame);

                replay.Frames.Add(currentFrame);
            }
        }
Example #31
0
        // <viewdata model="FubuMVC.Diagnostics.DashboardModel" />
        public Parsing Read()
        {
            var parsing = new Parsing();

            using (var reader = new StreamReader(_file))
            {
                string line;
                // Read and display lines from the file until the end of
                // the file is reached.
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.Contains("<viewdata"))
                    {
                        var document = new XmlDocument();
                        document.LoadXml(line.Trim());
                        parsing.ViewModelType = document.DocumentElement.GetAttribute("model");

                    }
                }
            }

            return parsing;
        }
Example #32
0
        /// <summary>
        /// Получить более менее команд
        /// </summary>
        /// <returns></returns>
        public async Task <MatchModels> GetPageCoefficient(bool fds = true, bool bm = true)
        {
            List <AllTotalModels> coeffBM = null, coeffFDS = null;

            var coeffPage = await new MatchInfomation().GetPageCoefficient(this);

            if (fds)
            {
                coeffFDS = Parsing.CoeffFDS(coeffPage);
            }
            if (bm)
            {
                coeffBM = Parsing.CoeffBM(coeffPage);
            }

            this.Coefficient = new CoefficientsModels()
            {
                BM  = coeffBM,
                FDS = coeffFDS,
            };

            return(this);
        }
Example #33
0
        /// <summary>Converts the string to a currency.
        /// A return value indicates whether the conversion succeeded.
        /// </summary>
        /// <param name="s">
        /// A string containing a currency to convert.
        /// </param>
        /// <param name="formatProvider">
        /// The specified format provider.
        /// </param>
        /// <param name="result">
        /// The result of the parsing.
        /// </param>
        /// <returns>
        /// True if the string was converted successfully, otherwise false.
        /// </returns>
        public static bool TryParse(string s, IFormatProvider formatProvider, out Currency result)
        {
            result = Empty;
            if (string.IsNullOrEmpty(s))
            {
                return(true);
            }
            var culture = formatProvider as CultureInfo ?? CultureInfo.InvariantCulture;

            if (Qowaiv.Unknown.IsUnknown(s, culture) || s == Unknown.Symbol)
            {
                result = Unknown;
                return(true);
            }
            AddCulture(culture);

            var    str = Parsing.ToUnified(s);
            string val;

            if (Parsings[culture].TryGetValue(str, out val) || Parsings[CultureInfo.InvariantCulture].TryGetValue(str, out val))
            {
                result = new Currency()
                {
                    m_Value = val
                };
                return(true);
            }
            foreach (var currency in AllCurrencies.Where(c => !string.IsNullOrEmpty(c.Symbol)))
            {
                if (currency.Symbol == str)
                {
                    result = currency;
                    return(true);
                }
            }
            return(false);
        }
Example #34
0
    /// <inheritdoc />
    public override async IAsyncEnumerable<string> Execute(string expr, Session session)
    {
        var remark = Parsing.Token(ref expr);
        var rate = Parsing.DoubleF(ref expr) / 10000D;
        var all = Parsing.Optional(ref expr, "all");
        var endDate = !all ? Parsing.UniqueTime(ref expr, session.Client) : null;
        Parsing.Eof(expr);

        var loans = (await session.Accountant.RunGroupedQueryAsync($"({MajorFilter()})-\"\" ``rtcC")).Items
            .Cast<ISubtotalRemark>()
            .ToList();
        var rmkObj =
            loans.Single(
                b =>
                    b.Remark?.StartsWith(remark, StringComparison.InvariantCultureIgnoreCase) == true &&
                    !b.Remark.EndsWith("-利息", StringComparison.Ordinal));
        var titleObj = rmkObj.Items.Cast<ISubtotalTitle>().Single();
        var cntObj = titleObj.Items.Cast<ISubtotalContent>().Single();
        var title = titleObj.Title!.Value;
        var content = cntObj.Content;
        var rmk = rmkObj.Remark;
        var currency = cntObj.Items.Cast<ISubtotalCurrency>().Single().Currency;
        var info = new LoanInfo
            {
                Currency = currency,
                Title = title,
                Content = content,
                Remark = rmk,
                Rate = rate,
            };

        await using var vir = session.Accountant.Virtualize();
        if (!all && !endDate.HasValue ||
            endDate.HasValue)
        {
            var lastD = (await session.Accountant.RunVoucherQueryAsync(info.QueryInterest())
                    .OrderByDescending(static v => v.Date, new DateComparer())
Example #35
0
        public bool SaveData(Dictionary <string, List <StringDictionary> > data)
        {
            var parsing = new Parsing()
            {
                Date = DateTime.UtcNow
            };                                                      // номер считать с лог файла
            var httpResponce = new HttpResponce();

            T _tag;
            A _attr;

            List <StringDictionary> attrs;

            foreach (var tags in data)
            {
                _tag = new Tag {
                    Name = tags.Key, Parsing = parsing
                } as T;

                _tags.Create(_tag);

                attrs = tags.Value;

                foreach (var attribute in attrs)
                {
                    foreach (var attr in attribute.Keys)
                    {
                        _attr = new TagAttribute()
                        {
                            Name = attr.ToString(), Value = attribute[attr.ToString()], Tag = _tag
                        } as A;
                        _attrs.Create(_attr);
                    }
                }
            }
            return(true);
        }
        /// <summary>
        ///     解析记账凭证表达式
        /// </summary>
        /// <param name="expr">表达式</param>
        /// <returns>记账凭证</returns>
        private Voucher GetVoucher(ref string expr)
        {
            Parsing.TrimStartComment(ref expr);
            var id = Parsing.Quoted(ref expr, '^');
            Parsing.TrimStartComment(ref expr);
            DateTime? date = ClientDateTime.Today;
            try
            {
                date = ParsingF.UniqueTime(ref expr);
            }
            catch (Exception)
            {
                // ignore
            }

            Parsing.TrimStartComment(ref expr);
            var remark = Parsing.Quoted(ref expr, '%');
            Parsing.TrimStartComment(ref expr);
            var typeT = VoucherType.Ordinary;
            var type = Parsing.Token(ref expr, false, t => TryParse(t, out typeT)) != null ? (VoucherType?)typeT : null;
            Parsing.TrimStartComment(ref expr);

            var lst = new List<VoucherDetail>();
            VoucherDetail d;
            while ((d = ParseVoucherDetail(ref expr)) != null)
                lst.Add(d);

            return new Voucher
                {
                    ID = id,
                    Remark = remark,
                    Type = type,
                    Date = date,
                    Details = lst
                };
        }
        /// <inheritdoc />
        public Voucher ParseVoucher(string expr)
        {
            if (!expr.StartsWith(TheToken, StringComparison.Ordinal))
            {
                throw new FormatException("格式错误");
            }

            expr = expr.Substring(TheToken.Length);
            if (ParsingF.Token(ref expr, false, s => s == "!") == null)
            {
                throw new NotImplementedException();
            }

            var v = GetVoucher(ref expr);

            Parsing.TrimStartComment(ref expr);
            if (Parsing.Token(ref expr, false) != "}")
            {
                throw new FormatException("格式错误");
            }

            Parsing.Eof(expr);
            return(v);
        }
        protected virtual void Watcher_Changed(object sender, FileSystemEventArgs e)
        {
            List <string> lines = new List <string>();

            for (int i = 0; i != 3; ++i)
            {
                try
                {
                    Thread.Sleep(100);
                    var file = new FileInfo(FilePath);
                    if (!file.Exists || file.Name != Defaults.ConfgFileName)
                    {
                        return;
                    }

                    lines = File.ReadAllLines(FilePath).ToList();
                    break;
                }
                catch (IOException)
                {
                }
            }

            if (lines.Count == 0)
            {
                return;
            }

            var triplets = Parsing.ParseLines(lines);

            if (!triplets.Equals(m_Triplets))
            {
                m_Triplets = triplets;
                Changed?.Invoke();
            }
        }
Example #39
0
        /// <summary>
        /// Try to add user to Online List, if already exists, find him and return
        /// </summary>
        /// <param name="chatLine">Full chat line</param>
        /// <returns>Sender user</returns>
        public User JoinUser(string chatLine)
        {
            string username = Parsing.ParseUsername(chatLine);
            long   userId   = Parsing.ParseUserId(chatLine);

            if (!OnlineUsers.Any(x => x.Username == username))
            { // User is not in the list
                var newUser = new User(username)
                {
                    ID = userId
                };

                newUser = _botDataManager.LoadUserData(newUser);
                OnlineUsers.Add(newUser);

                OnUserJoined?.Invoke(this, new OnUserArgs {
                    User = newUser
                });
                _logger.LogInformation("[JOIN] {name} joined the broadcast!", username);
                return(newUser);
            }

            return(FindOnlineUser(username));
        }
Example #40
0
        private async Task GetStationName()
        {
            Parsing parsing = new Parsing();

            if (StationEntry.IsVisible == true)     // Se al nome è associata una sola stazione
            {
                stationItem.StationName = await parsing.GetStationNameAsync("http://mobile.my-link.it/mylink/mobile/stazione", "stazione", StationEntry.Text.Trim());

                if (stationItem.StationName != "Cerca Treno Per Stazione")
                {
                    await Navigation.PushAsync(new StationPage(stationItem.StationName.Substring(13)));
                }
                else
                {
                    await GetMultipleStations();
                }
            }
            else    // Se al nome sono associate più stazioni
            {
                stationItem.StationName = await parsing.GetStationNameAsync("http://mobile.my-link.it/mylink/mobile/stazione", "codiceStazione", stationId[StationPicker.SelectedIndex]);

                await Navigation.PushAsync(new StationPage(stationId[StationPicker.SelectedIndex], StationPicker.SelectedItem.ToString()));
            }
        }
 private void ParserState_ModuleStateChanged(object sender, Parsing.ParseProgressEventArgs e)
 {
     // todo: figure out a way to handle error state.
     // the problem is that the _projects collection might not contain our failing module yet.
 }
Example #42
0
 //^ requires token == Token.Void || token == Token.Char || token == Token.Short || token == Token.Int || token == Token.Int8 || token == Token.Int16 ||
 //^    token == Token.Int32 || token == Token.Int64 || token == Token.Long || token == Token.Float || token == Token.Double ||
 //^    token == Token.Signed || token == Token.Unsigned || token == Token.Bool;
 public PrimitiveTypeSpecifier(Parsing.Token token, ISourceLocation sourceLocation)
     : base(sourceLocation)
 {
     this.Token = token;
 }
Example #43
0
 public override IAnalysisSet UnaryOperation(Node node, AnalysisUnit unit, Parsing.PythonOperator operation) {
     if (_original == null) {
         return AnalysisSet.Empty;
     }
     return _original.UnaryOperation(node, unit, operation);
 }
        /// <summary>
        /// Calculate the duration of the selected title and chapters
        /// </summary>
        public TimeSpan calculateDuration(string chapter_start, string chapter_end, Parsing.Title selectedTitle)
        {
            TimeSpan Duration = TimeSpan.FromSeconds(0.0);

            // Get the durations between the 2 chapter points and add them together.
            if (chapter_start != "Auto" && chapter_end != "Auto")
            {
                int start_chapter, end_chapter = 0;
                int.TryParse(chapter_start, out start_chapter);
                int.TryParse(chapter_end, out end_chapter);

                int position = start_chapter - 1;

                if (start_chapter <= end_chapter)
                {
                    if (end_chapter > selectedTitle.Chapters.Count)
                        end_chapter = selectedTitle.Chapters.Count;

                    while (position != end_chapter)
                    {
                        TimeSpan dur = selectedTitle.Chapters[position].Duration;
                        Duration = Duration + dur;
                        position++;
                    }
                }
            }
            return Duration;
        }
        /// <summary>
        /// Calculate the non-anamorphic resoltuion of the source
        /// </summary>
        /// <param name="width"></param>
        /// <returns></returns>
        public int cacluateNonAnamorphicHeight(int width, decimal top, decimal bottom, decimal left, decimal right, Parsing.Title selectedTitle)
        {
            float aspect = selectedTitle.AspectRatio;
            int aw = 0;
            int ah = 0;
            if (aspect.ToString() == "1.78")
            {
                aw = 16;
                ah = 9;
            }
            else if (aspect.ToString() == "1.33")
            {
                aw = 4;
                ah = 3;
            }

            if (aw != 0)
            {
                double a = width * selectedTitle.Resolution.Width * ah * (selectedTitle.Resolution.Height - (double)top - (double)bottom);
                double b = selectedTitle.Resolution.Height * aw * (selectedTitle.Resolution.Width - (double)left - (double)right);

                double y = a / b;

                // If it's not Mod 16, make it mod 16
                if ((y % 16) != 0)
                {
                    double mod16 = y % 16;
                    if (mod16 >= 8)
                    {
                        mod16 = 16 - mod16;
                        y = y + mod16;
                    }
                    else
                    {
                        y = y - mod16;
                    }
                }

                //16 * (421 / 16)
                //double z = ( 16 * (( y + 8 ) / 16 ) );
                int x = int.Parse(y.ToString());
                return x;
            }
            return 0;
        }
Example #46
0
 public FunctionSpecifier(Parsing.Token token, ISourceLocation sourceLocation)
     : base(sourceLocation)
 {
     this.Token = token;
 }
Example #47
0
 public RunnableScriptCode(Parsing.Ast.TotemAst ast)
     : base(ast.SourceUnit)
 {
     _ast = ast;
 }
 public IdentifierReference(Parsing.Symbols.IdentifierReference reference)
 {
     _reference = reference;
 }
Example #49
0
 public override INamespaceSet ReverseBinaryOperation(Node node, AnalysisUnit unit, Parsing.JOperator operation, INamespaceSet rhs)
 {
     return _original.ReverseBinaryOperation(node, unit, operation, rhs);
 }
Example #50
0
        /// <summary>
        /// Constructor to create a FunctionCode at runtime.
        /// 
        /// Code constructed this way supports both being interpreted and debugged.  When necessary the code will
        /// be re-compiled or re-interpreted for that specific purpose.
        /// 
        /// Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
        /// 
        /// the initial delegate provided here should NOT be the actual code.  It should always be a delegate which updates our Target lazily.
        /// </summary>
        internal FunctionCode(TotemContext context, Delegate initialDelegate, Parsing.Ast.ScopeStatement scope, bool? tracing, bool register)
        {
            _lambda = scope;
            Target = LightThrowTarget = initialDelegate;
            _localCount = scope.Variables == null ? 0 : scope.Variables.Count;
            _argCount = CalculateArgumentCount();
            if (tracing.HasValue)
            {
                if (tracing.Value)
                {
                    _tracingDelegate = initialDelegate;
                }
                else
                {
                    _normalDelegate = initialDelegate;
                }
            }

            if (register)
            {
                RegisterFunctionCode(context);
            }
        }
 public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
     _positionSetName = (IdentifierNode)treeNode.ChildNodes[0].AstNode;
 }
Example #52
0
 public StorageClassSpecifier(Parsing.Token token, ISourceLocation sourceLocation)
     : base(sourceLocation)
 {
     this.Token = token;
 }
 public GruntfileAnalysisUnit(Parsing.JsAst tree, ModuleEnvironmentRecord environment)
     : base(tree, environment) {
 }
 public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
     _name = (IdentifierNode) AddChild("name", treeNode.ChildNodes[0]);
 }
 public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
     Variable = (ExpressionAstNode) AddChild("variable",treeNode.ChildNodes[0]);
 }
        public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);
            _setName = treeNode.ChildNodes[0].FindTokenAndGetText();

        }
Example #57
0
 public override INamespaceSet UnaryOperation(Node node, AnalysisUnit unit, Parsing.JOperator operation)
 {
     return _original.UnaryOperation(node, unit, operation);
 }
 //^ ensures this.members != null;
 //^ invariant isInitialized ==> this.members != null;
 private void Parse(Parsing.Parser parser)
 {
     List<INamespaceDeclarationMember> members = this.members = new List<INamespaceDeclarationMember>();
       parser.ParseCompilationUnit(this.CompilationPart.GlobalDeclarationContainer, members);
       members.TrimExcess();
       //^ assume this.members != null;
 }
 public override void Init(Parsing.ParsingContext context, Parsing.ParseTreeNode treeNode)
 {
     base.Init(context, treeNode);
     _property = treeNode.ChildNodes[0].AstNode as IdentifierNode;
     _variable = treeNode.ChildNodes[1].AstNode as VariableAstNode;
 }
Example #60
0
 public TypeQualifier(Parsing.Token token, ISourceLocation sourceLocation)
     : base(sourceLocation)
 {
     this.Token = token;
 }