I have a function with something like
FILE *file1 = fopen("testing.txt", "r");
I can't modify this line. However, if I make a file named "testing.txt" in, say /tmp, would I be able to make the function load the file from /tmp instead of it's own directory. (Maybe by modifying the PATH variable?)
If the program doesn't change its own working directory, you could cd into /tmp and simply run the program from there.
$ cd /tmp
$ /absolute/path/to/my_program
That opens a file from your current working directory.
You can change the current working directory using chdir.
See this.
This is using C code.
You can also use cd.
For example, go to the terminal:
$ cd /tmp
$ cd /path_to_your_program
Also, cd .. will make you go to the directory above, and cd will make you go to the home directory.
Also, if you do not have the program in the directory in which you have to compile it, you can use cp which copies file.
$ cp /path_to_copy_from /path_to_copy_to
Then you can go to that directory, and run it from there.
I would recommend you to take a basic linux tutorial like this.
Related
Suppose I launch vim from a large project root folder and want to compile a specific example (I ll use zephyr RTOS for example). This root folder is located under /home/<user>/zephyr/
Let's say I run vim samples/basic/blinky/src/main.c.
Now if I want to compile it, I would go, from another terminal to samples/basic/blinky/build/ and run make
If I want to build it without leaving vim, I could run :make -C samples/basic/blinky/build/
I would like to automate this process, pressing any key, let's say f5.
So if I have, for example, two vertical splits, v1 and v2.
In v1 I have samples/basic/blinky/src/main.c and in v2 I have samples/drivers/rtc/src/main.c.
Pressing f5 from v1 would lead to run the equivalent of :make -C samples/basic/blinky/build/, and from v2 would lead to run the equivalent of :make -C samples/drivers/rtc/build/
The common pattern is that the build folder is located in ../build/ from the current c file directory.
I don't want to "permanently" use :cd or :lcd to change working directory, even for the current split/window because:
My ctags tags file is located in the root folder, so I want to be able to jump to any function that samples/basic/blinky/src/main.c uses but are not necessarily defined in the same file.
If I want to open a new file, I want to access it using its path from the root folder and not the current file path
My current solution is to have a function in my ~/.vimrc which temporally changes the working directory to the current file equivalent build folder, so that I can run :make and then changes back the working directory to the root folder.
It looks like this:
nnoremap <F5> :call MakeTst()<CR>
function! MakeTst(...)
:cd %:p:h
:cd ../build/
:make
:cd /home/<user>/zephyr/
endfunction
While this works, the downside is that the root folder is hardcoded inside the ~/.vimrc.
How can I achieve the same result without hardcoding the root folder path?
You gave the answer yourself: in your function. As long as your file
structure keeps that pattern, you can use filename modifiers to make it
generic:
:nnoremap <F5> :make -C %:p:h/../build
This will always build in the directory build at the same level of the
directory where the current file sits. Just like your example:
a/b/c/src/file.c
a/b/c/build
It breaks in a case like this:
a/b/c/src/include/features.h
As it would try to build in:
a/b/c/src/build
There is a workaround though. If your build is always at the same
level of src, then you can perform a text substitution with the :s
modifier:
:nnoremap <F5> :make -C %:p:s!.*\zssrc.*!build!
This simple pattern .*\zssrc.* searches for the last src in your
path and replaces it (and anything after it) with build. It does
nothing if there is no src in the path.
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.
I am making an online judge. This my school project.
I am taking a .c file from the user. I am able to compile the .c file with command prompt. But I don't know how to run this file. I need to run this file, take input from a text file and save output in a text file. The compilation code was:
gcc main.c -o HelloWorld
I need to run this file, take input from a text file and save output
in a text file.
Assuming you're on Linux, this should work:
./HelloWorld < input.txt > output.txt
Just type in the full path. For example, if you compiled the file in %homedrive% with the name dummy.exe, type %homedrive%/dummy.exe.
Also, if you're already in %homedrive%, you can just type dummy.exe.
Edit: Assuming you're on Windows.
When you type HelloWorld in Linux terminal, your system will be searching this program in place, where PATH variable indicates. Most likely it is /bin. You can check your PATH by typing:
echo $PATH
So, you must precise, that HelloWorld is in concrete dirctory or change $PATH variable.
./HelloWorld
Dot indicates current directory
I assume you're on Linux? If yes, run it with:
./HelloWorld
The ./ is needed so that the shell knows to look for the executable file in the current directory. (Executables are not looked for automatically in the current directory due to security reasons.)
If on Windows, just type its name:
HelloWorld
Appending .exe to the filename is optional.
Redirecting standard input works like this:
HelloWorld < inputfile
Standard output is redirected with > instead:
HelloWorld > outputfile
You can combine both:
HelloWorld < inputfile > outputfile
You can install TCC
#!/usr/local/bin/tcc -run
or else try the option ./HelloWorld
I need to create a makefile that will compile my simpleprogram.c to sp and it can be called like unix commands like ls,ps etc, without writing explicitly ./sp. I looked upon the web and cannot find a solution, or searching it in a wrong way. I cannot search like "executable without ./" , because I do not know what is this called => "./"
Put the binary in a directory that's in your PATH.
http://www.cs.purdue.edu/homes/cs348/unix_path.html
Just copy your program to your systems bin (executable binaries) directory.
Most commonly its /usr/bin for programs which can be used by all user.
If the app is only for admins, you should use /usr/sbin/ directory.
Remember to set the "executable" flag with chmod: chmod +x your_app
The proper solution to this (assuming you don't want sp to be run from outside of your makefile) is to call your program using the full path name instead of ./ (which is relative, and can change during multi-directory makes). In your makefile do something like:
SP_DIR := $(shell pwd)/spdir
rule : somedependency
$(SP_DIR)/sp
Where $(shell pwd) will expand to the directory the makefile is being run from. If your sp directory is in a parent directory of this, it is possible to use .. in the path as well: eg.
SP_DIR := $(shell pwd)/../../spdir
If you do want to run sp from outside of the makefile, then you need to either copy sp to a directory specified in your PATH variable (do echo $PATH to see these), or modify your .bashrc or equivalent file to make PATH include the directory that sp is built in.
John
You can just do:
export PATH=$PATH:.
But this is not a good idea, in general.
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