Program name: Difference between revisions
Add Ecstasy example
Thundergnat (talk | contribs) m (Fix Perl 6 -> Raku in comments) |
(Add Ecstasy example) |
||
(30 intermediate revisions by 20 users not shown) | |||
Line 7:
Examples from [https://github.com/mcandre/scriptname GitHub].
=={{header|11l}}==
<syntaxhighlight lang="11l">:start:
print(‘Program: ’:argv[0])</syntaxhighlight>
=={{header|68000 Assembly}}==
{{works with|NEOGEO}}
The name of the game is stored on the cartridge at memory address $000200. It is exactly 16 characters and is padded with spaces (ASCII 32). Since there is no null terminator after this string, use its size to terminate a printing loop.
<syntaxhighlight lang="68000devpac">LEA $000200,A3
JSR PrintString ;(my print routine is 255-terminated and there just so happens to be an FF after the name of the game.)</syntaxhighlight>
;Output
[[https://ibb.co/4jNm7TW Ninja Adventure]]
=={{header|AArch64 Assembly}}==
Line 14 ⟶ 27:
Without built-in CRT, <code>argc</code> and <code>argv</code> are stored in the stack. The format looks like:
<syntaxhighlight lang="text">sp+0 = argc
sp+8 = argv[0]
sp+16 = argv[1] ...</
Each item of <code>argv</code> is a pointer to a null-terminated 8-bit string.
<
.equ SVC_WRITE, 64
.equ SVC_EXIT, 93
Line 63 ⟶ 76:
_exit:
mov x8, #SVC_EXIT
svc #0</
=={{header|Ada}}==
Being a compiled language, Ada has difficulties accessing source code filenames. But it is easy to access the executable's filename, using the function Command_Name defined in Ada.Command_Line:
<
procedure Command_Name is
begin
Ada.Text_IO.Put_Line(Ada.Command_Line.Command_Name);
end Command_Name;</
=={{header|Aime}}==
The program command line arguments are accessible via the argc()/argv() functions. The program name is the first in the list of arguments.
<
o_byte('\n');</
=={{header|ALGOL 68}}==
<syntaxhighlight lang="text">
BEGIN
print ((program idf, newline))
END
</syntaxhighlight>
{{out}}
<pre>
$ a68g Program_name.a68
Program_name.a68
$
</pre>
=={{header|Amazing Hopper}}==
El primer parámetro en Hopper y sus sabores, siempre será el nombre del programa.
<syntaxhighlight lang="amazing hopper">
#include <hbasic.h>
Begin
GetParam(name File)
Print("My Program name: ", name File,Newl)
End
</syntaxhighlight>
{{out}}
<pre>
$ hopper myname.bas
My Program name: myname.bas
$
</pre>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="applesoftbasic">
10 GOSUB 40"GET PROGRAM NAME
20 PRINT N$
Line 155 ⟶ 184:
670 N$ = "
680 RETURN
</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 215 ⟶ 244:
bx lr /* retour procedure */
</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">
MsgBox, % A_ScriptName
</syntaxhighlight>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: TAWK -f PROGRAM_NAME.AWK
#
Line 242 ⟶ 271:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 261 ⟶ 290:
Unlike most MS BASICs, [[FreeBASIC]] provides a parsed version of <code>[http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgCommand COMMAND$]</code> (called as <code>COMMAND$(n)</code>). <code>COMMAND$(0)</code> is the program's name:
<
Additionally, FreeBASIC also provides an analog of [[#C|C's]] <code>argc/argv[]</code>, called <code>[http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgDdfbargc __FB_ARGC__]</code> and <code>[http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgDdfbargv __FB_ARGV__]</code>. __FB_ARGV__ can be used to get the program's name like this:
<
See also: [[#PowerBASIC|PowerBASIC]], [[#PureBasic|PureBasic]], [[#Visual Basic|Visual Basic]].
Line 270 ⟶ 299:
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
PRINT $$cl%</
==={{header|IS-BASIC}}===
<
110 CHAIN "Name2.BAS"(A,B,C,S$)
Line 282 ⟶ 311:
edit 0
start(1,2,3,"Hello")</
==={{header|BaCon}}===
To get the name with which the program was invoked:
<syntaxhighlight lang="bacon">PRINT TOKEN$(ARGUMENT$, 1)</syntaxhighlight>
To get the full path:
<syntaxhighlight lang="bacon">PRINT ME$</syntaxhighlight>
==={{header|uBasic/4tH}}===
'''CMD(1)''' returns a string with the filename - '''SHOW()''' prints this string.
<syntaxhighlight lang="text">Print Show(Cmd(1))</syntaxhighlight>
=={{header|Blue}}==
Linux/x86-64. Will print the name of the executable from "argv[0]" as provided.
<syntaxhighlight lang="blue">global _start
: syscall ( num:eax -- result:eax ) syscall ;
: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;
: write ( buf:esi len:edx fd:edi -- ) 1 syscall drop ;
1 const stdout
: print ( buf len -- ) stdout write ;
: newline ( -- ) s" \n" print ;
: println ( buf len -- ) print newline ;
: find0 ( start:rsi -- end:rsi ) lodsb 0 cmp latest xne ;
: cstrlen ( str:rdi -- len:rsi ) dup find0 swap sub dec ;
: cstr>str ( cstr:rdx -- str:rsi len:rdx ) dup cstrlen xchg ;
: print-arg ( arg -- ) cstr>str println ;
: arg0 ( rsp -- rsp ) 8 add @ ; inline
: _start ( rsp -- noret ) arg0 print-arg bye ;</syntaxhighlight>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">•name</syntaxhighlight>
=={{header|C}}==
Line 289 ⟶ 360:
* <code>argv[0]</code> might be the name of an executable in the PATH, or it might be an absolute or relative path to the executable. At least with [[Unix]], the parent process can set <code>argv[0]</code> to any string, so <code>argv[0]</code> might not be the real name. It is best to pretend that <code>argv[0]</code> has the correct value, but mind that <code>argv[0]</code> might not be an actual file.
<
int main(int argc, char **argv) {
Line 295 ⟶ 366:
return 0;
}</
To get the source information about some part of code, use compiler defined macros. Most compilers support them or some variation of.
<
int main()
Line 305 ⟶ 376:
__FILE__, __FUNCTION__, __LINE__);
return 0;
}</
=== BSD ===
Line 318 ⟶ 389:
{{works with|OpenBSD|5.0}} '''To compile myname.c:''' <code>make myname LDLIBS=-lkvm</code>
<
#include <sys/param.h>
Line 354 ⟶ 425:
kvm_close(kd);
return 0;
}</
The program can have three different names!
Line 367 ⟶ 438:
{{libheader|Win32}}
<
#include <stdlib.h>
#include <wchar.h>
Line 423 ⟶ 494:
free(path);
return 0;
}</
<pre>Path to executable: C:\Users\kernigh\Documents\field\scratch.exe</pre>
Line 429 ⟶ 500:
=={{header|C sharp|C#}}==
This effectively outputs the executable name, file path, and any arguments for the current program.
<
namespace ProgramName
{
Line 439 ⟶ 510:
}
}
}</
In a C# application with a reference to System.Windows.Forms, the following can be used to retrieve the executable name and arguments without the full path.
<
namespace ProgramName
{
Line 459 ⟶ 530:
}
}
}</
=={{header|C++}}==
<
using namespace std;
Line 471 ⟶ 542:
char *program = argv[0];
cout << "Program: " << program << endl;
}</syntaxhighlight>
=={{header|Clojure}}==
<
":";exit
Line 487 ⟶ 556:
(when (.contains (first *command-line-args*) *source-path*)
(apply -main (rest *command-line-args*)))</
=={{header|COBOL}}==
Line 493 ⟶ 562:
COBOL has an internal PROGRAM-ID name, and then the external invocation name.
<
program-id. sample.
Line 510 ⟶ 579:
goback.
end program sample.</
{{out}}
Line 519 ⟶ 588:
=={{header|CoffeeScript}}==
scriptname.coffee:
<
main = () ->
Line 525 ⟶ 594:
console.log "Program: " + program
if not module.parent then main()</
=={{header|Common Lisp}}==
Shebangs require a special tweak to ~/.clisprc.lisp.
<
(set-dispatch-macro-character #\# #\!
(lambda (stream character n)
(declare (ignore character n))
(read-line stream nil nil t)
nil))</
<
#|
exec clisp -q -q $0 $0 ${1+"$@"}
Line 566 ⟶ 635:
args
:test #'(lambda (x y) (search x y :test #'equalp)))
(main args)))</
=={{header|D}}==
<
import std.stdio;
Line 575 ⟶ 644:
void main(in string[] args) {
writeln("Program: ", args[0]);
}</
{{out}}
<pre>C:\rosetta>program_name.exe
Program: program_name.exe</pre>
<
$ ./scriptname
Program: ./scriptname</
If the system is configured, the D programming language offers an 'interpreted-looking' mode, which exhibits slightly different behavior than the normal compilation:
<
Program: /tmp/.rdmd/Users/andrew/Desktop/src/scriptname/scriptname.d.D3B32385A31B968A3CF8CAF1E1426E5F</
Alternative method using built-in function [http://dlang.org/changelog.html#current_path thisExePath()]
{{works with|D|2.064+}}
<
import std.file;
Line 599 ⟶ 668:
{
writeln("Program: ", thisExePath());
}</
{{out}} <pre>Z:\rosettacode>program_name.exe
Program: Z:\rosettacode\program_name.exe</pre>
=={{header|Dart}}==
<
main() {
var program = new Options().script;
print("Program: ${program}");
}</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 619 ⟶ 688:
Writeln('Program name: ' + ParamStr(0));
Writeln('Command line: ' + CmdLine);
end.</
=={{header|Déjà Vu}}==
<
=={{header|EchoLisp}}==
<
(js-eval "window.location.href")
→ "http://www.echolalie.org/echolisp/"
</syntaxhighlight>
=={{header|Ecstasy}}==
<syntaxhighlight lang="ecstasy">
module WhatIsMyName {
@Inject Console console;
void run() {
console.print($"program name: {this:module}");
}
}
</syntaxhighlight>
{{out}}
<pre>
program name: WhatIsMyName
</pre>
=={{header|Elena}}==
ELENA 4.x :
<
public program()
Line 640 ⟶ 725:
console.printLine(program_arguments[0]); // the program name
}</
=={{header|Emacs Lisp}}==
<
;;; Shebang from John Swaby
Line 649 ⟶ 734:
(defun main ()
(message "Program: %s" program)))</
<code>load-file-name</code> is the ".el" or ".elc" currently being loaded. Within a batch <code>-l</code> it will be the script name, but within sub-loads like <code>require</code> etc it is that sub-load.
=={{header|EMal}}==
<syntaxhighlight lang="emal">
writeLine("path: " + Runtime.path)
writeLine("name: " + Runtime.name)
writeLine("args: " + Runtime.args)
</syntaxhighlight>
{{out}}
<pre>
emal.exe Org\RosettaCode\ProgramName.emal sample arguments
path: C:\tmp\Org\RosettaCode\ProgramName.emal
name: ProgramName.emal
args: [sample,arguments]
</pre>
=={{header|Erlang}}==
Line 658 ⟶ 757:
When compiled Erlang's macros hold information about the running module.
<
%%
%% erlc scriptname.erl
Line 672 ⟶ 771:
Program = ?FILE,
io:format("Program: ~s~n", [Program]),
init:stop().</
=={{header|Euphoria}}==
<
puts(1,cmd[2])</
=={{header|F Sharp|F#}}==
Line 686 ⟶ 785:
* Run as a dotslashed program in Unix (./scriptname.fsx)
<
exec fsharpi --exec $0 --quiet
*)
Line 705 ⟶ 804:
let main =
printfn "%s" scriptname</
=={{header|Factor}}==
<
USING: namespaces io command-line ;
Line 716 ⟶ 815:
: main ( -- ) script get print ;
MAIN: main</
=={{header|Forth}}==
{{works with|GNU Forth}}
<
1 arg type cr \ name of script</
=={{header|Fortran}}==
Please find example runs in the comments at the beginning of the FORTRAN2003 source. Program name verification can deter system attackers. Therefore, the code is provided as a separate easily reused module.
<syntaxhighlight lang="fortran">
! program run with invalid name path/f
!
Line 773 ⟶ 872:
write(6,*)'program continues...'
end program name
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
Print "The program was invoked like this => "; Command(0) + " " + Command(-1)
Print "Press any key to quit"
Sleep</
=={{header|FutureBasic}}==
There are several ways to retrieve the program name. These functions return a string containing the name that can be used in various ways.
<syntaxhighlight lang="futurebasic">
print fn ProcessInfoProcessName
print fn RunningApplicationLocalizedName( fn RunningApplicationCurrentApplication )
</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=fc8af45b13a9bb52b6955bab487fc7ac Click this link to run this code]'''
<
Dim sTemp As String
Line 793 ⟶ 900:
Next
End</
Output:
<pre>
Line 800 ⟶ 907:
=={{header|Genie}}==
<
init
print args[0]
print Path.get_basename(args[0])
print Environment.get_application_name()
print Environment.get_prgname()</
{{out}}
Line 818 ⟶ 925:
scriptname.go:
<
import (
Line 827 ⟶ 934:
func main() {
fmt.Println("Program:", os.Args[0])
}</
{{out|Command line session}}
<pre>
Line 843 ⟶ 950:
If you want the script filename, use:
<
def program = getClass().protectionDomain.codeSource.location.path
println "Program: " + program</
But if you just want the class name, there are easier ways.
So, just typing in and running the following in the GroovyConsole environment:
<syntaxhighlight lang
yields the following on the first run:
<pre>ConsoleScript0</pre>
Line 866 ⟶ 973:
Haskell has an impure function for this.
<
main :: IO ()
main = getProgName >>= putStrLn . ("Program: " ++)</
=={{header|Icon}} and {{header|Unicon}}==
<
write(&progname) # obtain and write out the program name from the keyword &progname
end</
=={{header|Io}}==
<
main := method(
Line 885 ⟶ 992:
)
if (System args size > 0 and System args at(0) containsSeq("scriptname"), main)</
=={{header|J}}==
<
program =: monad : 0
Line 901 ⟶ 1,008:
echo 'Program: ', program 0
exit ''</
=={{header|Jakt}}==
The name of the program is stored in the first index of the array passed to main. This is the name of the compiled executable, so when using jakt -cr the value will be a path starting with build/.
<syntaxhighlight lang="jakt">
fn main(arguments: [String]) {
let program_name = arguments[0]
println("{}", program_name)
}
</syntaxhighlight>
=={{header|Java}}==
Line 910 ⟶ 1,027:
You can get the listing of the arguments to the <code>java</code> command through a system property. The first one is the name of the main class that was run. This depends on a system property named "sun.java.command", which might not exist on all Java virtual machines.
<
public static void main(String[] args) {
String program = System.getProperty("sun.java.command").split(" ")[0];
System.out.println("Program: " + program);
}
}</
An alternate solution is to create a dummy inner class, and then retrieve its enclosing class (which is the class the main method is in) through reflection (though this will not work if the code is placed in a method in another source file--it will give the name of the class it is in inside that source file):
<
public static void main(String[] args) {
Class c = new Object(){}.getClass().getEnclosingClass();
System.out.println("Program: " + c.getName());
}
}</
A solution using the security manager:
<
public static void main(String[] args) {
Class c = System.getSecurityManager().getClassContext()[0];
System.out.println("Program: " + c.getName());
}
}</
A solution using the stack trace (requires Java 1.5+):
<
public static void main(String[] args) {
String program = Thread.currentThread().getStackTrace()[1].getClassName();
System.out.println("Program: " + program);
}
}</
=={{header|JavaScript}}==
{{incorrect|JavaScript|Program name, not function name. Show sample output.}}
<small><i>Suggestion: document.location.href is probably closer to task requirements (and better than a script name), plus arguments.callee.name is long dead. --[[User:Petelomax|Pete Lomax]] ([[User talk:Petelomax|talk]]) 23:29, 24 March 2022 (UTC)</i></small><br>
There is no capability within the ECMA-262 standard (the standard for ECMAScript, the language underlying JavaScript) for a function to determine its name. Since objects in JavaScript are first class objects, variables and properties are only references to objects. The name of an object might be said to be the name used to reference it, however a single object may have many variables and properties that reference it, or none.
In some implementations, the following (non–standard) code will work:
<
return arguments.callee.name;
}</
But it will fail in in others. JavaScript also has anonymous functions that don't have a name, e.g.:
<
returns an empty string or <code>undefined</code> even where the first example works.
Line 958 ⟶ 1,076:
Node.js has a global variable for this.
<
/*jslint nodejs:true */
Line 966 ⟶ 1,084:
}
if (!module.parent) { main(); }</
=={{header|Joy}}==
<syntaxhighlight lang="joy">#!/usr/bin/joy
argv first putchars.</syntaxhighlight>
=={{header|Jsish}}==
<
/* Program name, in Jsish */
puts('Executable:', Info.executable());
puts('Argv0 :', Info.argv0());</
{{out}}
Line 981 ⟶ 1,104:
=={{header|Julia}}==
Julia strips the program file name from <tt>ARGS</tt>, so this information is not available to the program from its command line arguments. Instead it is accessible via <tt>Base.source_path()</tt>.
<syntaxhighlight lang="julia">
prog = basename(Base.source_path())
println("This program file is \"", prog, "\".")
</syntaxhighlight>
{{out}}
Line 992 ⟶ 1,115:
=={{header|Kotlin}}==
<
// 'progname.kt' packaged as 'progname.jar'
Line 999 ⟶ 1,122:
println(System.getProperty("sun.java.command")) // may not exist on all JVMs
println(System.getProperty("java.vm.name"))
}</
{{out}}
Line 1,006 ⟶ 1,129:
Java HotSpot(TM) 64-Bit Server VM
</pre>
=={{header|langur}}==
The script name is in the _script variable (separate from the arguments, in the _args variable).
<syntaxhighlight lang="langur">writeln "script: ", _script
writeln "script args: ", _args</syntaxhighlight>
{{out}}
<pre>script: ./testargs.langur
script args: []</pre>
=={{header|Lasso}}==
<
stdoutnl("Program: " + $argv->first)</
Output:
<
Program: script_name.lasso</
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
nSize = _MAX_PATH + 2
lpFilename$ = space$(nSize); chr$(0)
Line 1,059 ⟶ 1,191:
end function
</syntaxhighlight>
Output:
<
Path to LB exe
C:\progs\Liberty BASIC v4.04\liberty.exe
current program file (:last one on LRU list)
C:\progs\Liberty BASIC v4.04\untitled.bas
</syntaxhighlight>
=={{header|Lingo}}==
<
-- "lsw.exe"
put _movie.name
-- "lsw_win_d11.dir"</
=={{header|LLVM}}==
Like C, LLVM can use argv to access the executable's filename.
<
llvm-as scriptname.ll
llc -disable-cfi scriptname.bc
gcc -o scriptname scriptname.s
./scriptname
Program: ./scriptname</
Makefile
<
llvm-as scriptname.ll
llc scriptname.bc
Line 1,096 ⟶ 1,228:
-rm scriptname
-rm scriptname.s
-rm scriptname.bc</
<
declare i32 @printf(i8* noalias nocapture, ...)
Line 1,107 ⟶ 1,239:
ret i32 0
}</
=={{header|Lua}}==
Lua's arg is like C's argv.
<
function main(arg)
Line 1,123 ⟶ 1,255:
else
module(..., package.seeall)
end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Declare GetModuleFileName Lib "kernel32.GetModuleFileNameW" {Long hModule, &lpFileName$, Long nSize}
Line 1,144 ⟶ 1,276:
}
SayIt
</syntaxhighlight>
=={{header|Make}}==
<
all:
@echo $(NAME)
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">#!/usr/bin/env MathKernel -script
ScriptName[] = Piecewise[
{
Line 1,164 ⟶ 1,294:
$CommandLine[[Position[$CommandLine, "-script", 1][[1,1]] + 1]]
]
Program = ScriptName[];
Print["Program: " <> Program]</syntaxhighlight>
=={{header|Mercury}}==
<
:- interface.
Line 1,186 ⟶ 1,314:
io.print_line(ProgName, !IO).
:- end_module program_name.</
=={{header|Mozart/Oz}}==
Makefile:
<
test: scriptname
Line 1,201 ⟶ 1,329:
clean:
-rm scriptname
-rm *.exe</
scriptname.oz:
<
import
System
Line 1,215 ⟶ 1,343:
end
end
</syntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang
{{out}}
<pre>programname.nq</pre>
=={{header|Nemerle}}==
<
...
def program_name = GetCommandLineArgs()[0];
...</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,237 ⟶ 1,365:
say 'Program:' System.getProperty('sun.java.command')
return
</syntaxhighlight>
'''Output'''
Line 1,257 ⟶ 1,385:
newLISP has a function, (main-args int) for this.
<
(let ((program (main-args 1)))
(println (format "Program: %s" program))
(exit))</
=={{header|Nim}}==
<
echo getAppFilename() # Prints the full path of the executed file
echo paramStr(0) # Prints argv[0]</
=={{header|Oberon-2}}==
Works with oo2c Version 2
<
MODULE ProgramName;
IMPORT
Line 1,278 ⟶ 1,406:
Out.Object("Program name: " + Args.Get(0));Out.Ln
END ProgramName.
</syntaxhighlight>
Output:
<pre>
Line 1,288 ⟶ 1,416:
scriptname.m:
<
int main(int argc, char **argv) {
Line 1,303 ⟶ 1,431:
return 0;
}</
<
$ ./scriptname
Program: ./scriptname</
=={{header|OCaml}}==
<
print_endline Sys.executable_name;
print_endline Sys.argv.(0)</
<pre>
Line 1,333 ⟶ 1,461:
=={{header|Octave}}==
<
program = program_name();
printf("Program: %s", program);
endfunction
main();</
=={{header|Ol}}==
First argument of *vm-args* is an executing program name.
<
(print (car *vm-args*))
</syntaxhighlight>
=={{header|Order}}==
This is relatively trivial in Order, as the program being executed is a macro expression in the current C program file being read by the compiler:
<syntaxhighlight lang
When including another file containing another <code>ORDER_PP</code> expression, within that file the <code>__FILE__</code> macro will expand to the name of that file; but arguably that expression constitutes a separate Order program within the greater C project.
Line 1,356 ⟶ 1,484:
=={{header|Pascal}}==
<
var
prog : String;
Line 1,363 ⟶ 1,491:
write('Program: ');
writeln(prog)
end.</
=={{header|Perl}}==
<
use strict;
Line 1,376 ⟶ 1,504:
}
unless(caller) { main; }</
<code>$0</code> includes the full path if a script is run as say <code>perl /some/dir/foo.pl</code>. The <code>FindBin</code> module can give just the basename. This can be good for printing in diagnostics etc.
<
print "Program name $FindBin::Script\n";</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">cl2</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">command_line</span><span style="color: #0000FF;">()[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cl2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- full path</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">get_file_name</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cl2</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- eg test.exw or test.exe or test.htm</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">get_file_base</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cl2</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- eg test</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">argument 1 get ?</syntaxhighlight>
=={{header|PHP}}==
PHP has a global dictionary for this.
<
$program = $_SERVER["SCRIPT_NAME"];
echo "Program: $program\n";
?></
=={{header|PicoLisp}}==
The function '[http://software-lab.de/doc/refC.html#cmd cmd]' returns the command name.
<
-> "/usr/bin/picolisp"</
=={{header|PowerBASIC}}==
Line 1,402 ⟶ 1,539:
Previous versions of PowerBASIC ([[PB/Win]] 8 or older; [[PB/CC]] 4 or older) have to make an [[API]] call:
<
'[...]
DIM fullpath AS ASCIIZ * 260, appname AS STRING
Line 1,410 ⟶ 1,547:
ELSE
appname = fullpath
END IF</
{{works with|PowerBASIC for Windows|9}}
Line 1,416 ⟶ 1,553:
Recent versions of PowerBASIC provide the <code>EXE</code> object; <code>EXE.NAME$</code> returns the program's name, while <code>EXE.NAMEX$</code> returns the program's name and extension. (<code>EXE.EXTN$</code> returns the extension only.) So, to get the program's name, we do this:
<
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
# write this in file <program.ps1>
$MyInvocation.MyCommand.Name
# launch with <.\program>
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 1,430 ⟶ 1,567:
=={{header|Prolog}}==
<
% This will find itself, and return the knowledge base it is in.
file_name(F) :- true
Line 1,437 ⟶ 1,574:
, source_file(M:P, F) % F is the file .
, \+ predicate_property(M:P, imported_from(_))
.</
Alternatively, you may prefer a list of all your knowledge bases; adding the following code to each of your knowledge bases will allow you to query <code>findall(F, source_file(this_is_one_of_my_files, F), L).</code>.
<syntaxhighlight lang
=={{header|PureBasic}}==
PureBasic provides a way to retrieve the filename of the program being executed. It includes the file's path.
<
PrintN(ProgramFilename())
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
Sample output when executing the above program compiled to an executible file called 'program name.exe':
<pre>H:\Data\Rosetta Code\program name.exe</pre>
Line 1,456 ⟶ 1,593:
Python has at least two ways to get the script name: the traditional ARGV and the inspect module.
<
import sys
Line 1,465 ⟶ 1,602:
if __name__ == "__main__":
main()</
<
import inspect
Line 1,477 ⟶ 1,614:
if __name__ == "__main__":
main()</
=={{header|R}}==
R's syntax is complicated, but doable.
<
getProgram <- function(args) {
Line 1,493 ⟶ 1,630:
cat("Program: ", program, "\n")
q("no")</
=={{header|Racket}}==
<
#lang racket
(define (program) (find-system-path 'run-file))
(module+ main (printf "Program: ~a\n" (program)))</
=={{header|Raku}}==
Line 1,507 ⟶ 1,644:
{{works with|rakudo|2015-10-16}}
In Raku, the name of the program being executed is in the special global variable <tt>$*PROGRAM-NAME</tt>.
<syntaxhighlight lang="raku"
=={{header|Raven}}==
<
{{out}}
<pre>raven arg_file.rv</pre>
Line 1,523 ⟶ 1,660:
<br><br>It should be noted that the format of the complete path varies depending upon the operating system.
<
Parse source . . pgmPath
Say pgmPath
</syntaxhighlight>
;Output
<pre>
Line 1,536 ⟶ 1,673:
REXX does not support the use of arg(0) to access the program name. A workaround is to use a shell wrapper script to obtain and provide the invocation name of the wrapper:
<
rexxbit.rexx $0 $*</
Here is a rexx script that makes use of this:
<
On TSO, this program
<
Parse Source a b c
Say 'a='a
Say 'b='!!b
Say 'c='c </
yields
<pre>
Line 1,564 ⟶ 1,701:
:::* ROO REXX
:::* ooRexx
<
parse version _version
parse source _system _howInvoked _path
Line 1,578 ⟶ 1,715:
call prog_nam , 'subroutine' /*call ourself as a subroutine. */
zz = prog_nam( , 'function') /* " " " " function. */
/*stick a fork in it, we're done.*/</
'''output''' when using '''BREXX''' with the input of: <tt> command </tt>
<pre>
Line 1,678 ⟶ 1,815:
=={{header|Ring}}==
<
see "Active Source File Name : " + filename() + nl
</syntaxhighlight>
output
<
Active Source File Name : tests\filename.ring
</syntaxhighlight>
Check the main file in the program
<
if sysargv[2] = filename()
see "I'm the main program file!" + nl
Line 1,694 ⟶ 1,831:
see "I'm a sub file in a program" + nl
ok
</syntaxhighlight>
=={{header|Ruby}}==
<
puts "Path: #{$PROGRAM_NAME}" # or puts "Path: #{$0}"
puts "Name: #{File.basename $0}"</
For example,
Line 1,718 ⟶ 1,855:
scriptname.rs:
<
println!("Program: {}", std::env::args().next().unwrap());
}</
Example:
<
$ ./scriptname
Program: ./scriptname</
=={{header|SAC}}==
Line 1,732 ⟶ 1,869:
scriptname.sac:
<
use Array: all;
use String: { string };
Line 1,741 ⟶ 1,878:
printf("Program: %s\n", program);
return(0);
}</
Makefile:
<
scriptname: scriptname.sac
Line 1,752 ⟶ 1,889:
clean:
-rm scriptname
-rm scriptname.c</
Example:
<
sac2c -o scriptname scriptname.sac
$ ./scriptname
Program: ./scriptname</
=={{header|Scala}}==
<
println(s"Program of instantiated object: ${this.getClass.getName}")
// Not recommended, due various implementations
println(s"Program via enviroment: ${System.getProperty("sun.java.command")}")
}</
=={{header|Scheme}}==
Line 1,772 ⟶ 1,909:
Getting the program name is tricky. When interpreted, the script name will be printed. When compiled, the executable name will be printed.
<
#|
exec csi -ss $0 ${1+"$@"}
Line 1,796 ⟶ 1,933:
(if (equal? (car (program)) 'compiled)
(main (cdr (argv))))</
=={{header|Seed7}}==
Line 1,803 ⟶ 1,940:
When the program is compiled this is the path of the executable.
The functions ''dir(PROGRAM)'' and ''file(PROGRAM)'' deliver the directory respectivly file name of the program path.
<
const proc: main is func
Line 1,812 ⟶ 1,949:
writeln("Program directory: " <& dir(PROGRAM));
writeln("Program file: " <& file(PROGRAM));
end func;</
Output when the program is interpreted:
Line 1,829 ⟶ 1,966:
=={{header|Sidef}}==
<
if (__MAIN__ != __FILE__) {
say "This file has been included!";
}</
=={{header|Smalltalk}}==
Line 1,839 ⟶ 1,976:
Note that this only works when run as "./scriptname.st", because the shebang must force the script name onto ARGV.
<
"exit"
Line 1,846 ⟶ 1,983:
program := Smalltalk getArgv: 1.
Transcript show: 'Program: ', program; cr.</
{{works with|Smalltalk/X}}
Works when run in script mode or in a workspace.
<
program := Smalltalk commandLine first.
Transcript show: 'Program: ', program; cr.</
=={{header|Standard ML}}==
<
let
Line 1,863 ⟶ 2,000:
in
print ("Program: " ^ program ^ "\n")
end;</
=={{header|Tcl}}==
<
proc main {args} {
Line 1,875 ⟶ 2,012:
if {$::argv0 eq [info script]} {
main {*}$::argv
}</
=={{header|Transd}}==
<syntaxhighlight lang="Scheme">#lang transd
MainModule: {
_start: (λ
(textout (get @progArgs 0))
)
}</syntaxhighlight>
=={{header|TXR}}==
Line 1,881 ⟶ 2,027:
Given this code in <code>program-name.txr</code>, marked executable:
<
@(bind my-name @self-path)</
If we run it as an executable:
Line 1,907 ⟶ 2,053:
=={{header|UNIX Shell}}==
{{works with|Bourne Shell}}
<
echo "Program: $0"</
=={{header|Vala}}==
Get name of program and print to console:
<
public static void main(string[] args){
string command_name = args[0];
Line 1,919 ⟶ 2,065:
stdout.printf("%s\n", command_name);
}
</syntaxhighlight>
Output for program named "filename":
Line 1,929 ⟶ 2,075:
VBA can retrieve the name of the program hosting the VBA code using the <code>Application</code> object:
<syntaxhighlight lang
This is mostly useful for code that is shared between, say, [[wp:Microsoft Excel|Microsoft Excel]] and [[wp:Microsoft Word|Microsoft Word]], but has different requirements or actions depending on where it's running.
Line 1,939 ⟶ 2,085:
vbscript provides the Wscript object. Among its properties are the following:
<
Wscript.Echo "FullName:",Wscript.FullName
Wscript.Echo "Name:",Wscript.Name
Line 1,945 ⟶ 2,091:
Wscript.Echo "ScriptFullName:",Wscript.ScriptFullName
Wscript.Echo "ScriptName:",Wscript.ScriptName
</syntaxhighlight>
<pre>
Line 1,958 ⟶ 2,104:
Visual Basic provides the <code>App</code> object, which has a property called <code>EXEName</code> that contains the program's filename ''without the extension''. (For most uses, this doesn't matter, but for code shared between, for example, a program and a screensaver, it can be important.) So, if a program is called "MyVBapp.exe", retreiving the value of <code>App.EXEName</code> would look like this:
<
Alternately, Visual Basic can make an [[API]] call:
<
Dim fullpath As String * 260, appname As String, namelen As Long
namelen = GetModuleFileName (0, fullpath, 260)
Line 1,969 ⟶ 2,115:
Else
appname = fullpath
End If</
=={{header|Wren}}==
Assuming we're running a script file named "Program_name.wren":
<syntaxhighlight lang="wren">import "os" for Process
System.print("My name is %(Process.allArguments[1])")</syntaxhighlight>
{{out}}
<pre>
My name is Program_name.wren
</pre>
=={{header|x86 Assembly}}==
Line 1,975 ⟶ 2,132:
===Linux===
Makefile:
<
RUN=./
BIN=scriptname
Line 1,993 ⟶ 2,150:
clean:
-rm $(BIN)
-rm $(OBJ)</
scriptname.asm:
<
section .data
Line 2,067 ⟶ 2,224:
mov eax, sys_exit
mov ebx, 0
int kernel</
===FreeBSD/Mac OS X===
Makefile:
<
FORMAT=-f elf
Line 2,097 ⟶ 2,254:
clean:
-rm $(BIN)
-rm $(OBJ)</
scriptname.asm:
<
section .data
Line 2,178 ⟶ 2,335:
mov eax, sys_exit
sub esp, 4
int kernel</
===Windows===
Makefile:
<
BIN=scriptname.exe
OBJ=scriptname.obj
Line 2,200 ⟶ 2,357:
clean:
-rm $(BIN)
-rm $(OBJ)</
scriptname.asm:
<
section .data
Line 2,296 ⟶ 2,453:
push 0
call ExitProcess</
=={{header|Yabasic}}==
<
s$ = system$("cd")
n = len(s$)
print left$(s$, n - 2), "\\", peek$("program_name")</
=={{header|Zig}}==
<
const debug = std.debug;
Line 2,319 ⟶ 2,476:
debug.warn("{}\n", .{program_name});
}</
=={{header|zkl}}==
C's argv is exposed to the zkl runtime so if file bbb.zkl contains:
<
println(System.argv);</
Then (on Unix like OSes)
<
zkl bbb.zkl</
both print
<pre>
Line 2,333 ⟶ 2,490:
</pre>
On Unix, zkl is actually a shell script:
<
# A bash script to run zkl if you haven't jumped
# through all the Unix hoops to put the bits in the "right" places
Line 2,347 ⟶ 2,504:
export zklRoot
#set -o noglob
LD_LIBRARY_PATH=$zklRoot/Lib $zklRoot/Bin/zkl "$@"</
On Windows, no launch script (windows knows where the DLLs are) but argv[0] can be messed up.
{{omit from|EasyLang}}
{{omit from|GUISS}}
{{omit from|Retro}}
|