-(* Copyright (C) 2000, HELM Team.
- *
- * This file is part of HELM, an Hypertextual, Electronic
- * Library of Mathematics, developed at the Computer Science
- * Department, University of Bologna, Italy.
- *
- * HELM is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * HELM is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HELM; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- * MA 02111-1307, USA.
- *
- * For details, see the HELM World-Wide-Web page,
- * http://cs.unibo.it/helm/.
- *)
+(*
+ ||M|| This file is part of HELM, an Hypertextual, Electronic
+ ||A|| Library of Mathematics, developed at the Computer Science
+ ||T|| Department, University of Bologna, Italy.
+ ||I||
+ ||T|| HELM is free software; you can redistribute it and/or
+ ||A|| modify it under the terms of the GNU General Public License
+ \ / version 2 or (at your option) any later version.
+ \ / This software is distributed as is, NO WARRANTY.
+ V_______________________________________________________________ *)
type id = string (* identifier *)
-type qid = id * bool * id list (* qualified identifier: name, is local?, qualifiers *)
+type qid = id * bool * id list (* qualified identifier: name, local?, path *)
type term = Sort of bool (* sorts: true = TYPE, false = PROP *)
| GRef of qid * term list (* reference: name, arguments *)
| NL { () }
| OC { block_comment lexbuf; line_comment lexbuf }
| _ { line_comment lexbuf }
- | eof { () }
+ | eof { () }
and block_comment = parse
| CC { () }
| OC { block_comment lexbuf; block_comment lexbuf }
| LC { line_comment lexbuf; block_comment lexbuf }
| _ { block_comment lexbuf }
- | eof { () }
and token = parse
| SPC { token lexbuf }
| LC { line_comment lexbuf; token lexbuf }
grefs: int;
appls: int;
absts: int;
- pars: int
+ pars: int;
+ xnodes: int
}
let initial_counters = {
sections = 0; contexts = 0; blocks = 0; decls = 0; defs = 0;
- sorts = 0; grefs = 0; appls = 0; absts = 0; pars = 0
+ sorts = 0; grefs = 0; appls = 0; absts = 0; pars = 0; xnodes = 0
}
let rec count_term f c = function
| A.Sort _ ->
- f {c with sorts = succ c.sorts}
+ f {c with sorts = succ c.sorts; xnodes = succ c.xnodes}
| A.GRef (_, ts) ->
let c = {c with grefs = succ c.grefs} in
let c = {c with pars = c.pars + List.length ts} in
+ let c = {c with xnodes = succ c.xnodes + List.length ts} in
Cps.list_fold_left f count_term c ts
| A.Appl (v, t) ->
- let c = {c with appls = succ c.appls} in
+ let c = {c with appls = succ c.appls; xnodes = succ c.xnodes} in
let f c = count_term f c t in
count_term f c v
| A.Abst (_, w, t) ->
- let c = {c with absts = succ c.absts} in
+ let c = {c with absts = succ c.absts; xnodes = succ c.xnodes} in
let f c = count_term f c t in
count_term f c w
| A.Context _ ->
f {c with contexts = succ c.contexts}
| A.Block (_, w) ->
- let c = {c with blocks = succ c.blocks} in
+ let c = {c with blocks = succ c.blocks; xnodes = succ c.xnodes} in
count_term f c w
| A.Decl (_, w) ->
- let c = {c with decls = succ c.decls} in
+ let c = {c with decls = succ c.decls; xnodes = succ c.xnodes} in
count_term f c w
| A.Def (_, w, _, t) ->
- let c = {c with defs = succ c.defs} in
+ let c = {c with defs = succ c.defs; xnodes = succ c.xnodes} in
let f c = count_term f c t in
count_term f c w
L.warn (P.sprintf " Reference items: %7u" c.grefs);
L.warn (P.sprintf " Application items: %7u" c.appls);
L.warn (P.sprintf " Abstraction items: %7u" c.absts);
+ L.warn (P.sprintf " Global Int. Complexity: unknown");
+ L.warn (P.sprintf " + Abbreviation nodes: %7u" c.xnodes);
f ()
let f a = list_fold_left2 f map a tl1 tl2 in
map f a hd1 hd2
| _ -> assert false
+
+let rec list_mem ?(eq=(=)) a = function
+ | [] -> false
+ | hd :: _ when eq a hd -> true
+ | _ :: tl -> list_mem ~eq a tl
pappls: int;
tappls: int;
tabsts: int;
+ uris : U.uri list;
+ nodes : int;
+ xnodes: int
}
let initial_counters = {
eabsts = 0; eabbrs = 0; pabsts = 0; pappls = 0;
- tsorts = 0; tlrefs = 0; tgrefs = 0; tappls = 0; tabsts = 0
+ tsorts = 0; tlrefs = 0; tgrefs = 0; tappls = 0; tabsts = 0;
+ uris = []; nodes = 0; xnodes = 0
}
let rec count_term f c = function
| M.Sort _ ->
- f {c with tsorts = succ c.tsorts}
+ f {c with tsorts = succ c.tsorts; nodes = succ c.nodes}
| M.LRef _ ->
- f {c with tlrefs = succ c.tlrefs}
- | M.GRef (_, _, ts) ->
+ f {c with tlrefs = succ c.tlrefs; nodes = succ c.nodes}
+ | M.GRef (_, u, ts) ->
let c = {c with tgrefs = succ c.tgrefs} in
let c = {c with pappls = c.pappls + List.length ts} in
+ let c = {c with nodes = c.nodes + List.length ts} in
+ let c =
+ if Cps.list_mem ~eq:U.eq u c.uris
+ then {c with nodes = succ c.nodes}
+ else {c with xnodes = succ c.xnodes}
+ in
Cps.list_fold_left f count_term c ts
| M.Appl (v, t) ->
- let c = {c with tappls = succ c.tappls} in
+ let c = {c with tappls = succ c.tappls; nodes = succ c.nodes} in
let f c = count_term f c t in
count_term f c v
| M.Abst (_, w, t) ->
- let c = {c with tabsts = succ c.tabsts} in
+ let c = {c with tabsts = succ c.tabsts; nodes = succ c.nodes} in
let f c = count_term f c t in
count_term f c w
-let count_par f c (_, w) = count_term f c w
+let count_par f c (_, w) =
+ let c = {c with nodes = succ c.nodes} in
+ count_term f c w
let count_entry f c = function
- | _, pars, _, w, None ->
+ | _, pars, u, w, None ->
let c = {c with eabsts = succ c.eabsts} in
let c = {c with pabsts = c.pabsts + List.length pars} in
+ let c = {c with uris = u :: c.uris; nodes = succ c.nodes + List.length pars} in
let f c = count_term f c w in
Cps.list_fold_left f count_par c pars
| _, pars, _, w, Some (_, v) ->
- let c = {c with eabbrs = succ c.eabbrs} in
+ let c = {c with eabbrs = succ c.eabbrs; xnodes = succ c.xnodes} in
let c = {c with pabsts = c.pabsts + List.length pars} in
+ let c = {c with nodes = c.nodes + List.length pars} in
let f c = count_term f c v in
let f c = count_term f c w in
Cps.list_fold_left f count_par c pars
let terms = c.tsorts + c.tgrefs + c.tgrefs + c.tappls + c.tabsts in
let pars = c.pabsts + c.pappls in
let items = c.eabsts + c.eabbrs in
+ let nodes = c.nodes + c.xnodes in
L.warn (P.sprintf " Intermediate representation summary");
L.warn (P.sprintf " Total entry items: %7u" items);
L.warn (P.sprintf " Declaration items: %7u" c.eabsts);
L.warn (P.sprintf " Global reference items: %7u" c.tgrefs);
L.warn (P.sprintf " Application items: %7u" c.tappls);
L.warn (P.sprintf " Abstraction items: %7u" c.tabsts);
+ L.warn (P.sprintf " Global Int. Complexity: %7u" c.nodes);
+ L.warn (P.sprintf " + Abbreviation nodes: %7u" nodes);
f ()
let string_of_sort = function
projects / helm.git / commitdiff