From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <emacs-orgmode-bounces+larch=yhetil.org@gnu.org>
Received: from mp0.migadu.com ([2001:41d0:303:e224::])
	(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits))
	by ms8.migadu.com with LMTPS
	id CPg9Da1XA2Z/CQAAqHPOHw:P1
	(envelope-from <emacs-orgmode-bounces+larch=yhetil.org@gnu.org>)
	for <larch@yhetil.org>; Wed, 27 Mar 2024 00:18:05 +0100
Received: from aspmx1.migadu.com ([2001:41d0:303:e224::])
	(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits))
	by mp0.migadu.com with LMTPS
	id CPg9Da1XA2Z/CQAAqHPOHw
	(envelope-from <emacs-orgmode-bounces+larch=yhetil.org@gnu.org>)
	for <larch@yhetil.org>; Wed, 27 Mar 2024 00:18:05 +0100
X-Envelope-To: larch@yhetil.org
Authentication-Results: aspmx1.migadu.com;
	dkim=pass header.d=gmx.net header.s=s31663417 header.b=lYbDcFcO;
	dmarc=pass (policy=quarantine) header.from=gmx.net;
	spf=pass (aspmx1.migadu.com: domain of "emacs-orgmode-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="emacs-orgmode-bounces+larch=yhetil.org@gnu.org"
ARC-Seal: i=1; s=key1; d=yhetil.org; t=1711495085; a=rsa-sha256; cv=none;
	b=pZDx7SBCIQ9Q3AWbPeSMeJic/XJXdjFGgxR9pN6YSW8yQ9h8eNb6wUiFGgEYqHHSOhvHcb
	j0AXzqjZygpd2b6LFrEO+mG0h23ESd90VJtZnk71ZZXD63hbGGkkTlDKdpkhyA1woFRGpf
	5DhIaSe3fvg0X0fiKe/W2JngeIC0QPmJaT76VeIe65RjD1wsappeN/N6q0xcjB71iUlTrh
	R0qwyUias4AH0GYyn5wP7we4W1Te06iURyRaMc+ehBfcS06CcFl8nojSYHqdEdsKeIKnTk
	60JLJw0QAYWwJRE4T5IfwtZzgavIDRLKUlFsY+FIkIpimLVhUO62qx+fZhzaew==
ARC-Authentication-Results: i=1;
	aspmx1.migadu.com;
	dkim=pass header.d=gmx.net header.s=s31663417 header.b=lYbDcFcO;
	dmarc=pass (policy=quarantine) header.from=gmx.net;
	spf=pass (aspmx1.migadu.com: domain of "emacs-orgmode-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="emacs-orgmode-bounces+larch=yhetil.org@gnu.org"
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=yhetil.org;
	s=key1; t=1711495085;
	h=from:from:sender:sender:reply-to:subject:subject:date:date:
	 message-id:message-id:to:to:cc:cc:mime-version:mime-version:
	 content-type:content-type:
	 content-transfer-encoding:content-transfer-encoding:
	 in-reply-to:in-reply-to:references:references:list-id:list-help:
	 list-unsubscribe:list-subscribe:list-post:dkim-signature;
	bh=DUpmK4n5FibZNkOaXsSAUHx1PasaXnexGbaTwFjHXBk=;
	b=YvHLJr67W1DRk37U8uRIMfp7w9vHYkLnnOYm7s1pF0ajDL2ldmvieFQN2K/5qgL/j8kONe
	0cHKwuSpwQkjPE7vXAF9y/Ss/G7k5FIekODaWBRwNg9OV1l0WJjV5jYb3fsRAtt4uUabug
	NNXLQyHdt/KEnpHt2uew3+LBn31t5y2VYXhQKpnhZO652hfswSQR6FAQXVCNDIdfPvQuMT
	G1nELYicOfm+oHbAnBnS21y5Sq2Tu1Gi8nTuHiMIWfBeGEHtyhVnHNy14lbkh5SWbGf80B
	3iryl5RvVsu+XIlz0i2KMmhWCgdPTTVczjqR/EbMpoUz5LuLTKk0yDwnZ8tAFQ==
Received: from lists.gnu.org (lists.gnu.org [209.51.188.17])
	(using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits))
	(No client certificate requested)
	by aspmx1.migadu.com (Postfix) with ESMTPS id 85BC71EBA1
	for <larch@yhetil.org>; Wed, 27 Mar 2024 00:18:04 +0100 (CET)
Received: from localhost ([::1] helo=lists1p.gnu.org)
	by lists.gnu.org with esmtp (Exim 4.90_1)
	(envelope-from <emacs-orgmode-bounces@gnu.org>)
	id 1rpFxt-0004Kr-Fk; Tue, 26 Mar 2024 19:12:21 -0400
Received: from eggs.gnu.org ([2001:470:142:3::10])
 by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.90_1) (envelope-from <telegraph@gmx.net>) id 1rpFxq-0004Kj-NR
 for emacs-orgmode@gnu.org; Tue, 26 Mar 2024 19:12:18 -0400
Received: from mout.gmx.net ([212.227.17.21])
 by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256)
 (Exim 4.90_1) (envelope-from <telegraph@gmx.net>) id 1rpFxm-0004MT-TH
 for emacs-orgmode@gnu.org; Tue, 26 Mar 2024 19:12:18 -0400
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.net;
 s=s31663417; t=1711494730; x=1712099530; i=telegraph@gmx.net;
 bh=DUpmK4n5FibZNkOaXsSAUHx1PasaXnexGbaTwFjHXBk=;
 h=X-UI-Sender-Class:From:To:Cc:Subject:In-Reply-To:References:
 Date;
 b=lYbDcFcOKH3oSQv9WV8WnQfa9NiBZfc78q7OlbANirY6x4pY1AutKqqqjNF22leD
 ujZZ0EDOc4VRXk7Lr1MFUTVlTUlnmv5pVJ+lSjIPW2NbuubO4XHNPkeSDycg5dpz6
 tQXiDC5tHnQQnFk9BvvzVOxRMgCaWtLoTMAAnLfAcNqQZijy2VEJCTf2CQnj7R5w1
 zsrx79kxY+z7NzUrmON+DZrjUGEEu2IzCIyoBmA4GS9T5d/kS208au6xMA/ZQXtQQ
 LE95SWdLiYTF6A6tBV0wh7eqwZsxGM1DbFg5QqGCmx1FLoakHS1kp5jAO5LuxkhJn
 liqISXUGnkQQ74S1GA==
X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a
Received: from localhost ([95.90.236.232]) by mail.gmx.net (mrgmx104
 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MZCfJ-1sJjFw3F9V-00V71c; Wed, 27
 Mar 2024 00:12:09 +0100
From: Gregor Zattler <telegraph@gmx.net>
To: Ihor Radchenko <yantar92@posteo.net>
Cc: emacs-orgmode@gnu.org
Subject: Re: [BUG] org-clock-sum: Wrong type argument: fixnump, nil [9.7-pre
 (release_9.6.22-1309-g8507ef @ /home/grfz/src/org-mode/lisp/)]
In-Reply-To: <87frwdnv9l.fsf@localhost>
References: <87v85cpp2t.fsf@no.lan> <87jzlrbvzr.fsf@localhost>
 <871q7y2u29.fsf@no.lan> <87jzlqnpfw.fsf@localhost> <87jzlq17kx.fsf@no.lan>
 <87frwdnv9l.fsf@localhost>
Mail-Followup-To: Ihor Radchenko <yantar92@posteo.net>, emacs-orgmode@gnu.org
Date: Wed, 27 Mar 2024 00:11:24 +0100
Message-ID: <875xx8mvvn.fsf@no.lan>
MIME-Version: 1.0
Content-Type: text/plain
Content-Transfer-Encoding: quoted-printable
X-Provags-ID: V03:K1:bV99BEoBbSSYT9lTl2wghb8x8qSm+sNroLVE9DA1cOQnTDkYUod
 zHT/h3z5d2SltZRJatgf3Hfdklb5i1c9bDBqwE1148eEwKTr0Uk6OKZdTK751h1L0lohk+K
 eFGP7RX9tAbQ+Ssa+wB3Fq/DgX+wUwz/fg/DbL2bJqELVHjmzifhojQr0zbu11J2f7MrDjn
 ZV6EwCyz1TLzYb6hULEfQ==
UI-OutboundReport: notjunk:1;M01:P0:IYNF2cvZhik=;k0gUSFHtWn5PymzRU8eCWMKx+uD
 EpEmNwNveMFGoeOzf/A9brPbvGP9op4uyyFyzDFBoFuux+03+OpfVXmLbe7sPKEz6hthKKewf
 FdoeZ/u1pAnfZFiG443JHmg1Ah3bLkPrBCqzm1gGoLrhqNq2sKy0etuMVIMZQ2k4gnUN2G9ze
 rHsBJXZYQpnnMa/IGr4EXddjYWOwhPlKbkxlZjGYAaT5HRdtlKQttYNgP7BivA+HfXMNV4DAO
 p1ZuA1EMfTnLDbT6M6eTBbDt0SBAQaSWzUCHRDVy25c6af40TSEpdaZ/eVNEUYyicvexyWmr8
 ikZRi4t4EnccgqClgjrv29xOkke1T6HGx5u8ssgDVI9A2U8T9c+fReDebQvKhfV0cEl8voLqE
 X2qrqe5ZEjpd9Gd3M2wZQvvX/rhi/iSG37c46rHRrPCvpPoQ10H/LLws/9csN1CrFvEywq7N6
 vxnnn+VTUpvw6muyUH80Xct3ICTqCP8wrt19eMq3d4CMN9C/NElNVmBBh8E9ysUJxJm44y9el
 ZJZK5NcvgFUaljBJ06/pf0mmkbg5kyrrl2vmgzjTI/Wdqty9brh2cwI9Pb6BUUdwbvVkH0PJ9
 xyL6mIJDKVNX/yA8Piq177nFzB1Ik1u0LKzqGJPX6XAi0UKNAIRqMyVGyxt5o9lpWxbzVZ8ks
 P61uaotIEJh3p8fW1wm1g5Ss0168uEeft7ItIf+ZA06iQisk2eHUguDlR46rZ29ZUlP9foBwM
 gxxJJ9wMyMuOZYkHhX81fcdN6XXXdU/kxmZDOut3D7knjyodH3RcSIBLX0nvGqdjibXipSPZH
 6OFnNpZpvONENhnNRs+h65AqU/mdqkZ985A+SrcUEkQC0=
Received-SPF: pass client-ip=212.227.17.21; envelope-from=telegraph@gmx.net;
 helo=mout.gmx.net
X-Spam_score_int: -27
X-Spam_score: -2.8
X-Spam_bar: --
X-Spam_report: (-2.8 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1,
 DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001,
 RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001,
 SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no
X-Spam_action: no action
X-BeenThere: emacs-orgmode@gnu.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: "General discussions about Org-mode." <emacs-orgmode.gnu.org>
List-Unsubscribe: <https://lists.gnu.org/mailman/options/emacs-orgmode>,
 <mailto:emacs-orgmode-request@gnu.org?subject=unsubscribe>
List-Archive: <https://lists.gnu.org/archive/html/emacs-orgmode>
List-Post: <mailto:emacs-orgmode@gnu.org>
List-Help: <mailto:emacs-orgmode-request@gnu.org?subject=help>
List-Subscribe: <https://lists.gnu.org/mailman/listinfo/emacs-orgmode>,
 <mailto:emacs-orgmode-request@gnu.org?subject=subscribe>
Errors-To: emacs-orgmode-bounces+larch=yhetil.org@gnu.org
Sender: emacs-orgmode-bounces+larch=yhetil.org@gnu.org
X-Migadu-Flow: FLOW_IN
X-Migadu-Country: US
X-Spam-Score: -8.14
X-Migadu-Queue-Id: 85BC71EBA1
X-Migadu-Scanner: mx12.migadu.com
X-Migadu-Spam-Score: -8.14
X-TUID: 0G1AjkrFFPnO

Hi Ihor,
* Ihor Radchenko <yantar92@posteo.net> [2024-03-26; 10:27 GMT]:
> Gregor Zattler <telegraph@gmx.net> writes:
>
>> In the file.org_archive, with point on a clock line:
>>
>> Debugger entered--Lisp error: (wrong-type-argument fixnump nil)
>>   encode-time((0 nil nil nil nil nil nil -1 nil))
>>   (float-time (encode-time (list 0 (org-element--property :minute-start =
timestamp nil nil) (org-element--property :hour-start timestamp nil nil) (o=
rg-element--property :day-start timestamp nil nil) (org-element--property :=
month-start timestamp nil nil) (org-element--property :year-start timestamp=
 nil nil) nil -1 nil)))
>
> This is helpful. You have some very strange timestamp.
> May you, when the backtrace window is active, press
> e (buffer-substring-no-properties (line-beginning-position -2) (line-end-=
position 3)) <RET>
> It should display text around the problematic timestamp.
>
> I'd like to see the problematic timestamp to understand what might be
> going on there.


thanks for your instructions, I edited it a bit:

"	    - SxxxxxII VPN vxx USB Sxxxx (xxxx)
	    CLOCK: [2012-02-02 Do 14:00]--[2012-02-02 Do 16:00] =3D>  2:00
	    - SxxxxxII; Rxxxxxx kxxxxx, nxxxxxxxxxxxx xxxxxxxxxx
	    Clock: [2012-02-01 Mi 17:34]--[2012-02-01 Mi 18:24] =3D>  0:50
	    - Gxxxxxxx-... #NV -Fxxxxx axxxxxxxx
	    CLOCK: [2012-02-01 Mi 17:04]--[2012-02-01 Mi 17:33] =3D>  0:29"


>> seems to be somewhat truncated.  Is there a way to get
>> it unabbreviated?
>
> Press "." (M-x backtrace-expand-ellipses)

this way I get:

Debugger entered--Lisp error: (wrong-type-argument fixnump nil)
  encode-time((0 nil nil nil nil nil nil -1 nil))
  (float-time (encode-time (list 0 (org-element--property :minute-start tim=
estamp nil nil) (org-element--property :hour-start timestamp nil nil) (org-=
element--property :day-start timestamp nil nil) (org-element--property :mon=
th-start timestamp nil nil) (org-element--property :year-start timestamp ni=
l nil) nil -1 nil)))
  (let* ((timestamp (org-element--property :value element nil nil)) (ts (fl=
oat-time (encode-time (list 0 (org-element--property :minute-start timestam=
p nil nil) (org-element--property :hour-start timestamp nil nil) (org-eleme=
nt--property :day-start timestamp nil nil) (org-element--property :month-st=
art timestamp nil nil) (org-element--property :year-start timestamp nil nil=
) nil -1 nil)))) (te (float-time (encode-time (list 0 (org-element--propert=
y :minute-end timestamp nil nil) (org-element--property :hour-end timestamp=
 nil nil) (org-element--property :day-end timestamp nil nil) (org-element--=
property :month-end timestamp nil nil) (org-element--property :year-end tim=
estamp nil nil) nil -1 nil)))) (dt (- (if tend (min te tend) te) (if tstart=
 (max ts tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (floor dt 60))))=
))
  (cond ((and (eq element-type 'clock) (match-end 2)) (let* ((timestamp (or=
g-element--property :value element nil nil)) (ts (float-time (encode-time (=
list 0 (org-element--property :minute-start timestamp nil nil) (org-element=
--property :hour-start timestamp nil nil) (org-element--property :day-start=
 timestamp nil nil) (org-element--property :month-start timestamp nil nil) =
(org-element--property :year-start timestamp nil nil) nil -1 nil)))) (te (f=
loat-time (encode-time (list 0 (org-element--property :minute-end timestamp=
 nil nil) (org-element--property :hour-end timestamp nil nil) (org-element-=
-property :day-end timestamp nil nil) (org-element--property :month-end tim=
estamp nil nil) (org-element--property :year-end timestamp nil nil) nil -1 =
nil)))) (dt (- (if tend (min te tend) te) (if tstart (max ts tstart) ts))))=
 (if (> dt 0) (progn (setq t1 (+ t1 (floor dt 60))))))) ((match-end 4) (set=
q t1 (+ t1 (string-to-number (match-string 5)) (* 60 (string-to-number (mat=
ch-string 4)))))) ((memq element-type '(headline inlinetask)) (if (and org-=
clock-report-include-clocking-task (eq (org-clocking-buffer) (current-buffe=
r)) (eq (marker-position org-clock-hd-marker) (point)) tstart tend (>=3D (f=
loat-time org-clock-start-time) tstart) (<=3D (float-time org-clock-start-t=
ime) tend)) (progn (let ((time (floor (org-time-convert-to-integer (time-si=
nce org-clock-start-time)) 60))) (setq t1 (+ t1 time))))) (let* ((headline-=
forced (get-text-property (point) :org-clock-force-headline-inclusion)) (he=
adline-included (or (null headline-filter) (save-excursion (let ((saved-mat=
ch-data (match-data))) (unwind-protect (progn (funcall headline-filter)) (s=
et-match-data saved-match-data t))))))) (setq level (- (match-end 1) (match=
-beginning 1))) (if (>=3D level lmax) (progn (progn (setq ltimes (vconcat l=
times (make-vector lmax 0))) (setq lmax (* 2 lmax))))) (if (or (> t1 0) (> =
(aref ltimes level) 0)) (progn (if (or headline-included headline-forced) (=
progn (if headline-included (let* ((l 0) (--cl-var-- level)) (while (<=3D l=
 --cl-var--) (aset ltimes l (+ (aref ltimes l) t1)) (setq l (+ l 1))) nil))=
 (setq time (aref ltimes level)) (goto-char (match-beginning 0)) (put-text-=
property (point) (line-end-position) (or propname :org-clock-minutes) time)=
 (if headline-filter (progn (save-excursion (let ((saved-match-data (match-=
data))) (unwind-protect (progn (while (org-up-heading-safe) (put-text-prope=
rty (point) (line-end-position) :org-clock-force-headline-inclusion t))) (s=
et-match-data saved-match-data t)))))))) (setq t1 0) (let* ((l level) (--cl=
-var-- (1- lmax))) (while (<=3D l --cl-var--) (aset ltimes l 0) (setq l (+ =
l 1))) nil))))))
  (let* ((element (let ((saved-match-data (match-data))) (unwind-protect (p=
rogn (org-element-at-point)) (set-match-data saved-match-data t)))) (elemen=
t-type (org-element-type element))) (cond ((and (eq element-type 'clock) (m=
atch-end 2)) (let* ((timestamp (org-element--property :value element nil ni=
l)) (ts (float-time (encode-time (list 0 (org-element--property :minute-sta=
rt timestamp nil nil) (org-element--property :hour-start timestamp nil nil)=
 (org-element--property :day-start timestamp nil nil) (org-element--propert=
y :month-start timestamp nil nil) (org-element--property :year-start timest=
amp nil nil) nil -1 nil)))) (te (float-time (encode-time (list 0 (org-eleme=
nt--property :minute-end timestamp nil nil) (org-element--property :hour-en=
d timestamp nil nil) (org-element--property :day-end timestamp nil nil) (or=
g-element--property :month-end timestamp nil nil) (org-element--property :y=
ear-end timestamp nil nil) nil -1 nil)))) (dt (- (if tend (min te tend) te)=
 (if tstart (max ts tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (floo=
r dt 60))))))) ((match-end 4) (setq t1 (+ t1 (string-to-number (match-strin=
g 5)) (* 60 (string-to-number (match-string 4)))))) ((memq element-type '(h=
eadline inlinetask)) (if (and org-clock-report-include-clocking-task (eq (o=
rg-clocking-buffer) (current-buffer)) (eq (marker-position org-clock-hd-mar=
ker) (point)) tstart tend (>=3D (float-time org-clock-start-time) tstart) (=
<=3D (float-time org-clock-start-time) tend)) (progn (let ((time (floor (or=
g-time-convert-to-integer (time-since org-clock-start-time)) 60))) (setq t1=
 (+ t1 time))))) (let* ((headline-forced (get-text-property (point) :org-cl=
ock-force-headline-inclusion)) (headline-included (or (null headline-filter=
) (save-excursion (let ((saved-match-data (match-data))) (unwind-protect (p=
rogn (funcall headline-filter)) (set-match-data saved-match-data t))))))) (=
setq level (- (match-end 1) (match-beginning 1))) (if (>=3D level lmax) (pr=
ogn (progn (setq ltimes (vconcat ltimes (make-vector lmax 0))) (setq lmax (=
* 2 lmax))))) (if (or (> t1 0) (> (aref ltimes level) 0)) (progn (if (or he=
adline-included headline-forced) (progn (if headline-included (let* ((l 0) =
(--cl-var-- level)) (while (<=3D l --cl-var--) (aset ltimes l (+ (aref ltim=
es l) t1)) (setq l (+ l 1))) nil)) (setq time (aref ltimes level)) (goto-ch=
ar (match-beginning 0)) (put-text-property (point) (line-end-position) (or =
propname :org-clock-minutes) time) (if headline-filter (progn (save-excursi=
on (let ((saved-match-data (match-data))) (unwind-protect (progn (while (or=
g-up-heading-safe) (put-text-property (point) (line-end-position) :org-cloc=
k-force-headline-inclusion t))) (set-match-data saved-match-data t)))))))) =
(setq t1 0) (let* ((l level) (--cl-var-- (1- lmax))) (while (<=3D l --cl-va=
r--) (aset ltimes l 0) (setq l (+ l 1))) nil)))))))
  (while (re-search-backward re nil t) (let* ((element (let ((saved-match-d=
ata (match-data))) (unwind-protect (progn (org-element-at-point)) (set-matc=
h-data saved-match-data t)))) (element-type (org-element-type element))) (c=
ond ((and (eq element-type 'clock) (match-end 2)) (let* ((timestamp (org-el=
ement--property :value element nil nil)) (ts (float-time (encode-time (list=
 0 (org-element--property :minute-start timestamp nil nil) (org-element--pr=
operty :hour-start timestamp nil nil) (org-element--property :day-start tim=
estamp nil nil) (org-element--property :month-start timestamp nil nil) (org=
-element--property :year-start timestamp nil nil) nil -1 nil)))) (te (float=
-time (encode-time (list 0 (org-element--property :minute-end timestamp nil=
 nil) (org-element--property :hour-end timestamp nil nil) (org-element--pro=
perty :day-end timestamp nil nil) (org-element--property :month-end timesta=
mp nil nil) (org-element--property :year-end timestamp nil nil) nil -1 nil)=
))) (dt (- (if tend (min te tend) te) (if tstart (max ts tstart) ts)))) (if=
 (> dt 0) (progn (setq t1 (+ t1 (floor dt 60))))))) ((match-end 4) (setq t1=
 (+ t1 (string-to-number (match-string 5)) (* 60 (string-to-number (match-s=
tring 4)))))) ((memq element-type '(headline inlinetask)) (if (and org-cloc=
k-report-include-clocking-task (eq (org-clocking-buffer) (current-buffer)) =
(eq (marker-position org-clock-hd-marker) (point)) tstart tend (>=3D (float=
-time org-clock-start-time) tstart) (<=3D (float-time org-clock-start-time)=
 tend)) (progn (let ((time (floor (org-time-convert-to-integer (time-since =
org-clock-start-time)) 60))) (setq t1 (+ t1 time))))) (let* ((headline-forc=
ed (get-text-property (point) :org-clock-force-headline-inclusion)) (headli=
ne-included (or (null headline-filter) (save-excursion (let ((saved-match-d=
ata (match-data))) (unwind-protect (progn (funcall headline-filter)) (set-m=
atch-data saved-match-data t))))))) (setq level (- (match-end 1) (match-beg=
inning 1))) (if (>=3D level lmax) (progn (progn (setq ltimes (vconcat ltime=
s (make-vector lmax 0))) (setq lmax (* 2 lmax))))) (if (or (> t1 0) (> (are=
f ltimes level) 0)) (progn (if (or headline-included headline-forced) (prog=
n (if headline-included (let* ((l 0) (--cl-var-- level)) (while (<=3D l --c=
l-var--) (aset ltimes l (+ (aref ltimes l) t1)) (setq l (+ l 1))) nil)) (se=
tq time (aref ltimes level)) (goto-char (match-beginning 0)) (put-text-prop=
erty (point) (line-end-position) (or propname :org-clock-minutes) time) (if=
 headline-filter (progn (save-excursion (let ((saved-match-data (match-data=
))) (unwind-protect (progn (while (org-up-heading-safe) (put-text-property =
(point) (line-end-position) :org-clock-force-headline-inclusion t))) (set-m=
atch-data saved-match-data t)))))))) (setq t1 0) (let* ((l level) (--cl-var=
-- (1- lmax))) (while (<=3D l --cl-var--) (aset ltimes l 0) (setq l (+ l 1)=
)) nil))))))))
  (save-excursion (goto-char (point-max)) (while (re-search-backward re nil=
 t) (let* ((element (let ((saved-match-data (match-data))) (unwind-protect =
(progn (org-element-at-point)) (set-match-data saved-match-data t)))) (elem=
ent-type (org-element-type element))) (cond ((and (eq element-type 'clock) =
(match-end 2)) (let* ((timestamp (org-element--property :value element nil =
nil)) (ts (float-time (encode-time (list 0 (org-element--property :minute-s=
tart timestamp nil nil) (org-element--property :hour-start timestamp nil ni=
l) (org-element--property :day-start timestamp nil nil) (org-element--prope=
rty :month-start timestamp nil nil) (org-element--property :year-start time=
stamp nil nil) nil -1 nil)))) (te (float-time (encode-time (list 0 (org-ele=
ment--property :minute-end timestamp nil nil) (org-element--property :hour-=
end timestamp nil nil) (org-element--property :day-end timestamp nil nil) (=
org-element--property :month-end timestamp nil nil) (org-element--property =
:year-end timestamp nil nil) nil -1 nil)))) (dt (- (if tend (min te tend) t=
e) (if tstart (max ts tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (fl=
oor dt 60))))))) ((match-end 4) (setq t1 (+ t1 (string-to-number (match-str=
ing 5)) (* 60 (string-to-number (match-string 4)))))) ((memq element-type '=
(headline inlinetask)) (if (and org-clock-report-include-clocking-task (eq =
(org-clocking-buffer) (current-buffer)) (eq (marker-position org-clock-hd-m=
arker) (point)) tstart tend (>=3D (float-time org-clock-start-time) tstart)=
 (<=3D (float-time org-clock-start-time) tend)) (progn (let ((time (floor (=
org-time-convert-to-integer (time-since org-clock-start-time)) 60))) (setq =
t1 (+ t1 time))))) (let* ((headline-forced (get-text-property (point) :org-=
clock-force-headline-inclusion)) (headline-included (or (null headline-filt=
er) (save-excursion (let ((saved-match-data (match-data))) (unwind-protect =
(progn (funcall headline-filter)) (set-match-data saved-match-data t)))))))=
 (setq level (- (match-end 1) (match-beginning 1))) (if (>=3D level lmax) (=
progn (progn (setq ltimes (vconcat ltimes (make-vector lmax 0))) (setq lmax=
 (* 2 lmax))))) (if (or (> t1 0) (> (aref ltimes level) 0)) (progn (if (or =
headline-included headline-forced) (progn (if headline-included (let* ((l 0=
) (--cl-var-- level)) (while (<=3D l --cl-var--) (aset ltimes l (+ (aref lt=
imes l) t1)) (setq l (+ l 1))) nil)) (setq time (aref ltimes level)) (goto-=
char (match-beginning 0)) (put-text-property (point) (line-end-position) (o=
r propname :org-clock-minutes) time) (if headline-filter (progn (save-excur=
sion (let ((saved-match-data (match-data))) (unwind-protect (progn (while (=
org-up-heading-safe) (put-text-property (point) (line-end-position) :org-cl=
ock-force-headline-inclusion t))) (set-match-data saved-match-data t)))))))=
) (setq t1 0) (let* ((l level) (--cl-var-- (1- lmax))) (while (<=3D l --cl-=
var--) (aset ltimes l 0) (setq l (+ l 1))) nil)))))))) (setq org-clock-file=
-total-minutes (aref ltimes 0)))
  (let* ((re (concat "^\\(\\*+\\)[ \11]\\|^[ \11]*" org-clock-string "[ \11=
]*\\(?:\\(\\[.*?\\]\\)-+\\(\\[.*?\\]\\)\\|=3D>[ \11]+\\([0-9]+\\):\\([0-9]+=
\\)\\)")) (lmax 30) (ltimes (make-vector lmax 0)) (level 0) (tstart (cond (=
(stringp tstart) (org-time-string-to-seconds tstart)) ((consp tstart) (floa=
t-time tstart)) (t tstart))) (tend (cond ((stringp tend) (org-time-string-t=
o-seconds tend)) ((consp tend) (float-time tend)) (t tend))) (t1 0) time) (=
remove-text-properties (point-min) (point-max) (cons (or propname :org-cloc=
k-minutes) '(t :org-clock-force-headline-inclusion t))) (save-excursion (go=
to-char (point-max)) (while (re-search-backward re nil t) (let* ((element (=
let ((saved-match-data (match-data))) (unwind-protect (progn (org-element-a=
t-point)) (set-match-data saved-match-data t)))) (element-type (org-element=
-type element))) (cond ((and (eq element-type 'clock) (match-end 2)) (let* =
((timestamp (org-element--property :value element nil nil)) (ts (float-time=
 (encode-time (list 0 (org-element--property :minute-start timestamp nil ni=
l) (org-element--property :hour-start timestamp nil nil) (org-element--prop=
erty :day-start timestamp nil nil) (org-element--property :month-start time=
stamp nil nil) (org-element--property :year-start timestamp nil nil) nil -1=
 nil)))) (te (float-time (encode-time (list 0 (org-element--property :minut=
e-end timestamp nil nil) (org-element--property :hour-end timestamp nil nil=
) (org-element--property :day-end timestamp nil nil) (org-element--property=
 :month-end timestamp nil nil) (org-element--property :year-end timestamp n=
il nil) nil -1 nil)))) (dt (- (if tend (min te tend) te) (if tstart (max ts=
 tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (floor dt 60))))))) ((ma=
tch-end 4) (setq t1 (+ t1 (string-to-number (match-string 5)) (* 60 (string=
-to-number (match-string 4)))))) ((memq element-type '(headline inlinetask)=
) (if (and org-clock-report-include-clocking-task (eq (org-clocking-buffer)=
 (current-buffer)) (eq (marker-position org-clock-hd-marker) (point)) tstar=
t tend (>=3D (float-time org-clock-start-time) tstart) (<=3D (float-time or=
g-clock-start-time) tend)) (progn (let ((time (floor (org-time-convert-to-i=
nteger (time-since org-clock-start-time)) 60))) (setq t1 (+ t1 time))))) (l=
et* ((headline-forced (get-text-property (point) :org-clock-force-headline-=
inclusion)) (headline-included (or (null headline-filter) (save-excursion (=
let ((saved-match-data (match-data))) (unwind-protect (progn (funcall headl=
ine-filter)) (set-match-data saved-match-data t))))))) (setq level (- (matc=
h-end 1) (match-beginning 1))) (if (>=3D level lmax) (progn (progn (setq lt=
imes (vconcat ltimes (make-vector lmax 0))) (setq lmax (* 2 lmax))))) (if (=
or (> t1 0) (> (aref ltimes level) 0)) (progn (if (or headline-included hea=
dline-forced) (progn (if headline-included (let* ((l 0) (--cl-var-- level))=
 (while (<=3D l --cl-var--) (aset ltimes l (+ (aref ltimes l) t1)) (setq l =
(+ l 1))) nil)) (setq time (aref ltimes level)) (goto-char (match-beginning=
 0)) (put-text-property (point) (line-end-position) (or propname :org-clock=
-minutes) time) (if headline-filter (progn (save-excursion (let ((saved-mat=
ch-data (match-data))) (unwind-protect (progn (while (org-up-heading-safe) =
(put-text-property (point) (line-end-position) :org-clock-force-headline-in=
clusion t))) (set-match-data saved-match-data t)))))))) (setq t1 0) (let* (=
(l level) (--cl-var-- (1- lmax))) (while (<=3D l --cl-var--) (aset ltimes l=
 0) (setq l (+ l 1))) nil)))))))) (setq org-clock-file-total-minutes (aref =
ltimes 0))))
  (progn (let* ((re (concat "^\\(\\*+\\)[ \11]\\|^[ \11]*" org-clock-string=
 "[ \11]*\\(?:\\(\\[.*?\\]\\)-+\\(\\[.*?\\]\\)\\|=3D>[ \11]+\\([0-9]+\\):\\=
([0-9]+\\)\\)")) (lmax 30) (ltimes (make-vector lmax 0)) (level 0) (tstart =
(cond ((stringp tstart) (org-time-string-to-seconds tstart)) ((consp tstart=
) (float-time tstart)) (t tstart))) (tend (cond ((stringp tend) (org-time-s=
tring-to-seconds tend)) ((consp tend) (float-time tend)) (t tend))) (t1 0) =
time) (remove-text-properties (point-min) (point-max) (cons (or propname :o=
rg-clock-minutes) '(t :org-clock-force-headline-inclusion t))) (save-excurs=
ion (goto-char (point-max)) (while (re-search-backward re nil t) (let* ((el=
ement (let ((saved-match-data (match-data))) (unwind-protect (progn (org-el=
ement-at-point)) (set-match-data saved-match-data t)))) (element-type (org-=
element-type element))) (cond ((and (eq element-type 'clock) (match-end 2))=
 (let* ((timestamp (org-element--property :value element nil nil)) (ts (flo=
at-time (encode-time (list 0 (org-element--property :minute-start timestamp=
 nil nil) (org-element--property :hour-start timestamp nil nil) (org-elemen=
t--property :day-start timestamp nil nil) (org-element--property :month-sta=
rt timestamp nil nil) (org-element--property :year-start timestamp nil nil)=
 nil -1 nil)))) (te (float-time (encode-time (list 0 (org-element--property=
 :minute-end timestamp nil nil) (org-element--property :hour-end timestamp =
nil nil) (org-element--property :day-end timestamp nil nil) (org-element--p=
roperty :month-end timestamp nil nil) (org-element--property :year-end time=
stamp nil nil) nil -1 nil)))) (dt (- (if tend (min te tend) te) (if tstart =
(max ts tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (floor dt 60)))))=
)) ((match-end 4) (setq t1 (+ t1 (string-to-number (match-string 5)) (* 60 =
(string-to-number (match-string 4)))))) ((memq element-type '(headline inli=
netask)) (if (and org-clock-report-include-clocking-task (eq (org-clocking-=
buffer) (current-buffer)) (eq (marker-position org-clock-hd-marker) (point)=
) tstart tend (>=3D (float-time org-clock-start-time) tstart) (<=3D (float-=
time org-clock-start-time) tend)) (progn (let ((time (floor (org-time-conve=
rt-to-integer (time-since org-clock-start-time)) 60))) (setq t1 (+ t1 time)=
)))) (let* ((headline-forced (get-text-property (point) :org-clock-force-he=
adline-inclusion)) (headline-included (or (null headline-filter) (save-excu=
rsion (let ((saved-match-data (match-data))) (unwind-protect (progn (funcal=
l headline-filter)) (set-match-data saved-match-data t))))))) (setq level (=
- (match-end 1) (match-beginning 1))) (if (>=3D level lmax) (progn (progn (=
setq ltimes (vconcat ltimes (make-vector lmax 0))) (setq lmax (* 2 lmax))))=
) (if (or (> t1 0) (> (aref ltimes level) 0)) (progn (if (or headline-inclu=
ded headline-forced) (progn (if headline-included (let* ((l 0) (--cl-var-- =
level)) (while (<=3D l --cl-var--) (aset ltimes l (+ (aref ltimes l) t1)) (=
setq l (+ l 1))) nil)) (setq time (aref ltimes level)) (goto-char (match-be=
ginning 0)) (put-text-property (point) (line-end-position) (or propname :or=
g-clock-minutes) time) (if headline-filter (progn (save-excursion (let ((sa=
ved-match-data (match-data))) (unwind-protect (progn (while (org-up-heading=
-safe) (put-text-property (point) (line-end-position) :org-clock-force-head=
line-inclusion t))) (set-match-data saved-match-data t)))))))) (setq t1 0) =
(let* ((l level) (--cl-var-- (1- lmax))) (while (<=3D l --cl-var--) (aset l=
times l 0) (setq l (+ l 1))) nil)))))))) (setq org-clock-file-total-minutes=
 (aref ltimes 0)))))
  (unwind-protect (progn (let* ((re (concat "^\\(\\*+\\)[ \11]\\|^[ \11]*" =
org-clock-string "[ \11]*\\(?:\\(\\[.*?\\]\\)-+\\(\\[.*?\\]\\)\\|=3D>[ \11]=
+\\([0-9]+\\):\\([0-9]+\\)\\)")) (lmax 30) (ltimes (make-vector lmax 0)) (l=
evel 0) (tstart (cond ((stringp tstart) (org-time-string-to-seconds tstart)=
) ((consp tstart) (float-time tstart)) (t tstart))) (tend (cond ((stringp t=
end) (org-time-string-to-seconds tend)) ((consp tend) (float-time tend)) (t=
 tend))) (t1 0) time) (remove-text-properties (point-min) (point-max) (cons=
 (or propname :org-clock-minutes) '(t :org-clock-force-headline-inclusion t=
))) (save-excursion (goto-char (point-max)) (while (re-search-backward re n=
il t) (let* ((element (let ((saved-match-data (match-data))) (unwind-protec=
t (progn (org-element-at-point)) (set-match-data saved-match-data t)))) (el=
ement-type (org-element-type element))) (cond ((and (eq element-type 'clock=
) (match-end 2)) (let* ((timestamp (org-element--property :value element ni=
l nil)) (ts (float-time (encode-time (list 0 (org-element--property :minute=
-start timestamp nil nil) (org-element--property :hour-start timestamp nil =
nil) (org-element--property :day-start timestamp nil nil) (org-element--pro=
perty :month-start timestamp nil nil) (org-element--property :year-start ti=
mestamp nil nil) nil -1 nil)))) (te (float-time (encode-time (list 0 (org-e=
lement--property :minute-end timestamp nil nil) (org-element--property :hou=
r-end timestamp nil nil) (org-element--property :day-end timestamp nil nil)=
 (org-element--property :month-end timestamp nil nil) (org-element--propert=
y :year-end timestamp nil nil) nil -1 nil)))) (dt (- (if tend (min te tend)=
 te) (if tstart (max ts tstart) ts)))) (if (> dt 0) (progn (setq t1 (+ t1 (=
floor dt 60))))))) ((match-end 4) (setq t1 (+ t1 (string-to-number (match-s=
tring 5)) (* 60 (string-to-number (match-string 4)))))) ((memq element-type=
 '(headline inlinetask)) (if (and org-clock-report-include-clocking-task (e=
q (org-clocking-buffer) (current-buffer)) (eq (marker-position org-clock-hd=
-marker) (point)) tstart tend (>=3D (float-time org-clock-start-time) tstar=
t) (<=3D (float-time org-clock-start-time) tend)) (progn (let ((time (floor=
 (org-time-convert-to-integer (time-since org-clock-start-time)) 60))) (set=
q t1 (+ t1 time))))) (let* ((headline-forced (get-text-property (point) :or=
g-clock-force-headline-inclusion)) (headline-included (or (null headline-fi=
lter) (save-excursion (let ((saved-match-data (match-data))) (unwind-protec=
t (progn (funcall headline-filter)) (set-match-data saved-match-data t)))))=
)) (setq level (- (match-end 1) (match-beginning 1))) (if (>=3D level lmax)=
 (progn (progn (setq ltimes (vconcat ltimes (make-vector lmax 0))) (setq lm=
ax (* 2 lmax))))) (if (or (> t1 0) (> (aref ltimes level) 0)) (progn (if (o=
r headline-included headline-forced) (progn (if headline-included (let* ((l=
 0) (--cl-var-- level)) (while (<=3D l --cl-var--) (aset ltimes l (+ (aref =
ltimes l) t1)) (setq l (+ l 1))) nil)) (setq time (aref ltimes level)) (got=
o-char (match-beginning 0)) (put-text-property (point) (line-end-position) =
(or propname :org-clock-minutes) time) (if headline-filter (progn (save-exc=
ursion (let ((saved-match-data (match-data))) (unwind-protect (progn (while=
 (org-up-heading-safe) (put-text-property (point) (line-end-position) :org-=
clock-force-headline-inclusion t))) (set-match-data saved-match-data t)))))=
))) (setq t1 0) (let* ((l level) (--cl-var-- (1- lmax))) (while (<=3D l --c=
l-var--) (aset ltimes l 0) (setq l (+ l 1))) nil)))))))) (setq org-clock-fi=
le-total-minutes (aref ltimes 0))))) (if (or (not modified) (eq modified 'a=
utosaved)) (progn (restore-buffer-modified-p modified))))
  (let* ((modified (buffer-modified-p)) (buffer-undo-list t) (inhibit-read-=
only t) (inhibit-modification-hooks t)) (unwind-protect (progn (let* ((re (=
concat "^\\(\\*+\\)[ \11]\\|^[ \11]*" org-clock-string "[ \11]*\\(?:\\(\\[.=
*?\\]\\)-+\\(\\[.*?\\]\\)\\|=3D>[ \11]+\\([0-9]+\\):\\([0-9]+\\)\\)")) (lma=
x 30) (ltimes (make-vector lmax 0)) (level 0) (tstart (cond ((stringp tstar=
t) (org-time-string-to-seconds tstart)) ((consp tstart) (float-time tstart)=
) (t tstart))) (tend (cond ((stringp tend) (org-time-string-to-seconds tend=
)) ((consp tend) (float-time tend)) (t tend))) (t1 0) time) (remove-text-pr=
operties (point-min) (point-max) (cons (or propname :org-clock-minutes) '(t=
 :org-clock-force-headline-inclusion t))) (save-excursion (goto-char (point=
-max)) (while (re-search-backward re nil t) (let* ((element (let ((saved-ma=
tch-data (match-data))) (unwind-protect (progn (org-element-at-point)) (set=
-match-data saved-match-data t)))) (element-type (org-element-type element)=
)) (cond ((and (eq element-type 'clock) (match-end 2)) (let* ((timestamp (o=
rg-element--property :value element nil nil)) (ts (float-time (encode-time =
(list 0 (org-element--property :minute-start timestamp nil nil) (org-elemen=
t--property :hour-start timestamp nil nil) (org-element--property :day-star=
t timestamp nil nil) (org-element--property :month-start timestamp nil nil)=
 (org-element--property :year-start timestamp nil nil) nil -1 nil)))) (te (=
float-time (encode-time (list 0 (org-element--property :minute-end timestam=
p nil nil) (org-element--property :hour-end timestamp nil nil) (org-element=
--property :day-end timestamp nil nil) (org-element--property :month-end ti=
mestamp nil nil) (org-element--property :year-end timestamp nil nil) nil -1=
 nil)))) (dt (- (if tend (min te tend) te) (if tstart (max ts tstart) ts)))=
) (if (> dt 0) (progn (setq t1 (+ t1 (floor dt 60))))))) ((match-end 4) (se=
tq t1 (+ t1 (string-to-number (match-string 5)) (* 60 (string-to-number (ma=
tch-string 4)))))) ((memq element-type '(headline inlinetask)) (if (and org=
-clock-report-include-clocking-task (eq (org-clocking-buffer) (current-buff=
er)) (eq (marker-position org-clock-hd-marker) (point)) tstart tend (>=3D (=
float-time org-clock-start-time) tstart) (<=3D (float-time org-clock-start-=
time) tend)) (progn (let ((time (floor (org-time-convert-to-integer (time-s=
ince org-clock-start-time)) 60))) (setq t1 (+ t1 time))))) (let* ((headline=
-forced (get-text-property (point) :org-clock-force-headline-inclusion)) (h=
eadline-included (or (null headline-filter) (save-excursion (let ((saved-ma=
tch-data (match-data))) (unwind-protect (progn (funcall headline-filter)) (=
set-match-data saved-match-data t))))))) (setq level (- (match-end 1) (matc=
h-beginning 1))) (if (>=3D level lmax) (progn (progn (setq ltimes (vconcat =
ltimes (make-vector lmax 0))) (setq lmax (* 2 lmax))))) (if (or (> t1 0) (>=
 (aref ltimes level) 0)) (progn (if (or headline-included headline-forced) =
(progn (if headline-included (let* ((l 0) (--cl-var-- level)) (while (<=3D =
l --cl-var--) (aset ltimes l (+ (aref ltimes l) t1)) (setq l (+ l 1))) nil)=
) (setq time (aref ltimes level)) (goto-char (match-beginning 0)) (put-text=
-property (point) (line-end-position) (or propname :org-clock-minutes) time=
) (if headline-filter (progn (save-excursion (let ((saved-match-data (match=
-data))) (unwind-protect (progn (while (org-up-heading-safe) (put-text-prop=
erty (point) (line-end-position) :org-clock-force-headline-inclusion t))) (=
set-match-data saved-match-data t)))))))) (setq t1 0) (let* ((l level) (--c=
l-var-- (1- lmax))) (while (<=3D l --cl-var--) (aset ltimes l 0) (setq l (+=
 l 1))) nil)))))))) (setq org-clock-file-total-minutes (aref ltimes 0))))) =
(if (or (not modified) (eq modified 'autosaved)) (progn (restore-buffer-mod=
ified-p modified)))))
  org-clock-sum()
  eval((org-clock-sum) t)
  #f(compiled-function () #<bytecode -0x929962e206d445e>)()
  #f(compiled-function () #<bytecode -0x5db3e1955cb81d1>)()
  eval-expression((org-clock-sum) nil nil 127)
  funcall-interactively(eval-expression (org-clock-sum) nil nil 127)
  command-execute(eval-expression)


HTH, Gregor