Exemplo n.º 1
0
 protected BindAttributeBase(BindScope bindingScope, ConditionSource conditionSource, ConditionComparer conditionComparer, object conditionTarget)
     : this(bindingScope)
 {
     ConditionSource   = conditionSource;
     ConditionComparer = conditionComparer;
     ConditionTarget   = conditionTarget;
 }
Exemplo n.º 2
0
        public override int Compare(Account left, Account right)
        {
            if (left == null)
            {
                throw new ArgumentNullException("left");
            }

            if (right == null)
            {
                throw new ArgumentNullException("right");
            }

            AccountXData lXData = left.XData;

            if (!lXData.SortCalc)
            {
                BindScope boundScope = new BindScope(SortOrder.Context, left);
                FindSortValues(lXData.SortValues, boundScope);
                lXData.SortCalc = true;
            }

            AccountXData rXData = right.XData;

            if (!rXData.SortCalc)
            {
                BindScope boundScope = new BindScope(SortOrder.Context, right);
                FindSortValues(rXData.SortValues, boundScope);
                rXData.SortCalc = true;
            }

            return(-SortValueIsLessThan(lXData.SortValues, rXData.SortValues)); // [DM] Invert result because it is used as IComparer output that requires opposite meaning
        }
Exemplo n.º 3
0
 protected BindAttributeBase(BindScope bindingScope, ConditionSource conditionSource, ConditionComparer conditionComparer, object conditionTarget)
     : this(bindingScope)
 {
     ConditionSource = conditionSource;
     ConditionComparer = conditionComparer;
     ConditionTarget = conditionTarget;
 }
Exemplo n.º 4
0
        public override void Flush()
        {
            StringBuilder sb = new StringBuilder();

            if (Report.DisplayHandler.Handled)
            {
                Logger.Current.Debug("account.display", () => String.Format("Account display predicate: {0}", Report.DisplayHandler.Str()));
                DispPred.Parse(Report.DisplayHandler.Str());
            }

            MarkAccounts(Report.Session.Journal.Master, Report.FlatHandler.Handled);

            int displayed = PostedAccounts.Sum(account => PostAccount(account, Report.FlatHandler.Handled));

            if (displayed > 1 && !Report.NoTotalHandler.Handled && !Report.PercentHandler.Handled)
            {
                BindScope boundScope = new BindScope(Report, Report.Session.Journal.Master);
                sb.Append(SeparatorFormat?.Calc(boundScope));

                if (PrependFormat != null)
                {
                    sb.AppendFormat(StringExtensions.GetWidthAlignFormatString(PrependWidth), PrependFormat.Calc(boundScope));
                }

                sb.Append(TotalLineFormat.Calc(boundScope));
            }

            Report.OutputStream.Write(sb.ToString());
        }
Exemplo n.º 5
0
        // format_command
        public static Value FormatCommand(CallScope args)
        {
            string arg = CallScope.JoinArgs(args);

            if (String.IsNullOrEmpty(arg))
            {
                throw new LogicError(LogicError.ErrorMessageUsageFormatText);
            }

            Report        report = args.FindScope <Report>();
            StringBuilder sb     = new StringBuilder();

            Post post = GetSampleXact(report);

            sb.AppendLine("--- Input format string ---");
            sb.AppendLine(arg);
            sb.AppendLine();

            sb.AppendLine("--- Format elements ---");
            Format fmt = new Format(arg);

            sb.AppendLine(fmt.Dump());

            sb.AppendLine("--- Formatted string ---");
            BindScope boundScope = new BindScope(args, post);

            sb.AppendFormat("\"{0}\"", fmt.Calc(boundScope));
            sb.AppendLine();

            report.OutputStream.Write(sb.ToString());
            return(Value.Empty);
        }
Exemplo n.º 6
0
        public override void Flush()
        {
            StringBuilder sb            = new StringBuilder();
            Format        prependFormat = null;
            int           prependWidth  = 0;

            if (Report.PrependFormatHandler.Handled)
            {
                prependFormat = new Format(Report.PrependFormatHandler.Str());
                if (Report.PrependWidthHandler.Handled)
                {
                    prependWidth = Int32.Parse(Report.PrependWidthHandler.Str());
                }
            }

            foreach (KeyValuePair <Account, int> pair in Accounts.OrderBy(p => p.Key.FullName, StringComparer.Ordinal))
            {
                if (prependFormat != null)
                {
                    BindScope boundScope = new BindScope(Report, pair.Key);
                    sb.AppendFormat(StringExtensions.GetWidthAlignFormatString(prependWidth),
                                    prependFormat.Calc(boundScope));
                }

                if (Report.CountHandler.Handled)
                {
                    sb.AppendFormat("{0} ", pair.Value);
                }
                sb.AppendLine(pair.Key.ToString());
            }

            Report.OutputStream.Write(sb.ToString());
        }
Exemplo n.º 7
0
        public Value AddToValue(Value value, Expr expr = null)
        {
            if (HasXData && XData.Compound)
            {
                if (!Value.IsNullOrEmpty(XData.CompoundValue))
                {
                    value = Value.AddOrSetValue(value, XData.CompoundValue);
                }
            }
            else if (expr != null)
            {
                BindScope boundScope = new BindScope(expr.Context, this);
                Value     temp       = expr.Calc(boundScope);
                value = Value.AddOrSetValue(value, temp);
            }
            else if (HasXData && XData.Visited && !Value.IsNullOrEmpty(XData.VisitedValue))
            {
                value = Value.AddOrSetValue(value, XData.VisitedValue);
            }
            else
            {
                value = Value.AddOrSetValue(value, Value.Get(Amount));
            }

            return(value);
        }
Exemplo n.º 8
0
        public override void Handle(Post post)
        {
            if (!post.HasXData || !post.XData.Displayed)
            {
                StringBuilder sb         = new StringBuilder();
                BindScope     boundScope = new BindScope(Report, post);

                if (!String.IsNullOrEmpty(ReportTitle))
                {
                    if (FirstReportTitle)
                    {
                        FirstReportTitle = false;
                    }
                    else
                    {
                        sb.AppendLine();
                    }

                    ValueScope valScope         = new ValueScope(boundScope, Value.StringValue(ReportTitle));
                    Format     groupTitleFormat = new Format(Report.GroupTitleFormatHandler.Str());

                    sb.Append(groupTitleFormat.Calc(valScope));

                    ReportTitle = string.Empty;
                }

                if (PrependFormat != null)
                {
                    sb.AppendFormat(StringExtensions.GetWidthAlignFormatString(PrependWidth), PrependFormat.Calc(boundScope));
                }

                if (LastXact != post.Xact)
                {
                    if (LastXact != null)
                    {
                        BindScope xactScope = new BindScope(Report, LastXact);
                        if (BetweenFormat != null)      // DM - in the original code, between_format is called w/o instantiating and returns nothing
                        {
                            sb.Append(BetweenFormat.Calc(xactScope));
                        }
                    }
                    sb.Append(FirstLineFormat.Calc(boundScope));
                    LastXact = post.Xact;
                }
                else if (LastPost != null && LastPost.GetDate() != post.GetDate())
                {
                    sb.Append(FirstLineFormat.Calc(boundScope));
                }
                else
                {
                    sb.Append(NextLineFormat.Calc(boundScope));
                }

                post.XData.Displayed = true;
                LastPost             = post;

                Report.OutputStream.Write(sb.ToString());
            }
        }
Exemplo n.º 9
0
        /// <summary>
        /// Ported from changed_value_posts::output_revaluation
        /// </summary>
        public void OutputRevaluation(Post post, Date date)
        {
            if (date.IsValid())
            {
                post.XData.Date = date;
            }

            try
            {
                BindScope boundScope = new BindScope(Report, post);
                RepricedTotal = TotalExpr.Calc(boundScope);
            }
            finally
            {
                post.XData.Date = default(Date);
            }

            if (!Value.IsNullOrEmpty(LastTotal))
            {
                Value diff = RepricedTotal - LastTotal;
                if (!Value.IsNullOrEmptyOrFalse(diff))
                {
                    Xact xact = Temps.CreateXact();
                    xact.Payee = "Commodities revalued";
                    xact.Date  = date.IsValid() ? date : post.ValueDate;

                    if (!ForAccountsReports)
                    {
                        FiltersCommon.HandleValue(
                            /* value=         */ diff,
                            /* account=       */ RevaluedAccount,
                            /* xact=          */ xact,
                            /* temps=         */ Temps,
                            /* handler=       */ (PostHandler)Handler,
                            /* date=          */ xact.Date.Value,
                            /* act_date_p=    */ true,
                            /* total=         */ RepricedTotal);
                    }
                    else if (ShowUnrealized)
                    {
                        FiltersCommon.HandleValue(
                            /* value=         */ diff.Negated(),
                            /* account=       */
                            (diff.IsLessThan(Value.Zero) ?
                             LossesEquityAccount :
                             GainsEquityAccount),
                            /* xact=          */ xact,
                            /* temps=         */ Temps,
                            /* handler=       */ (PostHandler)Handler,
                            /* date=          */ xact.Date.Value,
                            /* act_date_p=    */ true,
                            /* total=         */ new Value(),
                            /* direct_amount= */ false,
                            /* mark_visited=  */ true);
                    }
                }
            }
        }
Exemplo n.º 10
0
        public void BindScope_Description_IsGrandChildDescription()
        {
            MockScope mockScope1 = new MockScope();
            MockScope mockScope2 = new MockScope("grand-child");

            BindScope bindScope = new BindScope(mockScope1, mockScope2);

            Assert.Equal(mockScope2.Description, bindScope.Description);
        }
Exemplo n.º 11
0
        public void ScopeExtensions_SearchScope_MakesReqursiveCallForBindScope()
        {
            MockScope parent     = new MockScope();
            MockScope grandChild = new MockScope();
            BindScope bindScope  = new BindScope(parent, grandChild);

            MockScope result = ScopeExtensions.SearchScope <MockScope>(bindScope);

            Assert.Equal(grandChild, result);
        }
Exemplo n.º 12
0
        public override void Handle(Post post)
        {
            BindScope boundScope = new BindScope(Context, post);

            if (Pred.Calc(boundScope).Bool)
            {
                post.XData.Matches = true;
                base.Handle(post);
            }
        }
Exemplo n.º 13
0
        public void BindScope_Contructor_PopulatesGrandChild()
        {
            MockScope mockScope1 = new MockScope();
            MockScope mockScope2 = new MockScope();

            BindScope bindScope = new BindScope(mockScope1, mockScope2);

            Assert.Equal(mockScope1, bindScope.Parent);
            Assert.Equal(mockScope2, bindScope.GrandChild);
        }
Exemplo n.º 14
0
        public void BindScope_Lookup_CallsGrandChildLookupFirst()
        {
            MockScope mockScope1 = new MockScope();
            MockScope mockScope2 = new MockScope("grand-child");

            BindScope bindScope    = new BindScope(mockScope1, mockScope2);
            ExprOp    lookupResult = bindScope.Lookup(SymbolKindEnum.FUNCTION, "dummy");

            Assert.Equal(mockScope2.LookupResult, lookupResult);
            Assert.Equal(1, mockScope2.LookupCalls.Count);
        }
Exemplo n.º 15
0
 public IBindingCondition As(BindScope scope)
 {
     switch (scope)
     {
         default:
         case Injection.BindScope.Transient:
             return AsTransient();
         case Injection.BindScope.Singleton:
             return AsSingleton();
     }
 }
Exemplo n.º 16
0
        public IBindingCondition As(BindScope scope)
        {
            switch (scope)
            {
            default:
            case Injection.BindScope.Transient:
                return(AsTransient());

            case Injection.BindScope.Singleton:
                return(AsSingleton());
            }
        }
Exemplo n.º 17
0
        public void BindScope_Define_CallsParentAndGrandChildDefine()
        {
            MockScope mockScope1 = new MockScope();
            MockScope mockScope2 = new MockScope("grand-child");

            BindScope bindScope = new BindScope(mockScope1, mockScope2);

            bindScope.Define(SymbolKindEnum.FUNCTION, "dummy", new ExprOp());

            Assert.Equal(1, mockScope1.DefineCalls.Count);
            Assert.Equal(1, mockScope2.DefineCalls.Count);
        }
Exemplo n.º 18
0
        /// <summary>
        /// Ported from void transfer_details::operator()(post_t& post)
        /// </summary>
        public override void Handle(Post post)
        {
            Xact xact = Temps.CopyXact(post.Xact);

            xact.Date = post.GetDate();

            Post temp = Temps.CopyPost(post, xact);

            temp.State = post.State;

            BindScope boundScope = new BindScope(Scope, temp);
            Value     substitute = Expr.Calc(boundScope);

            if (!Value.IsNullOrEmpty(substitute))
            {
                switch (WhichElement)
                {
                case TransferDetailsElementEnum.SET_DATE:
                    temp.Date = substitute.AsDate;
                    break;

                case TransferDetailsElementEnum.SET_ACCOUNT:
                {
                    string accountName = substitute.AsString;
                    if (!String.IsNullOrEmpty(accountName) && !accountName.EndsWith(":"))
                    {
                        Account prevAccount = temp.Account;
                        temp.Account.RemovePost(temp);

                        accountName += ":" + prevAccount.FullName;

                        string[] accountNames = accountName.Split(':');
                        temp.Account = FiltersCommon.CreateTempAccountFromPath(accountNames, Temps, xact.Journal.Master);
                        temp.Account.AddPost(temp);

                        temp.Account.SetFlags(prevAccount);
                        if (prevAccount.HasXData)
                        {
                            temp.Account.XData.SetFlags(prevAccount.XData);
                        }
                    }
                    break;
                }

                case TransferDetailsElementEnum.SET_PAYEE:
                    xact.Payee = substitute.AsString;
                    break;
                }
            }

            base.Handle(temp);
        }
Exemplo n.º 19
0
        public void Format_IntegrationTest_AccountLineFormat()
        {
            Report  report  = new Report(new Session());
            Account account = new Account(null, "test-account");

            string formatStr         = "%(ansify_if(  justify(scrub(display_total), 20, 20 + int(prepend_width), true, color), bold if should_bold))  %(!options.flat ? depth_spacer : \"\")%-(ansify_if(   ansify_if(partial_account(options.flat), blue if color), bold if should_bold))";
            Format accountLineFormat = new Format(formatStr);

            BindScope boundScope = new BindScope(report, account);
            string    result     = accountLineFormat.Calc(boundScope);

            Assert.AreEqual("                   0  test-account", result);
        }
Exemplo n.º 20
0
        public void RegisterMetadata(string key, Value value, Item context)
        {
            if (CheckingStyle == JournalCheckingStyleEnum.CHECK_WARNING || CheckingStyle == JournalCheckingStyleEnum.CHECK_ERROR)
            {
                if (!KnownTags.Contains(key))
                {
                    if (context == null)
                    {
                        if (ForceChecking)
                        {
                            FixedMetadata = true;
                        }
                        KnownTags.Add(key);
                    }
                    else if (!FixedMetadata && context != null && context.State != ItemStateEnum.Uncleared)
                    {
                        KnownTags.Add(key);
                    }
                    else if (CheckingStyle == JournalCheckingStyleEnum.CHECK_WARNING)
                    {
                        CurrentContext.Warning(String.Format("Unknown metadata tag '{0}'", key));
                    }
                    else if (CheckingStyle == JournalCheckingStyleEnum.CHECK_ERROR)
                    {
                        throw new ParseError(String.Format("Unknown metadata tag '{0}'", key));
                    }
                }
            }

            if (!Value.IsNullOrEmpty(value))
            {
                foreach (CheckExprPair pair in TagCheckExprsMap.GetValues(key))
                {
                    BindScope  boundScope = new BindScope(CurrentContext.Scope, context);
                    ValueScope valScope   = new ValueScope(boundScope, value);

                    if (!pair.Expr.Calc(valScope).AsBoolean)
                    {
                        if (pair.CheckExprKind == CheckExprKindEnum.EXPR_ASSERTION)
                        {
                            throw new ParseError(String.Format(ParseError.ParseError_MetadataAssertionFailedFor, key, value, pair.Expr));
                        }
                        else
                        {
                            CurrentContext.Warning(String.Format(ParseError.ParseError_MetadataCheckFailedFor, key, value, pair.Expr));
                        }
                    }
                }
            }
        }
Exemplo n.º 21
0
        public void BindScope_Lookup_CallsParentLookupNext()
        {
            MockScope mockScope1 = new MockScope();
            MockScope mockScope2 = new MockScope("grand-child");

            mockScope2.LookupResult = null;

            BindScope bindScope    = new BindScope(mockScope1, mockScope2);
            ExprOp    lookupResult = bindScope.Lookup(SymbolKindEnum.FUNCTION, "dummy");

            Assert.AreEqual(mockScope1.LookupResult, lookupResult);
            Assert.AreEqual(1, mockScope1.LookupCalls.Count);
            Assert.AreEqual(1, mockScope2.LookupCalls.Count);
        }
Exemplo n.º 22
0
        private static Value FnAll(CallScope args)
        {
            Account account = args.Context <Account>();
            ExprOp  expr    = args.Get <ExprOp>(0);

            foreach (Post p in account.Posts)
            {
                BindScope boundScope = new BindScope(args, p);
                if (!expr.Calc(boundScope, args.Locus, args.Depth).AsBoolean)
                {
                    return(Value.False);
                }
            }
            return(Value.True);
        }
Exemplo n.º 23
0
        private static Value FnAny(CallScope args)
        {
            Post   post = args.Context <Post>();
            ExprOp expr = args.Get <ExprOp>(0);

            foreach (Post p in post.Xact.Posts)
            {
                BindScope boundScope = new BindScope(args, p);
                if (expr.Calc(boundScope, args.Locus, args.Depth).AsBoolean)
                {
                    return(Value.True);
                }
            }
            return(Value.False);
        }
Exemplo n.º 24
0
        public virtual int PostAccount(Account account, bool flat)
        {
            if (!flat && account.Parent != null)
            {
                PostAccount(account.Parent, flat);
            }

            if (account.XData.ToDisplay && !account.XData.Displayed)
            {
                StringBuilder sb = new StringBuilder();

                Logger.Current.Debug("account.display", () => String.Format("Displaying account: {0}", account.FullName));
                account.XData.Displayed = true;

                BindScope boundScope = new BindScope(Report, account);

                if (!String.IsNullOrEmpty(ReportTitle))
                {
                    if (FirstReportTitle)
                    {
                        FirstReportTitle = false;
                    }
                    else
                    {
                        sb.AppendLine();
                    }

                    ValueScope valScope         = new ValueScope(boundScope, Value.StringValue(ReportTitle));
                    Format     groupTitleFormat = new Format(Report.GroupTitleFormatHandler.Str());

                    sb.Append(groupTitleFormat.Calc(valScope));

                    ReportTitle = string.Empty;
                }

                if (PrependFormat != null)
                {
                    sb.AppendFormat(StringExtensions.GetWidthAlignFormatString(PrependWidth), PrependFormat.Calc(boundScope));
                }

                sb.Append(AccountLineFormat.Calc(boundScope));

                Report.OutputStream.Write(sb.ToString());

                return(1);
            }
            return(0);
        }
Exemplo n.º 25
0
        public Amount ResolveExpr(Scope scope, Expr expr)
        {
            BindScope boundScope = new BindScope(scope, this);
            Value     result     = expr.Calc(boundScope);

            if (result.Type == ValueTypeEnum.Integer)
            {
                return(result.AsAmount);
            }
            else
            {
                if (result.Type != ValueTypeEnum.Amount)
                {
                    throw new AmountError(AmountError.ErrorMessageAmountExpressionsMustResultInASimpleAmount);
                }
                return(result.AsAmount);
            }
        }
Exemplo n.º 26
0
        private Value CallLambda(ExprOp func, Scope scope, CallScope callArgs, ExprOp locus, int depth)
        {
            int  argsIndex = 0;
            long argsCount = callArgs.Size;

            SymbolScope argsScope = new SymbolScope(Scope.EmptyScope);

            for (ExprOp sym = func.Left; sym != null; sym = sym.HasRight ? sym.Right : null)
            {
                ExprOp varName = sym.Kind == OpKindEnum.O_CONS ? sym.Left : sym;

                if (!varName.IsIdent)
                {
                    throw new CalcError(CalcError.ErrorMessageInvalidFunctionDefinition);
                }

                if (argsIndex == argsCount)
                {
                    Logger.Current.Debug("expr.calc", () => String.Format("Defining function argument as null: {0}", varName.AsIdent));
                    argsScope.Define(SymbolKindEnum.FUNCTION, varName.AsIdent, WrapValue(Value.Empty));
                }
                else
                {
                    Logger.Current.Debug("expr.calc", () => String.Format("Defining function argument from call_args: {0}", varName.AsIdent));
                    argsScope.Define(SymbolKindEnum.FUNCTION, varName.AsIdent, WrapValue(callArgs[argsIndex++]));
                }
            }

            if (argsIndex < argsCount)
            {
                throw new CalcError(String.Format(CalcError.ErrorMessageTooFewArgumentsInFunctionCall, argsCount, argsIndex));
            }

            if (func.Right.IsScope)
            {
                BindScope outerScope = new BindScope(scope, func.Right.AsScope);
                BindScope boundScope = new BindScope(outerScope, argsScope);
                return(func.Right.Left.Calc(boundScope, locus, depth + 1));
            }
            else
            {
                return(func.Right.Calc(argsScope, locus, depth + 1));
            }
        }
Exemplo n.º 27
0
        public Tuple <int, int> MarkAccounts(Account account, bool flat)
        {
            int visited   = 0;
            int toDisplay = 0;

            foreach (Account acc in account.Accounts.Values)
            {
                Tuple <int, int> i = MarkAccounts(acc, flat);
                visited   += i.Item1;
                toDisplay += i.Item2;
            }

            if (Logger.Current.ShowDebug(DebugAccountDisplay))
            {
                Logger.Current.Debug(DebugAccountDisplay, () => "Considering account: " + account.FullName);
                if (account.HasXFlags(d => d.Visited))
                {
                    Logger.Current.Debug(DebugAccountDisplay, () => "  it was visited itself");
                }
                Logger.Current.Debug(DebugAccountDisplay, () => "  it has " + visited + " visited children");
                Logger.Current.Debug(DebugAccountDisplay, () => "  it has " + toDisplay + " children to display");
            }

            if (account.Parent != null && (account.HasXFlags(d => d.Visited) || (!flat && visited > 0)))
            {
                BindScope boundScope = new BindScope(Report, account);
                CallScope callScope  = new CallScope(boundScope);

                if ((!flat && toDisplay > 1) || ((flat || toDisplay != 1 || account.HasXFlags(d => d.Visited)) &&
                                                 (Report.EmptyHandler.Handled || !Value.IsNullOrEmptyOrFalse(Report.DisplayValue(Report.FnDisplayTotal(callScope)))) &&
                                                 !Value.IsNullOrEmptyOrFalse(DispPred.Calc(boundScope))))
                {
                    account.XData.ToDisplay = true;
                    Logger.Current.Debug(DebugAccountDisplay, () => "Marking account as TO_DISPLAY");
                    toDisplay = 1;
                }
                visited = 1;
            }

            return(new Tuple <int, int>(visited, toDisplay));
        }
Exemplo n.º 28
0
        public override void Handle(Post post)
        {
            BindScope boundScope = new BindScope(Report, post);
            Value     result     = GroupByExpr.Calc(boundScope);

            if (!Value.IsNullOrEmpty(result))
            {
                IList <Post> posts;
                if (PostsMap.TryGetValue(result, out posts))
                {
                    posts.Add(post);
                }
                else
                {
                    PostsMap.Add(result, new List <Post>()
                    {
                        post
                    });
                }
            }
        }
Exemplo n.º 29
0
        private static Value FnAll(CallScope args)
        {
            Post   post = args.Context <Post>();
            ExprOp expr = args.Get <ExprOp>(0);

            foreach (Post p in post.Xact.Posts)
            {
                BindScope boundScope = new BindScope(args, p);
                if (p == post && args.Has <ExprOp>(1) && !args.Get <ExprOp>(1).Calc(boundScope, args.Locus, args.Depth).AsBoolean)
                {
                    // If the user specifies any(EXPR, false), and the context is a
                    // posting, then that posting isn't considered by the test.
                    ;                       // skip it
                }
                else if (expr.Calc(boundScope, args.Locus, args.Depth).AsBoolean)
                {
                    return(Value.False);
                }
            }
            return(Value.True);
        }
Exemplo n.º 30
0
        // parse_command
        public static Value ParseCommand(CallScope args)
        {
            string arg = CallScope.JoinArgs(args);

            if (String.IsNullOrEmpty(arg))
            {
                throw new LogicError(LogicError.ErrorMessageUsageParseText);
            }

            Report        report = args.FindScope <Report>();
            StringBuilder sb     = new StringBuilder();

            Post post = GetSampleXact(report);

            sb.AppendLine("--- Input expression ---");
            sb.AppendLine(arg);

            sb.AppendLine("--- Text as parsed ---");
            Expr expr = new Expr(arg);

            sb.AppendLine(expr.Print());

            sb.AppendLine("--- Expression tree ---");
            sb.Append(expr.Dump());

            BindScope boundScope = new BindScope(args, post);

            expr.Compile(boundScope);
            sb.AppendLine("--- Compiled tree ---");
            sb.Append(expr.Dump());

            sb.AppendLine("--- Calculated value ---");
            Value result = expr.Calc();

            sb.AppendLine(result.StripAnnotations(report.WhatToKeep()).Dump());

            report.OutputStream.Write(sb.ToString());
            return(Value.Empty);
        }
Exemplo n.º 31
0
        private MainApplicationContext InitializeSession(IEnumerable <string> args, CancellationToken token)
        {
            using (var memoryStreamManager = new MemoryStreamManager(InputText))
            {
                var context = ServiceEngine.CreateContext(memoryStreamManager);
                token.Register(() => context.CancellationSignal = CaughtSignalEnum.INTERRUPTED);
                using (context.AcquireCurrentThread())
                {
                    GlobalScope.HandleDebugOptions(args);
                    Logger.Current.Info(() => LedgerSessionStarting);

                    GlobalScope = new GlobalScope(context.EnvironmentVariables);
                    GlobalScope.Session.FlushOnNextDataFile = true;

                    try
                    {
                        // Look for options and a command verb in the command-line arguments
                        BindScope boundScope = new BindScope(GlobalScope, GlobalScope.Report);
                        args = GlobalScope.ReadCommandArguments(boundScope, args);

                        GlobalScope.Session.ReadJournalFiles();
                        Status = 0;
                    }
                    catch (CountError errors)
                    {
                        Status = errors.Count;
                    }
                    catch (Exception err)
                    {
                        GlobalScope.ReportError(err);
                    }

                    OutputText = memoryStreamManager.GetOutputText();
                    ErrorText  = memoryStreamManager.GetErrorText();
                    return(context);
                }
            }
        }
Exemplo n.º 32
0
        /// <summary>
        /// Ported from void changed_value_posts::operator()(post_t& post)
        /// </summary>
        public override void Handle(Post post)
        {
            if (LastPost != null)
            {
                if (!ForAccountsReports && !HistoricalPricesOnly)
                {
                    OutputIntermediatePrices(LastPost, post.ValueDate);
                }
                OutputRevaluation(LastPost, post.ValueDate);
            }

            if (ChangedValuesOnly)
            {
                post.XData.Displayed = true;
            }

            base.Handle(post);

            BindScope boundScope = new BindScope(Report, post);

            LastTotal = TotalExpr.Calc(boundScope);
            LastPost  = post;
        }
Exemplo n.º 33
0
 protected BindAttributeBase(BindScope bindingScope)
 {
     BindingScope = bindingScope;
 }
 public BindFactoryAttribute(Type contractType, BindScope scope)
     : this(contractType, Type.EmptyTypes, scope)
 {
 }
Exemplo n.º 35
0
 public BindAttribute(Type contractType, Type[] baseTypes, BindScope bindingScope, ConditionSource conditionSource, ConditionComparer conditionComparer, object conditionTarget)
     : base(bindingScope, conditionSource, conditionComparer, conditionTarget)
 {
     ContractType = contractType;
     BaseTypes = baseTypes;
 }
Exemplo n.º 36
0
 public BindAttribute(Type contractType, BindScope bindingScope, ConditionSource conditionSource, ConditionComparer conditionComparer, object conditionTarget)
     : this(contractType, Type.EmptyTypes, bindingScope, conditionSource, conditionComparer, conditionTarget)
 {
 }
Exemplo n.º 37
0
 public BindAttribute(Type contractType, Type[] baseTypes, BindScope bindingScope)
     : base(bindingScope)
 {
     ContractType = contractType;
     BaseTypes = baseTypes;
 }
 public BindFactoryAttribute(Type contractType, Type[] baseTypes, BindScope scope)
     : base(scope)
 {
     ContractType = contractType;
     BaseTypes = baseTypes;
 }
Exemplo n.º 39
0
 public BindAttribute(Type contractType, BindScope bindingScope)
     : this(contractType, Type.EmptyTypes, bindingScope)
 {
 }
Exemplo n.º 40
0
 public BindAllAttribute(BindScope bindingScope)
     : base(bindingScope)
 {
 }
Exemplo n.º 41
0
 public BindAllAttribute(BindScope bindingScope, ConditionSource conditionSource, ConditionComparer conditionComparer, object conditionTarget)
     : base(bindingScope, conditionSource, conditionComparer, conditionTarget)
 {
 }