Function frequency: Difference between revisions

 

This will, unfortunately, also catch variable names after an open paren, such as in <code>(let ...)</code> expressions.

 

(set-state-ok t)

(invoked-functions "function-freq.lisp" state)

(mv (take 10 (isort-freq-table

Output (for itself):

<pre>(((FIRST . 10)

=={{header|Arturo}}==

 

frequencies: #[]

 

inspectBlock source

 

 

=={{header|AWK}}==

# syntax: GAWK -f FUNCTION_FREQUENCY.AWK filename(s).AWK

#

}

}

<p>Output of running FUNCTION_FREQUENCY.AWK on itself:</p>

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Sort% = FN_sortinit(1,0) : REM Descending

FOR i% = 0 TO C%-1

PRINT func$(i%) " (" ; cnt%(i%) ")"

'''Output (for file LBB.BBC):'''

<pre>

=={{header|C}}==

This program treats doesn't differentiate between macros and functions. It works by looking for function calls which are not inside strings or comments. If a function call has a C style comment between the opening brace and the name of the function, this program will not recognize it as a function call.

#define _POSIX_SOURCE

#include <ctype.h>

}

return 0;

 

=={{header|Common Lisp}}==

Loading the file itself before scanning it is the quickest way to determine what function bindings would be created.

"Apply FN to all elements in TREE."

(cond ((consp tree)

(defun top-10 (table)

"Get the top 10 from the source counts TABLE."

{{out}}

<pre>CL-USER> (top-10 (count-source "function-frequency.lisp"))

=={{header|Erlang}}==

This is source code analyse. Mainly because I have never done that before.

-module( function_frequency ).

 

parse_all( _IO, {eof, _End}, Acc ) -> Acc;

parse_all( IO, {ok, Tokens, Location}, Acc ) -> parse_all( IO, io:parse_erl_form(IO, '', Location), [Tokens | Acc] ).

{{out}}

<pre>

=={{header|Factor}}==

Let's take a look at the <code>sequences</code> vocabulary/source file from Factor's standard library. This approach does not count word-defining words such as <code>:</code> and <code>M:</code>, nor does it count words like <code>{</code> and <code>[</code>.

sequences.deep source-files vocabs words ;

 

[ path>source-file top-level-form>> ]

[ vocab-words [ def>> ] [ ] map-as ] bi* compose [ word? ]

{{out}}

<pre>

=={{header|Forth}}==

Counts colon definitions, variables, constants, words defined by definers like CREATE..DOES>, etc. Check for levels of top from command line, by default 4. GForth 0.7.0 specific.

 

\ --- LIST OF CONSTANTS

\ Run, ruuun!

stdin ' run execute-parsing-file DEFS @maxfreq rings-vec over DEFS populate-by args>top# .top bye

Self test:

<pre>

=={{header|Go}}==

Only crude approximation is currently easy in Go. The following parses source code, looks for function call syntax (an expression followed by an argument list) and prints the expression.

 

import (

func (c calls) Len() int { return len(c) }

func (c calls) Swap(i, j int) { c[i], c[j] = c[j], c[i] }

Output, when run on source code above:

<pre>

Nevertheless, the quick and dirty solution may be given. It finds explicit applications which are distinguished as applications in AST while parsing the Haskell code. As soon as one will try to make this solution cleaner or more precise, ambiguity of the task will emerge immediately.

 

import Data.List.Split (splitOn)

import Data.List (nub, sortOn, elemIndices)

src <- readFile "CountFunctions.hs"

let res = sortOn (negate . fst) $ findApps src

 

<pre>*Main> main

The lowest approach taken here makes no effort to classify the primitives as monads nor dyads, nor as verbs, adverbs, nor conjunctions. Did "-" mean "additive inverse" or indicate subtraction? Does ";" raze or link? J is a multi-instruction single data language. Parentheses around a group of verbs form hooks or forks which affect data flow. The simple top10 verb does not find these important constructs. So we shall ignore them for this exercise.

 

IGNORE=: ;:'y(0)1',CR

 

│14655│@ │

└─────┴──┘

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

function funcfreqs(expr::Expr)

for (v, f) in freqs

@printf("%10s → %i\n", v, f)

 

{{out}}

=={{header|LiveCode}}==

Initially based on [http://lessons.livecode.com/m/2592/l/126343-listing-all-the-handlers-in-a-script Listing all the handlers in a script]

put pScript into pScriptCopy

filter pScript with regex pattern "^(on|function).*"

put line 1 to 10 of handlers into handlers

return handlers

 

 

put 8

return 8

factorial 2 -- user def function for other rosetta task

factorialit 2 -- user def function for other rosetta task

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}The output of applying this program to itself...<pre>programCount[programCount]

 

 

=={{header|Nim}}==

# TODO consider a more sophisticated condition on counting function callings

# without parenthesis which are common in nim lang. Be aware that the AST of

total-=1

if total == 0:

{{out}}

<pre>

=={{header|Perl}}==

We leverage the PPI::Tokenizer module.

my $Tokenizer = PPI::Tokenizer->new( '/path/to/your/script.pl' );

my %counts;

foreach my $token (@top_ten_by_occurrence) {

print $counts{$token}, "\t", $token, "\n";

{{out}}

When run on itself:

As Phix is self hosted, we can modify the compiler (or a copy of it) directly for this task.<br>

Add the line shown to procedure Call() in pmain.e, after the else on line 4938 (at the time of writing)

<span style="color: #008080;">else</span> <span style="color: #000080;font-style:italic;">-- rType=FUNC|TYPE</span>

<span style="color: #000000;">log_function_call</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rtnNo</span><span style="color: #0000FF;">)</span>

(I may have been a bit too literal about "function" here, specifically "not procedure")

 

Now create our test.exw program, which wraps the entire compiler:

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o, etc...</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">func_log</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">(),</span>

<span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #000000;">visitor</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">func_log</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- invert</span>

<span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #000000;">visitor</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">func_freq</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rev</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- top 10</span>

Invoke using "p test -norun test" (note you can omit the ".exw" part of "test.exw")

{{out}}

 

=={{header|PicoLisp}}==

(for "L" (filter pair (extract getd (all)))

(for "F"

(accu 'Freq "F" 1) ) )

(for X (head 10 (flip (by cdr sort Freq)))

Output, for the system in debug mode plus the above code:

<pre>quote 310

{{works with|Python|3.x}}

This code parses a Python source file using the built-in '''ast''' module and counts simple function calls; it won't process method calls or cases when you call the result of an expression. Also, since constructors are invoked by calling the class, constructor calls are counted as well.

 

class CallCountingVisitor(ast.NodeVisitor):

for name, count in top10:

print(name,'called',count,'times')

 

The result of running the program on the ftplib module of Python 3.2:

 

=={{header|Racket}}==

#lang racket

(require math)

(define counts (sort (hash->list (samples->hash symbols)) >= #:key cdr))

(take counts (min 10 (length counts)))

Output:

'((define . 4)

(counts . 3)

(in-port . 1)

(sort . 1))

 

=={{header|Raku}}==

(formerly Perl 6)

Here we just examine the ast of the Raku compiler (which is written in Raku) to look for function calls.

my %fun;

for $text.lines {

}

 

{{out}}

Here we run it on the strand sort RC entry. Note how Raku considers various operators to really be function calls underneath.

===version 1===

This program counts statically. It lacks, however, treatment of comments and literal strings.

cnt.=0

funl=''

If cnt.fun=1 Then

funl=funl fun

{{out}}

<pre> 1 lines

Contents of comments and literal strings are not analyzed.

Neither are function invocations via CALL.

* Rexx Tokenizer to find function invocations

*-----------------------------------------------------------------------

End

If errtxt<>'' Then Say ' 'errtxt

{{out}}

Result for the above program.

=={{header|Sidef}}==

Sidef provides full access to its parser, allowing us to inspect all the declarations within a program.

func bar { }

 

" #{entry{:line}}) is used #{entry{:count}} times")

}

 

{{out}}

This parses all classes of all loaded packages/libraries (takes a few seconds). From the code, it should be obvious how to restrict the search to packages, libraries, classes or individual methods.

 

Smalltalk allClassesDo:[:cls |

cls instAndClassMethodsDo:[:mthd |

(bagOfCalls sortedCounts to:10) do:[:assoc |

Stdout printCR: e'method {assoc value} is called {assoc key} times.'

note: messagesSent calls the parser for an AST and enumerates the parse nodes; it does not know, which get inlined and which end up being called actually (in fact, most of the one's below are probably inlined).

 

 

=={{header|Tcl}}==

 

proc examine {filename} {

foreach {cmd count} [lrange $cmdinfo 0 19] {

puts [format "%-20s%d" $cmd $count]

Sample run (note that the commands found are all standard Tcl commands; they're ''just'' commands so it is natural to expect them to be found):

<pre>

 

In the absence of any other feasible approach, we simply search for method/function calls in a given Wren source file and count them to find the 'top ten'.

import "os" for Process

import "/pattern" for Pattern

for (mc in methodCalls.take(10)) {

Fmt.print(" $2d $s", mc.value, mc.key)

 

{{out}}