Xcode and Curses.h with Error opening terminal

I am trying to compile a simple curse project with Xcode.
The program compiles fine with g++ in terminal with the flag -lcurses, and runs fine.

Started of by creating a Command Line Tool with type c++.
imported curses.h into my main.
In the Target"program"Info -> General -> Linked Libraries, libCurses.dylib has been added.

It compiles fine but the terminal window will not open.
In the Debug Console the output is,

Program loaded.
run
[Switching to process 3424]
Error opening terminal: unknown.
Running…

I can go to build folder and just open the program in terminal but is there any way for xcode to open the terminal?

Thanks for any help!

I had the same problem with ncurses debugging in Xcode. Finally I've found a good way for me to manage debugging with Terminal.app that allows to debug ncurses.

As we know, to initialise and use ncurses we need to run our application in terminal. But Xcode doesn't open terminal when we press run button. So, if we request environment variable TERM in from code, we'll get NULL. This is why application crashes on initscr().

But Xcode allows us to setup Launch option for Run scheme (Product > Scheme > Edit scheme... > Run) to "Wait for executable to be launched" instead of default "Automatically":

Now we can press Run in Xcode and after launch our application manually in Terminal. So debugger will be attached to the application. There are 2 problems in that:

If say honestly, debugger will not be attached self without additional actions and it will skip all breakpoints. But we can manage it by calling getchar() at the beginning of our program. I solved this problem by introducing command line argument that indicates we are debugging in terminal:
```
for (int argi = 1; argi < argc; argi++)
{
    if (strcmp(argv[argi], "--debug-in-terminal") == 0)
    {
        printf("Debugging in terminal enabled\n");
        getchar(); // Without this call debugging will be skipped
        break;
    }
}
```
So, we can turn on getchar() call only when we want to debug inside Terminal.app
We need to open Terminal and launch the application manually each time when we press Run in Xcode. This is really annoying. So, I decided to automate it through Pre-actions in Run scheme settings. The idea is to open Terminal and run our application in it. But this pre-action should launch the application AFTER Xcode will execute Run action to let it "Wait for executable to be launched" first. So we need a background non-blocking task with a delay. This can be achieved by following shell command (& in the end needed to run in the background):
```
osascript -e 'tell application "Terminal"' -e 'delay 0.5' -e "set currentTab to do script (\"$TARGET_BUILD_DIR/$PRODUCT_NAME --debug-in-terminal\")" -e 'end tell' &
```
Don't forget to select your application in "Provide build settings from" list to make accessible important environment variables $TARGET_BUILD_DIR and $PRODUCT_NAME:

So, now when we press Run, Xcode will wait for executable to attach, Terminal will be opened and our application will be executed with command line option --debug-in-terminal and all breakpoints will be triggered.

Pretty nice, but it will be even better to close this Terminal window in the end, because it will generate new one for each debug session. Let's do it in Post-actions for Run scheme:
```
osascript -e 'activate application "Terminal"' -e 'delay 0.5' -e 'tell application "System Events"' -e 'tell process "Terminal"' -e 'keystroke "w" using {command down}' -e 'end tell' -e 'end tell'
```
This command just closes active terminal window, so maybe this Post-action is not needed if you plan to use terminal for some other purposes during debug session, because you can close some important window accidentally.

And finally, an idea of safe ncurses code, that checks if we can use ncurses or no:

#include <stdlib.h>
#include <string.h>
#include <ncurses.h>


bool IsTerminalAvailable = false; // Check this global variable before ncurses calls


int main(int argc, const char *argv[])
{
    for (int argi = 1; argi < argc; argi++)
    {
        if (strcmp(argv[argi], "--debug-in-terminal") == 0)
        {
            printf("Debugging in terminal enabled\n");
            getchar(); // Without this call debugging will be skipped
            break;
        }
    }

    char *term = getenv("TERM");

    IsTerminalAvailable = (term != NULL);

    if (IsTerminalAvailable)
        IsTerminalAvailable = (initscr() != NULL);

    // Do some code here....

    if (IsTerminalAvailable)
    {
        printw("Press any key to exit...");
        refresh();

        getch();

        endwin();
    }

    return 0;
}

There is no terminal to attach to in the Xcode IDE. Instead run the program from a shell (via Terminal application)

./build/Debug/myprogram

If you want to use the IDE debugger (which is just gdb) you can attach to the process. Fist get the process id,

gdb> attach mypid

For a more convenient method, I'll quote Step into Xcode: Mac OS X development

Open the Executables group in the Groups & Files list, select the application, open an Info window, and in the Debugging tab, uncheck Start executable after starting debugger. When you're ready to debug, start the debugger, and then then launch the target application in its friendly environment. In the debugger's gdb console, type attach myprogram, and your debugging sesssion is under way.

In XCode 8 you can choose to run within the terminal, from the Edit Scheme... Options page.

Though in my quick testing it doesn't seem to work all that well; it sometimes (not always) seems to 'lose' the debuggee, or the debuggee never starts, and thinks it's still running. If you try to exit, Xcode gets stuck. I have found that if you find and then kill a process called lldb-rpc-server you can avoid having to force-quit.

In more detail (in case this helps anyone) whenever the debuggee fails to start, I open a Terminal and type