I have a stats package 32-bit binary (P-Stat) which is no longer produced (this is the last version ever). I run this successfully by adding sudo dpkg --add-architecture i386 sudo apt update sudo apt install lib32stdc++6 lib32z1 lib32ncurses6 I did this after installing Linux Mint 22, and have also done so successfully on older 64-bit systems. The /lib/ld-linux.so.2 interpreter is present on the system, corresponding to the details from running the file command on the p-stat binary. I have now been sent an even older version of the P-Stat binary to test on some very old data formats, and file says it needs /lib/ld-linux.so.1 which I don't have [yet]. Two questions: 1. can I have both ld-linux.so.1and ld-linux.so.2 present on the same system? 2. what do I need to install to get ld-linux.so.1?

Is there any way to dynamically choose the interpreter that's executing a script? I have a script that I'm running on two different systems, and the interpreter I want to use is located in different locations on the two systems. What I end up having to to is change the hashbang line every time I switch over. I would like to do something that is the *logical* equivalent of this (I realize that this exact construct is impossible): if running on system A: #!/path/to/python/on/systemA elif running on system B: #!/path/on/systemB #Rest of script goes here Or even better would be this, so that it tries to use the first interpreter, and if it doesn't find it uses the second: try: #!/path/to/python/on/systemA except: #!path/on/systemB #Rest of script goes here Obviously, I can instead execute it as /path/to/python/on/systemA myscript.py or /path/on/systemB myscript.py depending on where I am, but I actually have a wrapper script that launches myscript.py, so I would like to specify the path to the python interpreter programmatically rather than by hand.

As far as I understand, an interpreter runs code line by line; but I find probable that my reasoning is incorrect. If in this example case the first if line returns true, will the program know to skip to fi after echo "APPROVED" (and will it know which line fi is in?) or will it still take some time to check the next lines, and not execute them when they are inside an elif or else? if [ $AVERAGE -ge "6" ] then echo "APPROVED" # Does shell know how to directly get from here /\... elif [ $AVERAGE -lt "2" ] then echo "FAILED" else echo "RETAKE TEST" # ... To here? \/ fi Thank you!

I understand "field splitting" (or alternatively "word splitting") as a *possible* part of a broader process named parsing, while field splitting is done on parsing in various shells via field separation programs (such as IFS on Bourne shell and derivates). Is it correct to divide parsing into simple and complex while simple doesn't include "field splitting" and complex does?

I tried to copy-paste the following two commands into the terminal *directly* and to then execute them: read -s x read -s y Current output is empty prompt but desired output is the first read execution and then the second read execution. I can overcome this with: read -s x && read -s y But; **Why two or more read commands cannot be executed in one go (without some separation syntax)?**

So I have some experience with linux and I was always wondering if it is possible to modify the terminal so that it executes a different interpreter (like python) rather than the default shell interpreter (like sh or bash). (Note that this is not just "https://unix.stackexchange.com/q/22729/5132 " or "https://unix.stackexchange.com/q/20629/5132 ". This is about running things that are not _shells_, per se, but are interpreters. I give python as an example to make things clearer, but I could have easily said php or any other interpreter.) Is this possible, and if so, how would I do it?

I would like to understand the exact process of line interpretation executed by bash. from GNU bash reference manual:

When a simple command is executed, the shell performs the following expansions, assignments, and redirections, from left to right.

1. The words that the parser has marked as variable assignments (those preceding the command name) and redirections are saved for later processing.

2. The words that are not variable assignments or redirections are expanded (see Shell Expansions). If any words remain after expansion, the first word is taken to be the name of the command and the remaining words are the arguments.

3. Redirections are performed as described above (see Redirections).

4. The text after the ‘=’ in each variable assignment undergoes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before being assigned to the variable.

If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment. If any of the assignments attempts to assign a value to a readonly variable, an error occurs, and the command exits with a non-zero status.

If no command name results, redirections are performed, but do not affect the current shell environment. A redirection error causes the command to exit with a non-zero status.

If there is a command name left after expansion, execution proceeds as described below. Otherwise, the command exits. If one of the expansions contained a command substitution, the exit status of the command is the exit status of the last command substitution performed. If there were no command substitutions, the command exits with a status of zero.

now let’s take a simple example:

var="hello friend"

echo ${var}s > log.txt

what happens now? according the reference the var assignment (1) will take place after expansions (4) , but how the shell can expand the var without performing the variable assignment first? I don't know if it's something that I missed here or just misunderstanding of the manual. I'll appreciate if you'll be able to give me additional examples for further understanding. thanks

If the current user only has execute (--x) permissions on a file, under which user does the interpreter (specified by #!/path/to/interpreter at the beginning of the file) run? It couldn't be the current user, because he doesn't have permission to read the file. It couldn't be root, because then arbitrary code included in the interpreter would gain root access. As which user, then, does the interpreter process run? Edit: I think my question assumes that the file has already been read enough to know which interpreter it specifies, when in reality it wouldn't get that far. The current shell (usually b/a/sh) interpreting the command to execute the target file would attempt to read it, and fail.

**My goal:** To receive events from the kernel when a file/script is opened for execution with the absolute path of the file (or maybe the working directory, to resolve the absolute path of the file). * I don't want to get events on every file opened. * I have tried listening to the trace point event sched:sched_process_exec and see when the process is an interpreter but the filename is not always shown and when it does it's only the relative path, so there is no way for me to check if the file is from the type i am looking for (script). * I am aware that there is the option to set the FAN_OPEN_EXEC flag with fanotify but that is only for newer kernels (>5.0) and i need something for older kernels as well (also not sure it will work on files, according to the documentation). Any ideas?

I've learned that this command: echo -e "\a" triggers a beep on the local system, whereas this command: echo -e "\a" >/dev/console triggers a beep on a remote system. Why is this? What is the >/dev/console part doing? Why is it that executing echo -e "\a" on a remote machine triggers the beep locally and not remote ? Why does "echo" - command don't like sudo ? Is there a OSI-Layer - like scheme ? Please provide me with some external documentation. I have only a basic understandig of redirecting stdout/stderr to a file not much more, but the question more likely refers to how is "Gnu/Linux/Kernel" designed in order to requiere redirrection to " > /dev/console" for a remote beep to work out. Does a remote echo "Hello World" require a redirection to /dev/console ?

It would be very useful for me to run specific programs in a Linux environment with a fixed (lower) CPU clock speed (say, runat 400mhz ./my-program --argument-of="my program" for getting that clock speed). I need it to generate delays between each assembly instruction of my program, and it wouldn't kill me if the delay isn't exact (say, if it depends on the OS scheduler, as it almost sure will). The goal is to make algorithms efficiency very explicit when programming not-that-heavy applications at school (having a 3GHz CPU makes it difficult to notice slow algorithms that run for little time and could be really optimized). Also, it could be useful for spotting race conditions in real time, maybe. Do you know of any such tool? Is there any kind-of-interpreter that I could hack to achieve this? Can gdb help me in a relatively easy way? I think it's the closest thing to controlling a Linux program execution I know. Running the hole system in a CPU capped VM could be another option, given it provides me that illusion - a lower speed CPU - but or would be best to run single programs.

All my Python and Perl scripts are simply NOT iterpreted via shebang. Never. But they work as expected when I explicitly call the binary. I double checked my Perl and Python installations, it is just too strange: they shebang-way execution works very well in the target system chroot on a sane host but not in the actual running system. I work on a homemade Linux system which worked just great before that problem appeared. See by yourself: A test on the 'xscreensaver-text' Perl program, once via shebang then with the interpreter on the CLI: $ LC_ALL=C LANG=C /usr/bin/xscreensaver-text /usr/bin/xscreensaver-text: line 23: require: command not found /usr/bin/xscreensaver-text: line 25: use: command not found /usr/bin/xscreensaver-text: line 29: BEGIN: command not found /usr/bin/xscreensaver-text: line 31: use: command not found /usr/bin/xscreensaver-text: line 32: syntax error near unexpected token `(' /usr/bin/xscreensaver-text: line 32: `use POSIX qw(strftime);' $ LC_ALL=C LANG=C perl /usr/bin/xscreensaver-text poopy Linux 3.11.1 Sat Oct 5 23:07:33 2013 up 11:35, 2 users load average: 0.09, 0.08, 0.06 SO this for Perl programs but the same happens with Python scripts. We've been messing with encodings and terminfo's and different kernel, still no success. I've even rebuilt my entire system. It works just great in a chroot env, but once I boot it I have this problem. Here's an strace output: $ LC_ALL=C LANG=C strace /usr/bin/xscreensaver-text execve("/usr/bin/xscreensaver-text", ["/usr/bin/xscreensaver-text"], [/* 50 vars */]) = -1 ENOEXEC (Exec format error) write(2, "strace: exec: Exec format error\n", 32strace: exec: Exec format error ) = 32 exit_group(1) = ? +++ exited with 1 +++ $ LC_ALL=C LANG=C strace perl /usr/bin/xscreensaver-text execve("/usr/bin/perl", ["perl", "/usr/bin/xscreensaver-text"], [/* 50 vars */]) = 0 brk(0) = 0x601000 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7ff12e312000 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory) open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3 fstat(3, {st_mode=S_IFREG|0644, st_size=240674, ...}) = 0 mmap(NULL, 240674, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7ff12e2d7000 close(3) = 0 open("/usr/lib64/libc.so.6", O_RDONLY|O_CLOEXEC) = 3 read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \37\2\0\0\0\0\0"..., 832) = 832 fstat(3, {st_mode=S_IFREG|0755, st_size=1868472, ...}) = 0 mmap(NULL, 3981888, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7ff12dd24000 mprotect(0x7ff12dee6000, 2097152, PROT_NONE) = 0 mmap(0x7ff12e0e6000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1c2000) = 0x7ff12e0e6000 mmap(0x7ff12e0ec000, 16960, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7ff12e0ec000 close(3) = 0 mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7ff12e2d6000 mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7ff12e2d4000 arch_prctl(ARCH_SET_FS, 0x7ff12e2d4740) = 0 mprotect(0x7ff12e0e6000, 16384, PROT_READ) = 0 mprotect(0x7ff12e313000, 4096, PROT_READ) = 0 munmap(0x7ff12e2d7000, 240674) = 0 brk(0) = 0x601000 brk(0x622000) = 0x622000 clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=0x7ff12e2d4a10) = 5680 wait4(5680, poopy Linux 3.11.1 Sat Oct 5 23:11:49 2013 up 11:39, 2 users load average: 0.08, 0.12, 0.08 [{WIFEXITED(s) && WEXITSTATUS(s) == 0}], 0, NULL) = 5680 --- SIGCHLD {si_signo=SIGCHLD, si_code=CLD_EXITED, si_pid=5680, si_status=0, si_utime=2, si_stime=0} --- exit_group(0) = ? +++ exited with 0 +++ Contents (only the beginning) of the script : $ cat /usr/bin/xscreensaver-text #!/usr/bin/perl -w # Copyright � 2005-2013 Jamie Zawinski # # # Created: 19-Mar-2005. require 5; #use diagnostics; # Fails on some MacOS 10.5 systems use strict; # Some Linux systems don't install LWP by default! # Only error out if we're actually loading a URL instead of local data. BEGIN { eval 'use LWP::UserAgent;' } --*snip*--

I already stumbled over #!/usr/bin/env bash on numerous occasions and never questioned it. Now, I'm wondering what the purpose of wrapping the shell interpreter in an env command, i.e. why not just write #!/bin/bash, #!/bin/sh or whatever?

I had always thought that shells parse whole scripts, constructing an AST, and then execute that AST from memory. However, I just read [a comment by Stéphane Chazelas](https://unix.stackexchange.com/questions/449498/call-function-declared-below#comment816064_449508) , and tested executing this script, edit-while-executing.sh: #!/bin/bash echo start sleep 10 and then while it was sleeping running: $ echo "echo end" >> edit-while-executing.sh and it worked to cause it to print "end" at the end. However, when trying to modify this: #!/bin/bash while true; do echo yes done by doing: $ printf "%s" "no " | dd of=edit-while-executing.sh conv=notrunc seek=35 bs=1 It didn't work, and kept printing "yes". I also wondered if other non-shell interpreters also worked like this, and tried the equivalent of the first script with python, but it didn't work. Though, maybe python is not an interpreter anymore and it's more of a JIT compiler. So to reiterate my question, is this a behaviour ubiquitous to shells and limited to them or also present in other interpreters (those not regarded as shells)? Also how does this work such that could I do the first modification but not the second?

My goal is simple: I would like to create a program that bootstraps the nix package manager on any architecture, as a non-root user, with as few depends as possible. For now, what I did is the following: I download on the host a minimalist alpine version, with the good arch. Then I untar it, and "chroot" (in fact proot) into it. Then, I install (in the chroot) all the deps for the build, I build it with the good options, and then I copy back the files on the host. But there is an important problem: each system seems to have the "interpreter file" (the thing you get when you run file on it) in a different place: on my debian it's in /lib64/ld-linux-x86-64.so.2, but on alpine it's in /lib/ld-musl-x86_64.so.1. So when I run it, I get an error like File does not exists (while it obviously exist). So here is my question: how can I compile a tool (like nix), so that the interpreter is sure to be found on all (or at least most) of the linux distributions ? And if it's not possible, can I, somehow chroot/proot into a system, and use the host interpreter, so that when I copy back the files on the host the interpreter becomes the good one ? Thank you!

I have (foolishly?) written a couple of moderately general-purpose [xslt](https://www.w3.org/TR/xslt/) scripts. I'd quite like to turn these into executables that read an xml document from standard in or similar. The way you do this with other languages is to use a [shbang](https://en.wikipedia.org/wiki/Shebang_(Unix)) . Is there an easy / standard way to do this with xsltproc and friends? Sure I could hack up a wrapper around xsltproc that pulls off the first comment line... but if there is something approximating a standard this would be nicer to use.

I am writing expect script which can be used on mulple operating systems but the problem is i can't use #!/usr/bin/expect evreywhere so instead i tried to do #!which expect at the top but it failed [sesiv@itseelm-lx4151 ~]$ ./sendcommand -bash: ./sendcommand: `which: bad interpreter: No such file or directory any solution for this.

I'm running a script (in tmuxinator) that tries to source another script (rvm). rvm explicitly does not allow sourcing from sh. I didn't think that would be a problem, because the shebang in the tmuxinator script is #!/bin/bash but when I insert the code suggested by the rvm people to source rvm from a script, if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then source "$HOME/.rvm/scripts/rvm" fi -I get sh: 6: [[: not found Why is sh being used as the interpreter there? I've also used #!/usr/bin/zsh (which is the value of $SHELL in the interactive shell from which I called the script) and #!/usr/bin/env zsh, but they give the same complaint.

Must the shebang header always match the interpreter's installation directory? If so, then why do both #!/usr/bin/python and #!/usr/local/bin/python work for me?