libstdc- | libstdc++ library removed after Xcode | Code Editor library

GCC will adjust the linker command line accordingly if you invoke it as gcc -mx32. It is more than just a compiler flag.

As discussed separately, a boost::asio solution would be best, but your question is specifically about how getline is blocking, so I will talk to that.

The problem here is that std::ifstream is not really made for a FIFO file type. In the case of getline(), it is trying to do a buffered read, so (in the initial case) it decides the buffer does not have enough data to reach the delimiter ('\n'), calls underflow() on the underlying streambuf, and that does a simple read for a buffer-length amount of data. This works great for files because the file's length at a point in time is a knowable length, so it can return EOF if there's not enough data to fill the buffer, and if there is enough data, it simply returns with the filled buffer. With a FIFO, however, running out of data does not necessarily mean EOF, so it doesn't return until the process that writes to it closes (this is your infinite sleep command that holds it open).

A more typical way to do this is for the writer to open and close the file as it reads and writes. This is obviously a waste of effort when something more functional like poll()/epoll() is available, but I'm answering the question you're asking.

I realized I was using jupyter kernelspec in a non-intended way here. It is not intended to actually create the kernel, but only to add a kernelspec if it exists (see here, at the bottom).

There are two options for writing a kernel:

1. You can reuse the IPython kernel machinery to handle the communications, and just describe how to execute your code. This is much simpler if the target language can be driven from Python. See Making simple Python wrapper kernels for details.
2. You can implement the kernel machinery in your target language. This is more work initially, but the people using your kernel might be more likely to contribute to it if it’s in the language they know.

So, in my case what I really wanted to do was use IPythons utilities (option 1 above) which is documented well here. In which case to add the shared conda environment as a kernel in a way the users can access it I just need to run.

Is it possible giving this constraint on GCC to write a visitor class for the code example I included, so that the ostream stuff can be removed?

Sure. Basically, I see three approaches:

You can specialize the implementation details accidentally required by GCC:

it works for me -> i removed libstdc++.6.0.9.tbd -> clean and delete derived data -> run please backup your code and try it

Your build environment is incorrect.

MSYS2 has 3 shells (and toolchains)

• MSYS2: posix emulation with msys-2.0.dll (similar to cygwin1.dll).
• MINGW32: 32-bit Windows native
• MINGW64: 64-bit Windows native

the libiberty/configure selects the pex version to use based on this logic:

So, the problem was solved when I fully recompiled gcc instead of reconfiguring.

My 50 cents:

I'm a big fan of linking stuff statically (especially on Windows), but the price is that in case there are bugs/security problem, you have to re-ship your product or offer an update. I'm reluctant to doing that in Linux/Unix, because you generally don't have binary compatibility over all Unix operating systems. If you compile for a target system, then it doesn't matter (except, again, you have to take care of bugs yourself with updates).

Performance wise, shared libraries have this little overhead of loading the libraries, which is ridiculously negligible nowadays.

Legally, you're fine (Disclaimer, I'm not a lawyer, you may want to consult your company's lawyer). GNU has an exception on their Runtime libraries:

The source code is distributed under the GNU General Public License version 3, with the addition under section 7 of an exception described in the “GCC Runtime Library Exception, version 3.1” as follows (or see the file COPYING.RUNTIME)

If that wasn't the case, then no propietary products would have been ever available on Linux.

Also you might want to consider using the Clang compiler if you're concerned about licensing. It has a very tolerant BSD license. Well, since you're rewriting stuff from scratch.