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

MsgBox, % A_ScriptName

 

=={{header|BASIC}}==

Many BASICs -- notably older DOS BASICs, and especially DOS MS BASICs -- do not provide any way to retrieve the program's name.

 

 

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

 

{{works with|BBC BASIC for Windows}}

 

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

{

}

}

 

 

":";exit

(ns scriptname

 

(defn -main [& args]

 

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

 

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

 

;;; Shebang from John Swaby

 

(defun main ()

 

=={{header|Erlang}}==

 

 

 

=={{header|Euphoria}}==

 

 

This code correctly prints the program name in three modes:

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

 

 

 

ScriptName[] = Piecewise[

{

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

]

Program = ScriptName[];

 

 

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

 

Makefile:

 

test: scriptname

clean:

-rm scriptname

 

scriptname.oz:

import

System

end

end

 

 

 

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

}

 

 

 

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

 

def main():

 

 

 

 

import inspect

 

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

The [[REXX|Rexx]] <code>PARSE SOURCE</code> instruction parses data describing the source of the program running.

The language processor returns a string that does not change while the program is running.

These two tokens are followed by the complete path specification of the program file.

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

===version with various types of invokes===

Used under Windows/XP and Windows 7 with the following REXXes:

parse version _version

parse source _system _howInvoked _path

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

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

REXX's name of system being used: Win32

how the REXX program was invoked: COMMAND

REXX's name of system being used: Win32

how the REXX program was invoked: SUBROUTINE

REXX's name of system being used: Win32

how the REXX program was invoked: FUNCTION

</pre>

REXX's name of system being used: WIN32

how the REXX program was invoked: COMMAND

REXX's name of system being used: WIN32

how the REXX program was invoked: SUBROUTINE

REXX's name of system being used: WIN32

how the REXX program was invoked: FUNCTION

</pre>

────────────────────────────────────REXX/Personal 4.00 21 Mar 1992 ◄──► command

REXX's name of system being used: PCDOS

name of the REXX program and path: D:\PROG_NAM.REX

</pre>

─────────────────────────────────────────REXX-roo 4.00 28 Jan 2007 ◄──► command

REXX's name of system being used: Win32

name of the REXX program and path: D:\PROG_NAM.REX * * PROG_NAM

</pre>

 

=={{header|Ruby}}==

 

 

For example,

scriptname.rs:

 

 

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

 

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

Program file: programname

</pre>

 

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

 

=={{header|Visual Basic}}==

 

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

 

{{omit from|GUISS}}

{{omit from|Retro}}