Reflection/Get source: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(20 intermediate revisions by 12 users not shown) | |||
Line 3:
{{omit from|C++}}
{{omit from|Modula-2}}
{{omit from|Rust}}
;Task:
The goal is to get the source code or file path and line number where a programming object (e.g. module, class, function, method) is defined.
<br><br>
=={{header|6502 Assembly}}==
A printing routine that can convert hex digits to ASCII characters can point to the address of a subroutine and start printing from there.
Such a printing routine would work best if it substituted the null terminator for $60 (the <code>RTS</code> instruction.) This would only print the bytecode for the routine. Conversion to assembly language would need to be done separately.
<syntaxhighlight lang="6502asm">LDA #<foo
sta $00
LDA #>foo
sta $01
jsr PrintBytecode
foo:
;do stuff
rts
PrintBytecode:
ldy #0
lda $01 ;high byte of starting address of the source
jsr PrintHex
;unimplemented routine that separates the "nibbles" of the accumulator,
; adds $30 or $37 to each depending on if it's 0-9 or A-F respectively, which converts hex to ASCII,
; then prints the high nibble then the low.
lda $00 ;low byte of the starting address of the source
jsr PrintHex
jsr NewLine ;unimplemented new line routine
loop:
lda ($00),y
cmp #$60
beq Terminated
jsr PrintHex
jmp loop
Terminated:
jsr PrintHex ;print the last instruction of the routine.
rts</syntaxhighlight>
There is no way to get the file name that the routine is stored in. Whether you use a linker or <code>include</code> statements, this information is lost by the time the code is assembled into an executable form.
=={{header|Clojure}}==
<
; Use source function for source code.
(source println)
; Use meta function for filenames and line numbers (and other metadata)
(meta #'println)</
=={{header|Factor}}==
Printing definitions:
<
\ integer see ! class
nl
\ dip see ! word</
{{out}}
<pre>
Line 32 ⟶ 72:
</pre>
Obtaining the code that makes up a word as a quotation (an anonymous function/collection that stores code):
<
\ partition def>> .</
{{out}}
<pre>
Line 39 ⟶ 79:
</pre>
Obtaining the vocabulary name a word belongs to:
<
\ dip vocabulary>> print</
{{out}}
<pre>
Line 46 ⟶ 86:
</pre>
Obtaining file paths for a particular vocabulary:
<
"sequences" vocab-files .</
{{out}}
<pre>
Line 55 ⟶ 95:
"resource:core/sequences/sequences-tests.factor"
}
</pre>
Obtaining the path and line number where a word is defined:
<syntaxhighlight lang="factor">"loc" \ dip props>> at</syntaxhighlight>
{{out}}
<pre>
{ "resource:core/kernel/kernel.factor" 111 }
</pre>
Line 63 ⟶ 109:
This is mainly useful for debugging purposes. Here's a simple example :
<
Sub Proc()
Line 70 ⟶ 116:
Proc()
Sleep</
{{out}}
<pre>
PROC is defined in c:\FreeBasic\getsource.bas at line 3
</pre>
=={{header|Go}}==
It is possible to get the file name/path and line number of a given function in Go as follows.
<syntaxhighlight lang="go">package main
import (
"fmt"
"path"
"reflect"
"runtime"
)
func someFunc() {
fmt.Println("someFunc called")
}
func main() {
pc := reflect.ValueOf(someFunc).Pointer()
f := runtime.FuncForPC(pc)
name := f.Name()
file, line := f.FileLine(pc)
fmt.Println("Name of function :", name)
fmt.Println("Name of file :", path.Base(file))
fmt.Println("Line number :", line)
}</syntaxhighlight>
{{out}}
<pre>
Name of function : main.someFunc
Name of file : reflection_get_source.go
Line number : 10
</pre>
Line 85 ⟶ 163:
Examples:
<
5!:5 <'mean'
+/ % #
Line 97 ⟶ 175:
┌────────────────────────────────────────────┐
│/Applications/j64-804/system/main/stdlib.ijs│
└────────────────────────────────────────────┘</
We could also provide convenience functions for these mechanisms:
<
srcfile=: (4!:4@<) { a:,~ 4!:3 bind ''</
Example use:
<
list_z_@nl
srcfile 'names'
Line 115 ⟶ 193:
┌┐
││
└┘</
Note that these mechanisms can be disabled (using [http://www.jsoftware.com/help/dictionary/dx003.htm 3!:6]).
=={{header|Java}}==
A java exception will contain a list of <code>StackTraceElement</code>'s. Each element is one method call in the call stack. The element contains information on the location of the code. Samples are shown below.
Note that the file name is not the absolute path on the file system, but is relative to the java CLASSPATH.
<syntaxhighlight lang="java">
public class ReflectionGetSource {
public static void main(String[] args) {
new ReflectionGetSource().method1();
}
public ReflectionGetSource() {}
public void method1() {
method2();
}
public void method2() {
method3();
}
public void method3() {
Throwable t = new Throwable();
for ( StackTraceElement ste : t.getStackTrace() ) {
System.out.printf("File Name = %s%n", ste.getFileName());
System.out.printf("Class Name = %s%n", ste.getClassName());
System.out.printf("Method Name = %s%n", ste.getMethodName());
System.out.printf("Line number = %s%n%n", ste.getLineNumber());
}
}
}
</syntaxhighlight>
{{out}}
<pre>
File Name = ReflectionGetSource.java
Class Name = ReflectionGetSource
Method Name = method3
Line number = 20
File Name = ReflectionGetSource.java
Class Name = ReflectionGetSource
Method Name = method2
Line number = 16
File Name = ReflectionGetSource.java
Class Name = ReflectionGetSource
Method Name = method1
Line number = 12
File Name = ReflectionGetSource.java
Class Name = ReflectionGetSource
Method Name = main
Line number = 5
</pre>
=={{header|JavaScript}}==
<code>Function.toString()</code> will return the source code for user-defined functions.
<
foo.toString();
// "function foo() {...}"
</syntaxhighlight>
For native functions, the function body typically will be a syntactically invalid string indicating the function is native. This behavior isn't part of any ECMAScript standard, but is common practice.
<
// "function sqrt() { [native code] }"
</syntaxhighlight>
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
function foo() end
@which foo() # where foo is defined
@less foo() # first file where foo is defined</
=={{header|Kotlin}}==
Line 148 ⟶ 286:
2. In the example below the ''hello'' function will actually be referred to as ''_.hello'' in the generated JavaScript from within the main() function.
<
fun hello() {
Line 158 ⟶ 296:
println(code)
}
</syntaxhighlight>
{{out}}
Line 174 ⟶ 312:
but in each movie script all function names must be unique. So it's not too hard to manually
find the line number for a specific function in the returned code (e.g. using a RegExp).
<
-- Returns source code either for a class (parent script) or a class instance (object)
-- @param {script|instance} class
Line 198 ⟶ 336:
end repeat
end repeat
end</
Usage:
<
put getClassCode(obj)
-- script text is printed...
Line 206 ⟶ 344:
func = #startMovie
put getGlobalFunctionCode(func)
-- script text is printed...</
=={{header|
Introspective capabilities are provided by the debug library..
<syntaxhighlight lang="lua">debug = require("debug")
function foo(bar)
info = debug.getinfo(1)
for k,v in pairs(info) do print(k,v) end
end
foo()</syntaxhighlight>
{{out}}
<pre>linedefined 2
func function: 0000000000d8d670
currentline 3
source @reflection.lua
lastlinedefined 5
short_src reflection.lua
what Lua
namewhat global
nparams 0
isvararg false
name foo
istailcall false
nups 1</pre>
=={{header|Nanoquery}}==
If a program is run from the command line, the absolute path of the source file will be stored in __file__ as a string.
<syntaxhighlight lang="nanoquery">import Nanoquery.IO
println new(File, __file__).readAll()</syntaxhighlight>
=={{header|Nim}}==
<syntaxhighlight lang="nim">import macros, strformat
proc f(arg: int): int = arg+1
macro getSource(source: static[string]) =
let module = parseStmt(source)
for node in module.children:
if node.kind == nnkProcDef:
echo(&"source of procedure {node.name} is:\n{toStrLit(node).strVal}")
proc g(arg: float): float = arg*arg
getSource(staticRead(currentSourcePath()))</syntaxhighlight>
{{out}}
<pre>source of procedure f is:
proc f(arg: int): int =
arg + 1
source of procedure g is:
proc g(arg: float): float =
arg * arg
</pre>
=={{header|Perl}}==
<syntaxhighlight lang="perl"># 20211213 Perl programming solution
use strict;
use warnings;
use Class::Inspector;
print Class::Inspector->resolved_filename( 'IO::Socket::INET' ), "\n";
</syntaxhighlight>
{{out}}
<pre>/home/hkdtam/perl5/perlbrew/perls/perl-5.30.0/lib/5.30.0/x86_64-linux/IO/Socket/INET.pm
</pre>
Line 243 ⟶ 433:
"C:\\Program Files (x86)\\Phix\\"}
</pre>
or the directories where your project is located.
A caught exception (see the documentation for throw) contains the line number, file, and path (with the same caveat as above when installed elsewhere).
The file pincpathN.e also shows you how to get your grubby little mitts on the symbol table, and you may also want to look at builtins/VM/prtnidN.e for some ideas on scanning that. Throwing and catching an exception is one way to ensure the symbol table is populated with proper names rather than obscure integer ternary tree indexes. See pglobals.e for detailed notes about the contents of the symbol table. Some caution is advised here; the compiler
Of course the source files are just files that you can read like any other text files, and for all its detail, the symbol table contains very little in the way of context, which may make mapping of non-unique identifiers rather difficult.
Line 253 ⟶ 443:
=={{header|Python}}==
Modules loaded from files have a <code>__file__</code> attribute.
<
os.__file__
# "/usr/local/lib/python3.5/os.pyc"
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2016.11}}
A full path is provided for built-in routines/methods. However for routines exported by pre-compiled modules a precompilation hash is returned, not a proper file path.
<syntaxhighlight lang="raku" line>say &sum.file;
say Date.^find_method("day-of-week").file;</syntaxhighlight>
{{out}}
<pre>
SETTING::src/core/Any.pm
SETTING::src/core/Dateish.pm
</pre>
=={{header|REXX}}==
This REXX version was modeled after the '''zkl''' example, but in addition, it also displays the source.
<
/*───────────────────────── displays the number of lines. */
#=sourceline()
Line 271 ⟶ 477:
say 'The name of the source file (program) is: ' sID
say 'The number of lines in the source program: ' #
/*stick a fork in it, we're all done.*/</
{{out|output|:}}
<pre>
Line 292 ⟶ 498:
=={{header|Ring}}==
<
# Project : Reflection/Get source
Line 320 ⟶ 526:
end
fclose(fp)
</syntaxhighlight>
Output:
<pre>
Line 329 ⟶ 535:
=={{header|Ruby}}==
<code>[http://ruby-doc.org/core/Method.html#method-i-source_location Method#source_location]</code> will return the file and line number of a Ruby method. If a method wasn't defined in Ruby, <code>Method#source_location</code> returns nil.
<
Math.method(:sqrt).source_location
# ["/usr/local/lib/ruby2.3/2.3.0/mathn.rb", 119]
Line 335 ⟶ 541:
Class.method(:nesting).source_location
# nil, since Class#nesting is native
</syntaxhighlight>
=={{header|Smalltalk}}==
You can ask a class for a method:
<syntaxhighlight lang="smalltalk">mthd := someClass compiledMethodAt:#nameOfMethod</syntaxhighlight>
and a method for its source:
<syntaxhighlight lang="smalltalk">mthd source</syntaxhighlight>
or better yet, you can ask any active stack frame for its method, source and line number (what is the line number of the "current PC" if you like):
<syntaxhighlight lang="smalltalk">thisContext method source
thisContext lineNumber</syntaxhighlight>
so, a Logger could (actually: does) print a log-message with:
Stderr print: e'{msg} generated in {thisContext sender selector} line: {thisContext sender lineNumber}'.
Stderr print: e'generated by the following source line: {thisContext sender method source asStringCollection at:thisContext sender lineNumber}'.
=={{header|Tcl}}==
Tcl's <tt>info</tt> command makes it possible to access the source of nearly anything. This example can show the source code of any proc. The popular <b>tkcon</b> includes a <tt>dump</tt> command which is capable of showing aliases, arrays and more .. and a <tt>edit</tt> command which lets you edit them in an interactive window!
<
set name [uplevel 1 [list namespace which -command $name]]
set args [info args $name]
Line 354 ⟶ 573:
}
puts [getproc getproc]</
{{out}}
Note the output differs very slightly from the original source: the procedure's name is fully namespace-qualified, and the arguments are in "canonical list form", which does not include braces in this simple case.
<
set name [uplevel 1 [list namespace which -command $name]]
set args [info args $name]
Line 371 ⟶ 590:
set body [info body $name]
list proc $name $args $body
}</
=={{header|Wren}}==
{{libheader|Wren-pattern}}
Wren doesn't have reflection as such but the command line version (Wren CLI) does have an easy way to obtain a script's own source code which can then be searched for where an object is defined
<syntaxhighlight lang="wren">import "os" for Platform, Process
import "io" for File
import "/.pattern" for Pattern
var getSourceLines = Fn.new {
var fileName = Process.allArguments[1]
var text = File.read(fileName)
var sep = Platform.isWindows ? "\r\n" : "\n"
return [fileName, text.split(sep)]
}
var res = getSourceLines.call()
var fileName = res[0]
var lines = res[1]
// look for getSourceLines function
var funcName = "getSourceLines"
var p = Pattern.new("+1/s")
var i = 1
var found = 0
for (line in lines) {
var t = p.splitAll(line.trim())
if (t[0] == "var" && t[1] == funcName && t[2] == "=" && t[3] == "Fn.new") {
found = i
break
}
i = i + 1
}
System.print("File name : %(fileName)")
System.print("Function name : %(funcName)")
System.print("Line number : %(found > 0 ? found : "Function not found")")</syntaxhighlight>
{{out}}
<pre>
File name : Reflection_get_source.wren
Function name : getSourceLines
Line number : 5
</pre>
=={{header|zkl}}==
Reads the source file and counts the lines.
<
println("Src file is \"%s\" and has %d lines".fmt(__FILE__,src.len(1)));</
{{out}}
<pre>
|