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)

(LIST . 3))

<state>)</pre>

 

=={{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>

$

</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>

append 1

</pre>

 

=={{header|J}}==

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]

 

{{Slot, 3}, {Pattern, 2}, {fn, 2}, {Blank, 2}, {\[Infinity], 1}, {True, 1}, {Tally, 1}, {Take, 1}, {Symbol, 1}, {SortBy, 1}}</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)

(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:

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.

1 wordsort

0.093000 seconds elapsed for 2200 tokens in 510 lines.</pre>

 

=={{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}}

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

 

Smalltalk allClassesDo:[:cls |

cls instAndClassMethodsDo:[:mthd |

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

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

{{out}}

<pre>method ifTrue:is called 19805 times.

 

=={{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>

lappend 351

</pre><!-- note that it's certainly possible that not all commands are found; break and continue are likely underrepresented -->