Program name: Difference between revisions

 

Examples from [https://github.com/mcandre/scriptname GitHub].

 

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

 

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

=={{header|ALGOL 68}}==

BEGIN

print ((program idf, newline))

END

{{out}}

<pre>

$

</pre>

=={{header|Applesoft BASIC}}==

10 GOSUB 40"GET PROGRAM NAME

20 PRINT N$

670 N$ = "

680 RETURN

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr /* retour procedure */

=={{header|AutoHotkey}}==

MsgBox, % A_ScriptName

=={{header|AWK}}==

# syntax: TAWK -f PROGRAM_NAME.AWK

#

exit(0)

}

{{out}}

<pre>

 

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]].

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

{{works with|BBC BASIC for Windows}}

 

==={{header|IS-BASIC}}===

110 CHAIN "Name2.BAS"(A,B,C,S$)

 

 

edit 0

 

=={{header|C}}==

* <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) {

 

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

__FILE__, __FUNCTION__, __LINE__);

return 0;

 

=== BSD ===

{{works with|OpenBSD|5.0}} '''To compile myname.c:''' <code>make myname LDLIBS=-lkvm</code>

 

 

#include <sys/param.h>

kvm_close(kd);

return 0;

 

The program can have three different names!

 

{{libheader|Win32}}

#include <stdlib.h>

#include <wchar.h>

free(path);

return 0;

 

<pre>Path to executable: C:\Users\kernigh\Documents\field\scratch.exe</pre>

 

=={{header|C sharp|C#}}==

This effectively outputs the executable name, file path, and any arguments for the current program.

namespace ProgramName

{

}

}

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

{

}

}

 

=={{header|Clojure}}==

":";exit

 

 

(when (.contains (first *command-line-args*) *source-path*)

 

=={{header|CoffeeScript}}==

scriptname.coffee:

 

main = () ->

console.log "Program: " + program

 

 

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

 

#|

exec clisp -q -q $0 $0 ${1+"$@"}

args

:test #'(lambda (x y) (search x y :test #'equalp)))

 

=={{header|D}}==

 

import std.stdio;

void main(in string[] args) {

writeln("Program: ", args[0]);

{{out}}

<pre>C:\rosetta>program_name.exe

Program: program_name.exe</pre>

 

$ ./scriptname

 

If the system is configured, the D programming language offers an 'interpreted-looking' mode, which exhibits slightly different behavior than the normal compilation:

 

 

Alternative method using built-in function [http://dlang.org/changelog.html#current_path thisExePath()]

{{works with|D|2.064+}}

 

import std.file;

{

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}

Writeln('Program name: ' + ParamStr(0));

Writeln('Command line: ' + CmdLine);

 

=={{header|Déjà Vu}}==

 

 

=={{header|EchoLisp}}==

(js-eval "window.location.href")

→ "http://www.echolalie.org/echolisp/"

 

 

=={{header|Emacs Lisp}}==

 

;;; Shebang from John Swaby

 

(defun main ()

 

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

When compiled Erlang's macros hold information about the running module.

 

%%

%% erlc scriptname.erl

Program = ?FILE,

io:format("Program: ~s~n", [Program]),

 

=={{header|Euphoria}}==

 

=={{header|F Sharp|F#}}==

* Run as a dotslashed program in Unix (./scriptname.fsx)

 

exec fsharpi --exec $0 --quiet

*)

 

let main =

 

=={{header|Factor}}==

 

USING: namespaces io command-line ;

: main ( -- ) script get print ;

 

=={{header|Forth}}==

{{works with|GNU Forth}}

 

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

! program run with invalid name path/f

!

write(6,*)'program continues...'

end program name

 

=={{header|FreeBASIC}}==

 

Print "The program was invoked like this => "; Command(0) + " " + Command(-1)

Print "Press any key to quit"

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=fc8af45b13a9bb52b6955bab487fc7ac Click this link to run this code]'''

Dim sTemp As String

 

Next

 

Output:

<pre>

Command to start the program was ./CLIOnly.gambas Hello World!

</pre>

 

=={{header|Go}}==

scriptname.go:

 

 

import (

func main() {

fmt.Println("Program:", os.Args[0])

{{out|Command line session}}

<pre>

If you want the script filename, use:

 

 

def program = getClass().protectionDomain.codeSource.location.path

 

 

But if you just want the class name, there are easier ways.

 

So, just typing in and running the following in the GroovyConsole environment:

yields the following on the first run:

<pre>ConsoleScript0</pre>

Haskell has an impure function for this.

 

 

main :: IO ()

 

=={{header|Icon}} and {{header|Unicon}}==

write(&progname) # obtain and write out the program name from the keyword &progname

 

=={{header|Io}}==

 

main := method(

)

 

 

=={{header|J}}==

 

 

program =: monad : 0

echo 'Program: ', program 0

 

 

=={{header|Java}}==

 

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

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.

 

Node.js has a global variable for this.

 

/*jslint nodejs:true */

 

}

 

 

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

prog = basename(Base.source_path())

println("This program file is \"", prog, "\".")

 

{{out}}

 

=={{header|Kotlin}}==

 

// 'progname.kt' packaged as 'progname.jar'

println(System.getProperty("sun.java.command")) // may not exist on all JVMs

println(System.getProperty("java.vm.name"))

 

{{out}}

Java HotSpot(TM) 64-Bit Server VM

</pre>

 

=={{header|Lasso}}==

 

Output:

 

=={{header|Liberty BASIC}}==

nSize = _MAX_PATH + 2

lpFilename$ = space$(nSize); chr$(0)

end function

 

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

 

=={{header|Lingo}}==

-- "lsw.exe"

put _movie.name

 

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

 

Makefile

 

 

llvm-as scriptname.ll

llc scriptname.bc

-rm scriptname

-rm scriptname.s

 

 

declare i32 @printf(i8* noalias nocapture, ...)

 

ret i32 0

 

=={{header|Lua}}==

Lua's arg is like C's argv.

 

 

function main(arg)

else

module(..., package.seeall)

=={{header|M2000 Interpreter}}==

Module Checkit {

Declare GetModuleFileName Lib "kernel32.GetModuleFileNameW" {Long hModule, &lpFileName$, Long nSize}

Checkit

\\ command$ return the file's path plus name of script

Module SayIt {

Show

}

SayIt

 

=={{header|Make}}==

 

 

all:

@echo $(NAME)

 

ScriptName[] = Piecewise[

{

$CommandLine[[Position[$CommandLine, "-script", 1][[1,1]] + 1]]

]

Program = ScriptName[];

 

=={{header|Mercury}}==

 

:- interface.

 

io.print_line(ProgName, !IO).

 

 

=={{header|Mozart/Oz}}==

 

Makefile:

 

test: scriptname

clean:

-rm scriptname

 

scriptname.oz:

import

System

end

end

 

=={{header|Nemerle}}==

...

def program_name = GetCommandLineArgs()[0];

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

say 'Program:' System.getProperty('sun.java.command')

return

'''Output'''

 

newLISP has a function, (main-args int) for this.

 

 

(let ((program (main-args 1)))

(println (format "Program: %s" program))

 

=={{header|Nim}}==

echo getAppFilename() # Prints the full path of the executed file

 

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE ProgramName;

IMPORT

Out.Object("Program name: " + Args.Get(0));Out.Ln

END ProgramName.

Output:

<pre>

Program name: ./ProgramName

</pre>

=={{header|Objective-C}}==

 

scriptname.m:

 

 

int main(int argc, char **argv) {

 

return 0;

 

$ ./scriptname

 

=={{header|OCaml}}==

 

print_endline Sys.executable_name;

 

<pre>

 

=={{header|Octave}}==

program = program_name();

printf("Program: %s", program);

endfunction

 

 

=={{header|Ol}}==

First argument of *vm-args* is an executing program name.

(print (car *vm-args*))

 

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

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.

 

=={{header|Pascal}}==

 

var

prog : String;

write('Program: ');

writeln(prog)

 

=={{header|Perl}}==

 

use strict;

}

 

 

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

 

 

 

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

 

=={{header|PowerBASIC}}==

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

ELSE

appname = fullpath

 

{{works with|PowerBASIC for Windows|9}}

 

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

# write this in file <program.ps1>

$MyInvocation.MyCommand.Name

# launch with <.\program>

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

file_name(F) :- true

, M = user % M is the module .

, P = file_name(_) % P is the predicate .

, \+ predicate_property(M:P, imported_from(_))

 

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

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>

Python has at least two ways to get the script name: the traditional ARGV and the inspect module.

 

 

import sys

 

if __name__ == "__main__":

 

 

 

import inspect

 

if __name__ == "__main__":

 

=={{header|R}}==

R's syntax is complicated, but doable.

 

 

getProgram <- function(args) {

cat("Program: ", program, "\n")

 

 

=={{header|Racket}}==

#lang racket

 

(define (program) (find-system-path 'run-file))

 

 

=={{header|Raven}}==

{{out}}

<pre>raven arg_file.rv</pre>

<br><br>It should be noted that the format of the complete path varies depending upon the operating system.

 

 

Parse source . . pgmPath

Say pgmPath

;Output

<pre>

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:

 

 

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

yields

<pre>

:::* ROO REXX

:::* ooRexx

parse version _version

parse source _system _howInvoked _path

call prog_nam , 'subroutine' /*call ourself as a subroutine. */

zz = prog_nam( , 'function') /* " " " " function. */

'''output''' &nbsp; when using '''BREXX''' with the input of: &nbsp; <tt> command </tt>

<pre>

 

=={{header|Ring}}==

see "Active Source File Name : " + filename() + nl

output

Active Source File Name : tests\filename.ring

 

Check the main file in the program

if sysargv[2] = filename()

see "I'm the main program file!" + nl

see "I'm a sub file in a program" + nl

ok

 

=={{header|Ruby}}==

 

puts "Path: #{$PROGRAM_NAME}" # or puts "Path: #{$0}"

 

For example,

scriptname.rs:

 

println!("Program: {}", std::env::args().next().unwrap());

 

Example:

 

$ ./scriptname

 

=={{header|SAC}}==

scriptname.sac:

 

use Array: all;

use String: { string };

printf("Program: %s\n", program);

return(0);

 

Makefile:

 

 

scriptname: scriptname.sac

clean:

-rm scriptname

 

Example:

 

sac2c -o scriptname scriptname.sac

$ ./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}}==

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+"$@"}

 

(if (equal? (car (program)) 'compiled)

 

=={{header|Seed7}}==

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

writeln("Program directory: " <& dir(PROGRAM));

writeln("Program file: " <& file(PROGRAM));

 

Output when the program is interpreted:

 

=={{header|Sidef}}==

if (__MAIN__ != __FILE__) {

say "This file has been included!";

 

=={{header|Smalltalk}}==

Note that this only works when run as "./scriptname.st", because the shebang must force the script name onto ARGV.

 

"exit"

 

program := Smalltalk getArgv: 1.

 

 

{{works with|Smalltalk/X}}

Works when run in script mode or in a workspace.

 

 

program := Smalltalk commandLine first.

 

=={{header|Standard ML}}==

 

let

in

print ("Program: " ^ program ^ "\n")

 

=={{header|Tcl}}==

 

proc main {args} {

if {$::argv0 eq [info script]} {

main {*}$::argv

 

=={{header|TXR}}==

Given this code in <code>program-name.txr</code>, marked executable:

 

 

If we run it as an executable:

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

 

 

=={{header|Vala}}==

Get name of program and print to console:

public static void main(string[] args){

string command_name = args[0];

stdout.printf("%s\n", command_name);

}

 

Output for program named "filename":

 

VBA can retrieve the name of the program hosting the VBA code using the <code>Application</code> object:

 

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.

 

Wscript.Echo "FullName:",Wscript.FullName

=={{header|vbscript}}==

 

vbscript provides the Wscript object. Among its properties are the following:

 

Wscript.Echo "FullName:",Wscript.FullName

Wscript.Echo "Name:",Wscript.Name

Wscript.Echo "ScriptFullName:",Wscript.ScriptFullName

Wscript.Echo "ScriptName:",Wscript.ScriptName

 

<pre>

 

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)

Else

appname = fullpath

 

 

 

=={{header|x86 Assembly}}==

===Linux===

Makefile:

RUN=./

BIN=scriptname

clean:

-rm $(BIN)

 

scriptname.asm:

 

section .data

mov eax, sys_exit

mov ebx, 0

 

===FreeBSD/Mac OS X===

Makefile:

 

FORMAT=-f elf

clean:

-rm $(BIN)

 

scriptname.asm:

 

section .data

mov eax, sys_exit

sub esp, 4

 

===Windows===

Makefile:

BIN=scriptname.exe

OBJ=scriptname.obj

clean:

-rm $(BIN)

 

scriptname.asm:

 

section .data

 

push 0

 

=={{header|Yabasic}}==

 

s$ = system$("cd")

n = len(s$)

 

=={{header|zkl}}==

C's argv is exposed to the zkl runtime so if file bbb.zkl contains:

Then (on Unix like OSes)

both print

<pre>

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

export zklRoot

#set -o noglob

On Windows, no launch script (windows knows where the DLLs are) but argv[0] can be messed up.

 

{{omit from|GUISS}}

{{omit from|Retro}}