Program name: Difference between revisions

=={{header|11l}}==

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

;Output

Without built-in CRT, <code>argc</code> and <code>argv</code> are stored in the stack. The format looks like:

sp+8 = argv[0]

Each item of <code>argv</code> is a pointer to a null-terminated 8-bit string.

.equ SVC_WRITE, 64

.equ SVC_EXIT, 93

_exit:

mov x8, #SVC_EXIT

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

=={{header|Amazing Hopper}}==

El primer parámetro en Hopper y sus sabores, siempre será el nombre del programa.

#include <hbasic.h>

Begin

Print("My Program name: ", name File,Newl)

End

{{out}}

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

To get the name with which the program was invoked:

To get the full path:

==={{header|uBasic/4tH}}===

'''CMD(1)''' returns a string with the filename - '''SHOW()''' prints this string.

=={{header|Blue}}==

Linux/x86-64. Will print the name of the executable from "argv[0]" as provided.

: syscall ( num:eax -- result:eax ) syscall ;

: arg0 ( rsp -- rsp ) 8 add @ ; inline

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

C++ can access the executable's filename through the arguments to main().

using namespace std;

char *program = argv[0];

cout << "Program: " << program << endl;

=={{header|Clojure}}==

":";exit

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

=={{header|COBOL}}==

COBOL has an internal PROGRAM-ID name, and then the external invocation name.

program-id. sample.

goback.

{{out}}

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

ELENA 4.x :

public program()

console.printLine(program_arguments[0]); // the program name

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

;;; Shebang from John Swaby

(defun main ()

(let ((program (nth 2 command-line-args)))

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

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

print fn ProcessInfoProcessName

print fn RunningApplicationLocalizedName( fn RunningApplicationCurrentApplication )

=={{header|Gambas}}==

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

Dim sTemp As String

Next

Output:

<pre>

=={{header|Genie}}==

init

print args[0]

print Path.get_basename(args[0])

print Environment.get_application_name()

{{out}}

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

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

/* Program name, in Jsish */

puts('Executable:', Info.executable());

{{out}}

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

=={{header|langur}}==

The script name is in the _script variable (separate from the arguments, in the _args variable).

{{out}}

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

}

SayIt

=={{header|Make}}==

all:

@echo $(NAME)

=={{header|Mathematica}}/{{header|Wolfram Language}}==

ScriptName[] = Piecewise[

{

]

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

{{out}}

<pre>programname.nq</pre>

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

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

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

=={{header|Phixmonti}}==

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

% This will find itself, and return the knowledge base it is in.

file_name(F) :- true

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

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

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

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