/// <summary> /// Ported from void process_option(const string& whence, const expr_t::func_t& opt, /// </summary> public static void ProcessOption(string whence, ExprFunc opt, Scope scope, string arg, string name) { try { CallScope args = new CallScope(scope); args.PushBack(NValue.Get(whence)); if (!String.IsNullOrEmpty(arg)) { args.PushBack(NValue.Get(arg)); } opt(args); } catch (CountError) { throw; // DM - error_count is not std::exception and may pass by "catch" block } catch (Exception) { if (!String.IsNullOrEmpty(name) && name.StartsWith("-")) { throw new Exception(String.Format("While parsing option '{0}'", name)); } else { throw new Exception(String.Format("While parsing environent variable '{0}'", name)); } } }
public static CallScope Create(string parm) { CallScope callScope = new CallScope(new EmptyScope()); callScope.PushBack(NValue.StringValue(parm)); return(callScope); }
public Value Handler(CallScope args) { if (WantsArg) { if (args.Size < 2) { throw new InvalidOperationException(String.Format("No argument provided for {0}", Desc)); } if (args.Size > 2) { throw new InvalidOperationException(String.Format("To many arguments provided for {0}", Desc)); } if (args[0].Type != ValueTypeEnum.String) { throw new InvalidOperationException(String.Format("Context argument for {0} not a string", Desc)); } On(args[0].AsString, args[1].AsString); } else { if (args.Size < 1) { throw new InvalidOperationException(String.Format("No argument provided for {0}", Desc)); } if (args[0].Type != ValueTypeEnum.String) { throw new InvalidOperationException(String.Format("Context argument for {0} not a string", Desc)); } On(args[0].AsString); } return(NValue.Get(true)); }
public static void ProcessOption(string whence, ExprFunc opt, Scope scope, string arg, string name) { try { CallScope args = new CallScope(scope); args.PushBack(NValue.Get(whence)); if (!String.IsNullOrEmpty(arg)) { args.PushBack(NValue.Get(arg)); } opt(args); } catch { if (!String.IsNullOrEmpty(name) && name.StartsWith("-")) { throw new Exception(String.Format("While parsing option '{0}'", name)); } else { throw new Exception(String.Format("While parsing environent variable '{0}'", name)); } } }
public Value PushCommand(CallScope args) { // Make a copy at position 2, because the topmost report object has an // open output stream at this point. We want it to get popped off as // soon as this command terminate so that the stream is closed cleanly. Report temp = ReportStack.Pop(); ReportStack.Push(new Report(temp)); ReportStack.Push(temp); return(Value.Get(true)); }
public Value FnLotTag(CallScope args) { Amount amt = args.Get <Amount>(0, false); if (amt.HasAnnotation && amt.Annotation.Tag != null) { return(Value.Get(amt.Annotation.Tag)); } else { return(Value.Empty); } }
public Value FnAccount(CallScope args) { if (args[0].Type == ValueTypeEnum.String) { return(Value.ScopeValue(Journal.FindAccount(args[0].AsString))); } else if (args[0].Type == ValueTypeEnum.Mask) { return(Value.ScopeValue(Journal.FindAccountRe(args[0].AsMask.ToString()))); } else { return(null); } }
// operator() public Value Call(CallScope args) { if (!args.IsEmpty) { args.PushFront(NValue.StringValue("?expr")); return(Handler(args)); } if (WantsArg) { return(NValue.StringValue(Value)); } else { return(NValue.Get(Handled)); } }
public void ExecuteCommand(IEnumerable <string> args, bool atRepl) { Session.FlushOnNextDataFile = true; // Process the command verb, arguments and options if (atRepl) { args = ReadCommandArguments(Report, args); if (!args.Any()) { return; } } string verb = args.First(); args = args.Skip(1); // DM - skip the first item that is equal to verb = *arg++; // Look for a precommand first, which is defined as any defined function // whose name starts with "ledger_precmd_". The difference between a // precommand and a regular command is that precommands ignore the journal // data file completely, nor is the user's init file read. // // Here are some examples of pre-commands: // // parse STRING ; show how a value expression is parsed // eval STRING ; simply evaluate a value expression // format STRING ; show how a format string is parsed // // If such a command is found, create the output stream for the result and // then invoke the command. ExprFunc command; bool isPrecommand = false; BindScope boundScope = new BindScope(this, Report); command = LookForPrecommand(boundScope, verb); if (!command.IsNullOrEmpty()) { isPrecommand = true; } // If it is not a pre-command, then parse the user's ledger data at this // time if not done already (i.e., if not at a REPL). Then patch up the // report options based on the command verb. if (!isPrecommand) { if (!atRepl) { Session.ReadJournalFiles(); } Report.NormalizeOptions(verb); command = LookForCommand(boundScope, verb); if (command.IsNullOrEmpty()) { throw new LogicError(String.Format(LogicError.ErrorMessageUnrecognizedCommand, verb)); } } // Create the output stream (it might be a file, the console or a PAGER // subprocess) and invoke the report command. The output stream is closed // by the caller of this function. Report.OutputStream = FileSystem.OutputStreamInitialize( Report.OutputHandler.Handled ? Report.OutputHandler.Str() : String.Empty, Report.PagerHandler.Handled ? Report.PagerHandler.Str() : String.Empty); // Now that the output stream is initialized, report the options that will // participate in this report, if the user specified --options if (OptionsHandler.Handled) { Report.OutputStream.Write(ReportOptions(Report)); } // Create an argument scope containing the report command's arguments, and // then invoke the command. The bound scope causes lookups to happen // first in the global scope, and then in the report scope. CallScope commandArgs = new CallScope(boundScope); foreach (string arg in args) { commandArgs.PushBack(Value.Get(arg)); } var info = Logger.Current.InfoContext(TimerName.Command)?.Message("Finished executing command").Start(); // INFO_START command(commandArgs); info?.Finish(); // INFO_FINISH }
public Value PopCommand(CallScope args) { PopReport(); return(Value.Get(true)); }
public static string JoinArgs(CallScope args) { return(String.Join(" ", args.ArgsList)); }
public Value FnStr(CallScope args) { return(Value.StringValue(args[0].AsString)); }
public Value FnInt(CallScope args) { return(Value.Get(args[0].AsLong)); }
public Value FnMax(CallScope args) { return(args[1].IsGreaterThan(args[0]) ? args[1] : args[0]); }
public Value FnMin(CallScope args) { return(args[1].IsLessThan(args[0]) ? args[1] : args[0]); }