How to add C program output generated by -o to $PATH? - c

My c program file is Numbers.c
cc- Numbers.c -o output.txt
can give me results in another file. But how can I modify that command line, therefore, I can add the results of Numbers.c to $PATH?
I tried:
cc Numbers.c >>PATH
But there is no change in $PATH when I check it;
echo $PATH

How to add an executable program to PATH environment variable?
Make these steps to add a C program to PATH variable.
First of all make a back up from important PATH Variable with echo $PATH > ~/path.txt
Compile the C source code with gcc Numbers.c -o Numbers
Suppose the executable output file Numbers is place under ~/barname.
Run export PATH="$PATH:~/barname" to append ~/barname folder to PATH variable.
Now you can run the executable file i.e: Numbers from any location on Terminal.
I answer to similar question at Iranian Ubuntu community.
and now translate it to English.
Edit
By performing jonathan-leffler notes in comment section, i can change above answer to:
Having many different directories inside PATH environment variable not recommend and have performance issue.
If i want to use specific programs only for myself, create a new directory in current user (me) home folder. mkdir $HOME/bin Then copy Numbers program and all of other programs in to it. for example cp ~/barname/Numbers ~/bin. And finally add only one directory i.e: $HOME/bin to PATH variable by export PATH="$PATH:$HOME/bin".
In a situation when working on a real multi user system, like when work as Sysadmin its better to copy programs to /usr/local/bin and then adding this to PATH by export PATH="$PATH:/usr/local/bin. Now every users can access and run programs.

Related

"Command not found" trying to run my C program by typing its name at the terminal [duplicate]

When running scripts in bash, I have to write ./ in the beginning:
$ ./manage.py syncdb
If I don't, I get an error message:
$ manage.py syncdb
-bash: manage.py: command not found
What is the reason for this? I thought . is an alias for current folder, and therefore these two calls should be equivalent.
I also don't understand why I don't need ./ when running applications, such as:
user:/home/user$ cd /usr/bin
user:/usr/bin$ git
(which runs without ./)
Because on Unix, usually, the current directory is not in $PATH.
When you type a command the shell looks up a list of directories, as specified by the PATH variable. The current directory is not in that list.
The reason for not having the current directory on that list is security.
Let's say you're root and go into another user's directory and type sl instead of ls. If the current directory is in PATH, the shell will try to execute the sl program in that directory (since there is no other sl program). That sl program might be malicious.
It works with ./ because POSIX specifies that a command name that contain a / will be used as a filename directly, suppressing a search in $PATH. You could have used full path for the exact same effect, but ./ is shorter and easier to write.
EDIT
That sl part was just an example. The directories in PATH are searched sequentially and when a match is made that program is executed. So, depending on how PATH looks, typing a normal command may or may not be enough to run the program in the current directory.
When bash interprets the command line, it looks for commands in locations described in the environment variable $PATH. To see it type:
echo $PATH
You will have some paths separated by colons. As you will see the current path . is usually not in $PATH. So Bash cannot find your command if it is in the current directory. You can change it by having:
PATH=$PATH:.
This line adds the current directory in $PATH so you can do:
manage.py syncdb
It is not recommended as it has security issue, plus you can have weird behaviours, as . varies upon the directory you are in :)
Avoid:
PATH=.:$PATH
As you can “mask” some standard command and open the door to security breach :)
Just my two cents.
Your script, when in your home directory will not be found when the shell looks at the $PATH environment variable to find your script.
The ./ says 'look in the current directory for my script rather than looking at all the directories specified in $PATH'.
When you include the '.' you are essentially giving the "full path" to the executable bash script, so your shell does not need to check your PATH variable. Without the '.' your shell will look in your PATH variable (which you can see by running echo $PATH to see if the command you typed lives in any of the folders on your PATH. If it doesn't (as is the case with manage.py) it says it can't find the file. It is considered bad practice to include the current directory on your PATH, which is explained reasonably well here: http://www.faqs.org/faqs/unix-faq/faq/part2/section-13.html
On *nix, unlike Windows, the current directory is usually not in your $PATH variable. So the current directory is not searched when executing commands. You don't need ./ for running applications because these applications are in your $PATH; most likely they are in /bin or /usr/bin.
This question already has some awesome answers, but I wanted to add that, if your executable is on the PATH, and you get very different outputs when you run
./executable
to the ones you get if you run
executable
(let's say you run into error messages with the one and not the other), then the problem could be that you have two different versions of the executable on your machine: one on the path, and the other not.
Check this by running
which executable
and
whereis executable
It fixed my issues...I had three versions of the executable, only one of which was compiled correctly for the environment.
Rationale for the / POSIX PATH rule
The rule was mentioned at: Why do you need ./ (dot-slash) before executable or script name to run it in bash? but I would like to explain why I think that is a good design in more detail.
First, an explicit full version of the rule is:
if the path contains / (e.g. ./someprog, /bin/someprog, ./bin/someprog): CWD is used and PATH isn't
if the path does not contain / (e.g. someprog): PATH is used and CWD isn't
Now, suppose that running:
someprog
would search:
relative to CWD first
relative to PATH after
Then, if you wanted to run /bin/someprog from your distro, and you did:
someprog
it would sometimes work, but others it would fail, because you might be in a directory that contains another unrelated someprog program.
Therefore, you would soon learn that this is not reliable, and you would end up always using absolute paths when you want to use PATH, therefore defeating the purpose of PATH.
This is also why having relative paths in your PATH is a really bad idea. I'm looking at you, node_modules/bin.
Conversely, suppose that running:
./someprog
Would search:
relative to PATH first
relative to CWD after
Then, if you just downloaded a script someprog from a git repository and wanted to run it from CWD, you would never be sure that this is the actual program that would run, because maybe your distro has a:
/bin/someprog
which is in you PATH from some package you installed after drinking too much after Christmas last year.
Therefore, once again, you would be forced to always run local scripts relative to CWD with full paths to know what you are running:
"$(pwd)/someprog"
which would be extremely annoying as well.
Another rule that you might be tempted to come up with would be:
relative paths use only PATH, absolute paths only CWD
but once again this forces users to always use absolute paths for non-PATH scripts with "$(pwd)/someprog".
The / path search rule offers a simple to remember solution to the about problem:
slash: don't use PATH
no slash: only use PATH
which makes it super easy to always know what you are running, by relying on the fact that files in the current directory can be expressed either as ./somefile or somefile, and so it gives special meaning to one of them.
Sometimes, is slightly annoying that you cannot search for some/prog relative to PATH, but I don't see a saner solution to this.
When the script is not in the Path its required to do so. For more info read http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_02_01.html
All has great answer on the question, and yes this is only applicable when running it on the current directory not unless you include the absolute path. See my samples below.
Also, the (dot-slash) made sense to me when I've the command on the child folder tmp2 (/tmp/tmp2) and it uses (double dot-slash).
SAMPLE:
[fifiip-172-31-17-12 tmp]$ ./StackO.sh
Hello Stack Overflow
[fifi#ip-172-31-17-12 tmp]$ /tmp/StackO.sh
Hello Stack Overflow
[fifi#ip-172-31-17-12 tmp]$ mkdir tmp2
[fifi#ip-172-31-17-12 tmp]$ cd tmp2/
[fifi#ip-172-31-17-12 tmp2]$ ../StackO.sh
Hello Stack Overflow

Can't find how to select path to run a C program

I am using mac OS x and have written C program using GCC compiler.
But while running the program on terminal I am being shown that "No such file or directory found"
Please help me how to select the path?
run it with $./yourProgramFile command the ./ in the beginning is important. It means the program resides in the current directory.
Example:
/path/to/your/cFile $ gcc myfile.c -o myfile
/path/to/your/cFile $ ./myfile
You can do one of two things
1) Add the program's folder to the system's PATH; that way, you can call the program from any location. If it's a program you plan to use constantly, this is the best option.
Here's a way to do that:
Open up the .profile file in your home directory using any text editor.
Paste the following code anywhere in the file, preferably around the bottom of the file.
#make sure there's no space in the pasted code
export PATH=$PATH:path_to_the_program
Save it and restart your computer. That should put the program in the system's PATH.
2) Navigate to the folder of the program; then type
./program_name
Hope the explanation is clear and the answer helps.
Make sure that when you compile the program, you should use -o program_name to make the program name whatever you want it to be; otherwise, the program's name will be a.out, which would be very confusing.

Executing a compiled C program

I compiled a silly little "hello world" C program called main.c:
gcc main.c
As expected, a file called a.out appeared, which they say is an executable. From that same directory, if I type
a.out
and hit enter, it says "command not found". But if I type
./a.out
It says "hello world", as desired. I've never seen an executable that requires a './' in front of it to run. Why now?
All executables that aren't in your PATH require an explicit path from root / or the local directory ./ to run. A quick search turns up other threads with essentially the same question:
Why do you need ./ (dot-slash) before script name to run it in bash?
This also has the added benefit of helping with your auto completion in your shell (assuming it supports it). If you type just aTabTab then it will list every executable in your path that starts with "a". However, if you type ./aTab it will probably just auto-complete as a.out since it will only look at executable files in the current directory starting with "a". So, looking at it that way, the "./" actually saves you typing a few keys!
It is standard practice in Unix and Linux not to have the current working directory in the path. If you want to have MSDOS/Windows behavior, alter your PATH variable to include . as the first directory.
It's because the system is looking for a.out or any other exec. file in some special paths. And the current dir in not in that list by default (usually).
look at the list of such paths:
$ env|grep PATH
you can add such current dir to PATH env. variable:
$ export PATH=$PATH:.
But you better avoid doing that and run ./a.out.
Such tech. provides us understanding that we are running specified file from current dir,
not the other file with the same name from another (potentially) dir. So, we know what we run exactly.
When you type something like a.out into a Linux terminal, you're implying that you want to run a command called a.out. By default, the terminal does not look in the current directory for these commands, it looks in PATH - a set of directories for executable programs. It is usually these directories:
/bin
/usr/bin
/usr/local/bin
among others (you can check them all by running echo $PATH)
You have to specifiy the directory directory of your program for it to run, if it is not in one of the directories of PATH. For example:
./a.out works because . refers to the directory you're in
../a.out could work if a.out is in a parent directory (.. refers to the parent)
directory
projectdir/a.out also works, if your program is in the sub-directory, projectdir
That's because a.out is not in your $PATH.
The command you provide is searched in the $PATH (environment variable in linux) by the shell.
$PATH basically is the list of directories. When you provide the executable name, shell searches it in the directories provides by $PATH.
Since a.out is not in your $PATH, you've to explicitly provide the path to a.out.

Running C programs in Linux/MacOSX

Here is another(probably) noob question. Let us assume that I have a simple 1 file program (called myProg.c) written in C. When I want to compile this program in Linux/MacOSX, I type "gcc -o haha myProg.c". The executable file that is generated is now named "haha". When I wish to run this program, I will need to type "./haha" in the console.
What do I need to do to stop typing "./" always? How can I make sure that by just typing "haha", my program will be invoked? I have checked the permissions of the file "haha" and it is executable. Am I correct in thinking that the "./" indicates that the path of executable file i.e., the file is present in the current directory (".")??
The current directory is by default not a part of PATH in unix-derived OS'es. This is a security measure, which you can but should not change by modifying PATH in your .bash_profile or .bashrc
The reason not to include the current directory in path: Assume that you are root, and you have a malicious user. This user creates e.g. a ls executable in his home directory, which does something not nice. If you're looking at what this user is up to, and type ls while in his home directory, his ls will be executed.
If you want to just change it, add PATH="${PATH}:." to your .bashrc and .bash_profile

User defined command

I am having a situation for which I am looking for some suggestion.
Suppose I write a program which prints the directory names of the directories.
Is it possible to convert this program into a command (just on my system).
Not be alias but via C only.
As long as the file is executable (has the exec x access for the user starting it) and can be seen from the command interpreter (usually bash or sh), you can consider it to be a command.
There will be no difference in running your own file from your path than the ls command for instance.
Also, the C (or C++ ...) language is not a requirement. There are plenty of commands in, for instance, /usr/bin that are a script, meaning they're sh or bash (or even perl)...
access Ensure the file has the x access right (e.g. chmod u+x file)
path Ensure the file is in your PATH, or add an entry in your path (for instance) with PATH=$PATH:mypath
test Test it well before to put it in a path from which other users may have access
Put it in the path. On Linux, for example, you should put it in /usr/local/bin.
First, compile the program and create an executable using gcc program.c -o myexecfile. Then, an executable file named myexecfile is created in the same directory. You can run it by using ./myexecfile.
If you are on Unix(Linux etc.) and want to use it like ls or any other standard command, you need to place it in a directory that is specified in $PATH variable. For example, /usr/local/bin.

Resources