I'm trying to debug my code in VS Code. When I "Run" the code (the button on the top right corner or Ctrl+Alt+N) it works perfectly. But when I try debug, the code goes to the flow==NULL option.
Here is my reading function from code:
AVLTree readData(char* file_name){
AVLTree myTree;
myTree = CreateTree();
/* Opening file stream for reading data from the file */
FILE* flow;
flow = fopen(file_name,"r");
if(flow==NULL){
printf("\nflow == NULL option\n");
printf("File Error"); exit(1);
}
else{
printf("File opened successfully\n");
}
Also here is my launch.json:
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "gcc.exe - Etkin dosyayı derle ve dosyada hata ayıkla",
"type": "cppdbg",
"request": "launch",
// "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
"program": "${fileDirname}\\indexingphotos.exe",
"args": [],
"stopAtEntry": false,
"cwd": "C:\\Program Files\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64\\bin",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"miDebuggerPath": "C:\\Program Files\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64\\bin\\gdb.exe",
"setupCommands": [
{
"description": "gdb için düzgün yazdırmayı etkinleştir",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "C/C++: gcc.exe etkin dosyayı derle"
}
]
}
What should I do?
Also, I'm a computer engineering student and I worked with Dev C++ until now. I'm trying to switch to VS CODE, but it seems too confusing than Dev C++. How can I learn to use VS Code (or another modern IDE) any suggestions?
There is one thing you can try: change the value of "cwd"(current working directory) in "launch.json" to the folder where you have your file to read. For example, if you have your file to read in the path "C:\Users\username\Documents\file.txt", just put the "cwd": "C:\Users\username\Documents", then compile and run it again.
The "launch.json" file controls the arguments for your C++ debugger and you can find a full list of such arguments including "cwd" in the reference of VS code here. One possible reason why you cannot read the file is that your program cannot find the file because your file is not in the search path of your program.
I had the same issue just now and tried to solve it by setting the current working directory although I'm not sure if that's the best way to do it. A better way is probably to run debugger with argument to add new directory to the search path(like what you can do in "task.json" using -I argument). I was not able to find an argument for gdb. But one thing is for sure: you have to let the program or debugger find the file in some way.
In my case, replacing ${fileDirname} with ${workspaceFolder} resolved the issue
Related
I wrote the following C program:
#include <stdio.h>
int main()
{
printf("size of void pointer in bytes : %d\n", sizeof(void*));
return 0;
}
I am using Windows 10 now, hence, I installed the gcc compiler (MinGW for Windows). Now I want to compile my program once for the 32 bit architecture and then for 64 bit architecture. In order to do so, I added m32 to the args parameter in launch.json, then compiled the program. After that, I done the same thing but for the 64 bit architecture (added m64 flag).
In both cases the output of the program was:
size of void pointer in bytes : 8
That made me wonder. If I compile my program in Visual Studio (there you can choose the architecture pretty simple, in the dropdown menu next to the "green arrow"), then the word size is 4 bytes (32 bit architecture) and 8 bytes (64 bit architecture) as it should be.
I also tried to use -march=i386 for the 32 bit architecture but it does not help me, the pointer was still 8 byte long. It seems that the passed arguments do not affect the architecture at all. Am I missing something or using the wrong arguments for my purpose?
My launch.json file (with -m32 flag):
{
"version": "0.2.0",
"configurations": [
{
"name": "gcc.exe - Build and debug active file",
"type": "cppdbg",
"request": "launch",
"program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
"args": ["-m32"],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"miDebuggerPath": "D:\\Compilers\\MinGW\\mingw64\\bin\\gdb.exe",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "C/C++: gcc.exe build active file"
}
]
}
launch.json contains commands describing how to launch the compiled files. args are command-line arguments passed to the program (argc,argv), not the compiler.
You need to setup tasks.json which basically executes scripts.
Search for (ctrl+shift+P for me) Tasks:Configure Task or Task:Configure Default build Task. Or you can find them in the Terminal menu.
It can find gcc on its own and create a default task for it which compiles the currently active file. Unfortunately, I do not have experience with managing multi-file projects direclty in VSCode, so I cannot help more, but you should be able to find some default tasks.json for C++ on the internet. Or go with CMake or similar.
When debugging a C project in VSCode with GDB, the output to stdout (through printf()) does not appear on the Debug Console. When using cppvsdebug, however, it works.
This is my launch.json:
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "Debug",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/${fileBasenameNoExtension}",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": false
}
],
"windows": {
"miDebuggerPath": "C:/raylib/mingw/bin/gdb.exe",
},
"osx": {
"MIMode": "lldb"
},
"linux": {
"miDebuggerPath": "/usr/bin/gdb",
},
"preLaunchTask": "build debug"
},
{
"name": "Run",
"type": "cppdbg",
"request": "launch",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"program": "${workspaceFolder}/main",
"MIMode": "gdb",
"windows": {
"program": "${workspaceFolder}/main.exe",
"miDebuggerPath": "C:/raylib/mingw/bin/gdb.exe"
},
"osx": {
"MIMode": "lldb"
},
"linux": {
"miDebuggerPath": "/usr/bin/gdb"
},
"preLaunchTask": "build release",
}
]
}
This is the command that is executed to run the debug session (according to the terminal window):
'c:\Users\...\.vscode\extensions\ms-vscode.cpptools-0.27.1\debugAdapters\bin\WindowsDebugLauncher.exe' '--stdin=Microsoft-MIEngine-In-2dvbqvix.1cb' '--stdout=Microsoft-MIEngine-Out-1m5j1iy0.ufe' '--stderr=Microsoft-MIEngine-Error-oqyothgz.h5l' '--pid=Microsoft-MIEngine-Pid-hal3wx4b.uld' '--dbgExe=C:/raylib/mingw/bin/gdb.exe' '--interpreter=mi'
The Debug Console shows the "splash screen" info of GDB, but doesn't display any of the output from the printf() statements in my code:
=thread-group-added,id="i1"
GNU gdb (GDB) 8.1
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-w64-mingw32".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word".
Warning: Debuggee TargetArchitecture not detected, assuming x86_64.
=cmd-param-changed,param="pagination",value="off"
[New Thread 9488.0x54dc]
[New Thread 9488.0x577c]
[New Thread 9488.0xff4]
[New Thread 9488.0x4918]
When I run the Exe file with GDB from the commandline (Git Bash), all the output is displayed normally.
Setting externalConsole to true doesn't work (it also doesn't open an external console to begin with).
I'm on Windows 10.
Is there any specific setting I need to adjust for this to work?
Setting "externalConsole" to true solved the issue for me.
I ended up somewhat fixing this. In my launch.json I set filterStdout to true (I know it's default but lol): https://code.visualstudio.com/docs/cpp/launch-json-reference#_filterstdout
Setting filterStdout to false does the same thing. So I'm sure there's a bug somewhere. I believe the intention is that setting it to true is supposed to get stdout output into the Debug Console tab.
Now when I call my method that calls printf, I just go into the terminal tab and lo and behold my call is in the Terminal tab!!!!
fflush(stdout);
after your printf statement worked for me.
printf writes to the output stream stdout. stdout waits to be flushed (so it can then be displayed in the terminal). It must be flushed to be displayed, which is normally accomplished via newline characters (\n) since stdout is line-buffered. (gh)
I had this problem just now, too, the program output was not shown in the "Debug Console". Restarting Visual Studio Code helped, now the output is visible again.
It will however output on newline.. so as a workaround, add a '\n' to flush.
I have a simple c program, with prints something to screen.
When I debug the program I can see the DEBUG CONSOLE, however as soon as I use fgets I don't see any output. Where does my program run when debugging using VS Code?
If I just run my compiled .exe, everything is printed as expected.
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Hello World!\n");
printf("Enter your name\n");
char name[100];
// fgets(name, sizeof(name), stdin); // as soon as I uncomment this, no output is in the output console
printf("You name %s", name);
return 0;
}
my launch.json:
{
"version": "0.2.0",
"configurations": [
{
"name": "(Windows) Launch",
"type": "cppvsdbg",
"request": "launch",
"program": "${workspaceFolder}/app.exe",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false
}
]
}
One solution may solve your issue.
How to configure tasks.json and launch.json from VSCode
You don't need to do any type of coding for this, just follow the steps:
Delete tasks.json and launch.json located in .vscode folder
Press F5 (debugging shortcut) again focusing on that C program file, you'll see something like:
Select your compiler which is GCC (since you're trying to debug a C program and ensure the compiler is installed into your system).
You'll be prompted to select a configuration (assuming selected option: GCC), you'll get launch.json created automatically by VSCode as shown below:
Note: Keep the preLaunchTask configuration in your mind (located at the bottom-most of the config).
As soon as you press F5 again (this time, for creation of tasks.json) you'll get something shown below, simply select Configure Tasks:
Now, you'll be redirected into tasks.json, edit the label to the name you've selected in § 4 (remember that name). In other words, launch's preLaunchTask and tasks' label should be the same. Process shown below:
And now, you can make a successful debug. A working example:
Just add externalConsole": true to you configuration in launch.json.
For example:
launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "(Windows) Launch",
"type": "cppvsdbg",
"request": "launch",
"program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"preLaunchTask": "cl.exe build active file",
}
]
}
tasks.json
{
"version": "2.0.0",
"tasks": [
{
"type": "shell",
"label": "cl.exe build active file",
"command": "cl.exe",
"args": [
"/Zi",
"/EHsc",
"/Fe:",
"${fileDirname}\\${fileBasenameNoExtension}.exe",
"${file}"
],
"problemMatcher": ["$msCompile"],
"group": {
"kind": "build",
"isDefault": true
},
}
]
}
I'm trying to setup VSCode to build and debug C on Windows.
I have installed MinGW.
I'm trying to generate an .exe file for the following code:
#define USE_PTS true
#include "Cartography.h"
static Cartography cartography ;
static int nCartography = 0;
int main(void)
{
nCartography = loadCartography("map (1).txt", &cartography);
showCartography(cartography, nCartography);
interpreter(cartography, nCartography);
return 0;
}
I have two other files Cartography.hand Cartography.c.
If I run the following command using the powershell terminal, it generates an .exe file perfectly:
gcc -std=c11 -o Main Cartography.c Main.c -lm
But if I try to build it using VSCode (using Ctrl + Shift + B) it doesn't recognize the other files:
> Executing task in folder Projeto2LAP: gcc -std=c11 -o Main Cartography.c Main.c -lm <
gcc.exe: error: Cartography.c: No such file or directory
gcc.exe: error: Main.c: No such file or directory
The terminal process terminated with exit code: 1
Terminal will be reused by tasks, press any key to close it.
Here is my tasks.json file:
{
"version": "2.0.0",
"tasks": [
{
"type": "shell",
"label": "C/C++: gcc.exe build active file",
"command": "gcc -std=c11 -o Main Cartography.c Main.c -lm",
"options": {
"cwd": "C:\\Program Files (x86)\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32\\bin"
},
"problemMatcher": [
"$gcc"
],
"group": {
"kind": "build",
"isDefault": true
}
}
]
}
The other issue I have is when I'm trying to use the built in VSCode debugger.
I generate the .exe file using the command I mentioned, so an .exe file is present in the current folder.
(I should also mention that the folder I'm working on only contains the files and the .vscode folder, there are no subfolders or anything that could cause an error).
When I click on debug it gives me the following error message:
Error message prompt
Here is my launch.json file:
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "(gdb) Launch",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/Main.exe",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"miDebuggerPath": "C:/Program Files (x86)/mingw-w64/i686-8.1.0-posix-dwarf-rt_v6-rev0/mingw32/bin/gdb.exe",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
}
]
}
What am I doing wrong?
Your first question:
When you use the powershell command, it gets your *.c files from your current wording directory via relative paths. This is what you attempt to do in the task command, but your CWD is set to the wrong place. In tasks.json, you need to either specify the absolute paths of your files in the gcc command or change your CWD to the directory of the *.c files. Or better, VSC lets you set "cwd": "${workspaceFolder}". This means if you change the name or do any other edits, your task will still work. (For bonus points, you could set the CWD to the enclosing folder of the currently selected file.) First question part 2: The task error probably isn't you. It appears to be a known bug. Instructions here to mitigate it.
Sorry for the late response
I don't see any reason why you would get the debugging error, so my only guess is a permissions problem. Your debugger may not be able to "see" that that directory exists. Make sure neither it nor any of its parent folders have unduly tights restrictions.
Rather than pass one long string to launch GCC in tasks.json, consider using the "args" list variable, placing each arg in a separate element of the list.
Assuming your source files are located within the same directory that was opened in VSCode, the previously-mentioned "${workspaceFolder}" macro will construct the correct paths.
Otherwise, provide absolute paths to your source files as earlier suggested.
Example:
{
"label": "GCC Build Debug (64-bit)",
"type": "shell",
"command": "C:\\Program Files (x86)\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32\\bin\\gcc",
"args": [
"--std=c11",
"-g",
"-lm",
"-o",
"${workspaceFolder}/Main"
"${workspaceFolder}/Main.c",
"${workspaceFolder}/Cartography.c"
],
"problemMatcher": [
"$msCompile"
]
},
I'm trying to live-debug a C program which, using the C/C++ expansion from VScode, also allows me to write direct input to the console using scanf(). However, when I debug the code it opens the debug console, which does not allow me to enter any input.
I found two threads in which people answered this problem:
https://github.com/OmniSharp/omnisharp-vscode/issues/1053
Debug Console window cannot accept Console.ReadLine() input during debugging
Both advise to set the "console" property in the launch.json file to either "externalTerminal" or "integratedTerminal". I however couldn't find the property or create it for that matter, because it doesn't exist in my file.
I do have the "externalConsole" property, which can be set to either true or false. But both options seem to open the debug console like before.
The launch.json file:
{
"name": "(gdb) Launch",
"type": "cppdbg",
"request": "launch",
"program": "/mnt/c/Users/David/Documents/code/puc-rio/inf1010/lab8/teste.out",
"args": [],
"stopAtEntry": true,
"cwd": "/mnt/c/Users/David/Documents/code/puc-rio/inf1010/lab8/",
"environment": [],
"externalConsole": true,
"windows": {
"MIMode": "gdb",
"miDebuggerPath": "/usr/bin/gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
]
},
"pipeTransport": {
"pipeCwd": "",
"pipeProgram": "c:\\windows\\sysnative\\bash.exe",
"pipeArgs": [
"-c"
],
"debuggerPath": "/usr/bin/gdb"
},
"sourceFileMap": {
"/mnt/c": "${env:systemdrive}/",
"/usr": "C:\\Users\\David\\AppData\\Local\\Packages\\CanonicalGroupLimited.Ubuntu18.04onWindows_79rhkp1fndgsc\\LocalState\\rootfs\\usr"
}
}
]
What happens when I try to write something to the debug console:
Unable to perform this action because the process is running.
I had the same confusion before I saw your post. In my Windows environment, I set "externalConsole" to be true. After that, when the debugging started there will be a cmd shell of my program (not the "debug console" provided by VScode), in which stdin can be typed.!(https://i.stack.imgur.com/KKlJP.jpg)