MinGW64 | MinGW64 compiler for running and debugging C

I just accidentally found the solution to the above problem. The problem is the package setuptools (which in my case is the version 60.9.1)! Indeed, by executing python setup.py build_ext --inplace --compiler=mingw32, the latter will call the class Mingw32CCompiler into setuptools/_distutils/cygwinccompiler.py which contains these two lines:

I'm used to the fact that image rows are often (not always) stored with a certain alignment. Whenever I see an image that appears erroneously in stripes, the row alignment is the first thing I would check.

With this suspicion in mind, I look for some gdkmm (or Gdk) doc. Instead I found a comment in the Gdk source code.

GitHub: gdk-pixbuf.c:

C++20 supports allocation during constexpr time, as long as the allocation is completely deallocated by the time constant evaluation ends. So, for instance, this very silly example is valid in C++20:

I'm a pylint maintainer. Can you upgrade to the latest pylint with pip install pylint -U and check that the problem still exists ? If it does this is definitely a problem with pylint. You can open an issue in pylint issue tracker so it gets fixed.

Great question, but it's not exactly the corporate proxy refusing self-signed certificates; it's pacman's SSL agent.

In your browser, go to repo.msys2.org to find which certificates are being used:

Open details:

You'll need to export all certificates individually, but don't need the lowest one for repo.msys2.org:

Save to a local file:

Export using Base-64 encoding:

Can save directly to the trust source anchors folder. Things move around from time to time, but as of now, that's C:\msys64\etc\pki\ca-trust\source\anchors\.cer

Go through the same steps to import the top-level root certificate. Save in the same path, different file name.

You could try using join to replace the CRLF with unix EOL:

The website you are using is displaying the binary representation of a floating-point number. For example, 3.14 is 40 48 F5 C3 in big-endian, or C3 F5 48 40 in little-endian.

The hex representation in C is the actual floating-point number in base 16, not it's binary representation. 0xc.8f5c3p-2 means c.8f5c3 * 2^(-2). If we convert this to decimal using the usual conversion algorithm, we get 3.14:

12(C) * 16^0 + 8 * 16^(-1) + 15(F) * 16^(-2) + 5 * 16^(-3) + 12(C) * 16^(-4) + 3 * 16^(-5) = 12 + 0.5 + 0.05859 + ... = 12.56 (with approximation)

Now multiply by 2^(-2), or divide by 4, and we get 3.14.

The difference between the 2 representations is shown here (note that this program technically causes undefined behavior in C, because of the uint32_t* to float* cast followed by dereference, but in this case the behavior is to use the binary representation to create a floating-point number, as one would expect):

For the first sample, MinGW is correct and MSVC is incorrect: the get_num call can only consider the function template.

This is a question of overload resolution, so I'll start in clause [over]. get_num(*this) is a plain function call expression, so [over.call.func] applies:

In unqualified function calls, the name is not qualified by an -> or . operator and has the more general form of a primary-expression. The name is looked up in the context of the function call following the normal rules for name lookup in function calls. The function declarations found by that lookup constitute the set of candidate functions.

"Name lookup" is discussed in section [basic.lookup]. Paragraph 2:

A name "looked up in the context of an expression" is looked up as an unqualified name in the scope where the expression is found.

One complication here is that the get_num(*this) default member initializer expression doesn't get used by anything until the default constructor of Foo is implicitly defined by its odr-use in main. But the lookup is determined from the code location of the expression itself, no matter that it's used in the process of that implicit definition.

For the second code sample, MinGW is again correct: the apparently recursive call inside the template definition actually calls the non-template function.

This is a result of "two phase lookup" for dependent function calls, described in section [temp.dep.res]. Briefly, since the type of t depends on a template parameter, the name get_num in the expression get_num(t) is considered a dependent name. So for each instantiation of the function template, it gets two ways of finding candidates for overload resolution: the ordinary immediate way which finds the get_num function template, plus another lookup from the point of instantiation. The specialization get_num has point of instantiation right after the main() definition, so overload resolution is able to find the non-template from the instantiation context, and the non-template wins overload resolution.

(Argument-dependent lookup is a related tangent issue to this second point. ADL applies to declarations from the instantiation context but not declarations from the definition context. But it's not directly a reason for the behaviors in either example program.)

None of this has changed significantly between C++14 and the latest draft, as far as I can see.