There doesn&#39;t seem to be any mention of any equivalent pragmas in the [GCC manual&#39;s page on pragmas][1].

One reason I saw for GCC not supporting linking in source code was that sometimes, [correct linking *depends* on link order][2]; and this would require you to make sure that the linking order happens correctly no matter the order of compilation.  If you&#39;re going to go to that much work, you may as well just pass the linker arguments on the command line (or otherwise), I suppose.


  [1]: http://gcc.gnu.org/onlinedocs/gcc/Pragmas.html
  [2]: http://www.network-theory.co.uk/docs/gccintro/gccintro_18.html

&gt; Libraries should be specified during the linking step. Such information simply
&gt; doesn&#39;t belong inside a translation unit. A translation unit can be preprocessed,
&gt; compiled and assembled even without a linking stage.

Simply because `#pragma comment(lib,&quot;xxx.lib&quot;)` is in the source file does not mean the compiler consumes it. In fact, it goes in as a comment and is subsequently used by the linker. Not much different than *nix.


Use this GCC flag to generate an error for unknown pragmas.  It will quickly tell you if the compiler understands it.

`-Werror=unknown-pragmas`



I have written a pretty extensive REST API using Java Jersey (and JAXB). I have also written the documentation using a Wiki, but its been a totally manual process, which is very error-prone, especially when we need to make modifications, people tend to forget to update the wiki.

From looking around, most other REST API&#39;s are also manually creating their documentation. But I&#39;m wondering if theres maybe a good solution to this.

The kind of things which need to be documented for each endpoint are:

 - Service Name  
 - Category
 - URI 
 - Parameter
 - Parameter Types
 - Response Types
 - Response Type Schema (XSD) 
 - Sample requests and responses
 - Request type (Get/Put/Post/Delete) 
 - Description
 - Error codes which may be returned


And then of course there are some general things which are global such as

 - Security
 - Overview of REST
 - Error handling
 - Etc


These general things are fine to describe once and don&#39;t need to be automated, but for the web service methods themselves it seems highly desirable to automate it. 

I&#39;ve thought of maybe using annotations, and writing a small program which generates XML, and then an XSLT which should generate the actual documentation in HTML. Does it make more sense to use custom XDoclet?


How to automate documentation of a REST API (Jersey Implementation)

I have a UITableView displaying a list of Cities.
I want to separate them by State.  I can&#39;t seem to figure out how to get it to pick the right items out of my Array.
If Section 1 (Arizona) has 2 Cities and Section 2 (California) has 2 Cities, during cellForRowAtIndexPath, Section 2, City 1 has an index of 0, even though it&#39;s the 3rd item in my array.
I thought about just turning my City Array into a State Array, where each item holds an Array of Cities, but I still don&#39;t know what section I&#39;m on and therefore don&#39;t know which City Array under the States Array I would need to access.


UITableView, how do I know what Section during cellForRowAtIndexPath?

I have a static library file called `libunp.a`, I do know I could use `gcc -lunp xx` to link to the library.

I could use `#pragma comment(lib,&quot;xxx.lib&quot;)` to tell the Microsoft C/C++ compiler to include the library; how could I do it under Linux/GCC?

#pragma comment(lib, &quot;xxx.lib&quot;) equivalent under Linux?

<p>I have a static library file called <code>libunp.a</code>, I do know I could use <code>gcc -lunp xx</code> to link to the library.</p>
<p>I could use <code>#pragma comment(lib,"xxx.lib")</code> to tell the Microsoft C/C++ compiler to include the library; how could I do it under Linux/GCC?</p>


In `errno.h`, this variable is declared as `extern int errno;` so my question is, is it safe to check `errno` value after some calls or use perror() in multi-threaded code. Is this a thread safe variable? If not, then whats the alternative ? 

I am using linux with gcc on x86 architecture. 

Is errno thread-safe?

I&#39;ve a small C-program which just reads numbers from stdin, one at each loop cycle. If the user inputs some NaN, an error should be printed to the console and the input prompt should return again. On input of &quot;0&quot;, the loop should end and the number of given positive/negative values should be printed to the console. Here&#39;s the program:

    #include &lt;stdio.h&gt;
    
    int main()
    {
        int number, p = 0, n = 0;
    
        while (1) {
            printf(&quot;-&gt; &quot;);
            if (scanf(&quot;%d&quot;, &amp;number) == 0) {
                printf(&quot;Err...\n&quot;);
                continue;
            }
            
            if (number &gt; 0) p++;
            else if (number &lt; 0) n++;
            else break; /* 0 given */
        }

        printf(&quot;Read %d positive and %d negative numbers\n&quot;, p, n);
        return 0;
    }

My problem is, that on entering some non-number (like &quot;a&quot;), this results in an infinite loop writing &quot;-&gt; Err...&quot; over and over. I guess it&#39;s a scanf() issue and I know this function could be replace by a safer one, but this example is for beginners, knowing just about printf/scanf, if-else and loops.

I&#39;ve already read the answers to the question[`scanf()` skips every other `while` loop in C][1] and skimmed through other questions, but nothing really answer this specific problem.

  [1]: https://stackoverflow.com/questions/1669821/scanf-skips-every-other-while-loop-in-c

Why is scanf() causing infinite loop in this code?

How many [GCC][1] optimization levels are there?

I tried gcc -O1, gcc -O2, gcc -O3, and gcc -O4

If I use a really large number, it won&#39;t work.

However, I have tried

    gcc -O100

and it compiled.

How many optimization levels are there?

  [1]: http://en.wikipedia.org/wiki/GNU_Compiler_Collection


How many GCC optimization levels are there?

I am wondering why gcc/g++ doesn&#39;t have an option to place the generated object files into a specified directory.

For example:

    mkdir builddir
    mkdir builddir/objdir
    cd srcdir

    gcc -c file1.c file2.c file3.c **--outdir=**../builddir/objdir

I know that it&#39;s possible to achive this with separate -o options given to the compiler, e.g.:

    gcc -c file1.c -o ../builddir/objdir/file1.o
    gcc -c file2.c -o ../builddir/objdir/file2.o
    gcc -c file3.c -o ../builddir/objdir/file3.o

... and I know that I can write Makefiles via VPATH and vpath directives to simplify this.

But that&#39;s a lot of work in a complex build environment.

I could also use

    gcc -c file1.c file2.c file3.c

But when I use this approach my srcdir is full of .o garbage afterwards.

So I think that an option with the semantics of --outdir would be very useful.

What is your opinion?

**EDIT**: our Makefiles are written in such a way that .o files actually placed into  builddir/obj. But I am simply wondering if there might be a better approach.

**EDIT**: There are several approaches which place the burden to achieve the desired behavior to the build system (aka Make, CMake etc.). But I consider them all as being *workarounds* for a weakness of gcc (and other compilers too).

gcc/g++ option to place all object files into separate directory

Just to make it clear, I&#39;m not going for any sort of portability here, so any solutions that will tie me to a certain box is fine.

Basically, I have an if statement that will 99% of the time evaluate to true, and am trying to eke out every last clock of performance, can I issue some sort of compiler command (using GCC 4.1.2 and the x86 ISA, if it matters) to tell the branch predictor that it should cache for that branch?

Is it possible to tell the branch predictor how likely it is to follow the branch?

Are there any compelling performance reasons to choose static linking over dynamic linking or vice versa in certain situations? I&#39;ve heard or read the following, but I don&#39;t know enough on the subject to vouch for its veracity.

1) The difference in runtime performance between static linking and dynamic linking is usually negligible.

2) (1) is not true if using a profiling compiler that uses profile data to optimize program hotpaths because with static linking, the compiler can optimize both your code and the library code. With dynamic linking only your code can be optimized. If most of the time is spent running library code, this can make a big difference. Otherwise, (1) still applies.

Static linking vs dynamic linking

In fact, *-static* gcc flag on Linux doesn&#39;t work now. Let me cite from the GNU libc FAQ:

&gt; **2.22. Even statically linked programs need some shared libraries
&gt; which is not acceptable for me. What
&gt; can I do?**
&gt; 
&gt; {AJ} NSS (for details just type `info
&gt; libc &quot;Name Service Switch&quot;&#39;) won&#39;t
&gt; work properly without shared
&gt; libraries.  NSS allows using different
&gt; services (e.g. NIS, files, db, hesiod)
&gt; by just changing one configuration
&gt; file (/etc/nsswitch.conf) without
&gt; relinking any programs.  The only 
&gt; disadvantage is that now static
&gt; libraries need to access shared 
&gt; libraries.  This is handled
&gt; transparently by the GNU C library. 
&gt; 
&gt; A solution is to configure glibc with
&gt; --enable-static-nss.  In this case you can create a static binary that will
&gt; use only the services dns and files
&gt; (change /etc/nsswitch.conf for this).
&gt; You need to link explicitly against
&gt; all these services. For example:
&gt;  
&gt; 
&gt;      gcc -static test-netdb.c -o test-netdb \
&gt;        -Wl,--start-group -lc -lnss_files -lnss_dns -lresolv -Wl,--end-group
&gt; 
&gt;   The problem with this approach is
&gt; that you&#39;ve got to link every static
&gt; program that uses NSS routines with
&gt; all those libraries.  
&gt; **{UD} In fact, one cannot say anymore that a libc compiled with this option
&gt; is using NSS.  There is no switch
&gt; anymore.  Therefore it is *highly*
&gt; recommended *not* to use
&gt; --enable-static-nss since this makes the behaviour of the programs on the
&gt; system inconsistent.**

Concerning that fact is there any reasonable way now to create a full-functioning static build on Linux or static linking is completely dead on Linux? I mean static build which:

 - Behaves exactly the same way as
   dynamic build do (static-nss with
   inconsistent behaviour is evil!);
 - Works on reasonable variations of glibc environment and Linux versions;



Linux static linking is dead?

I would like to have control over the type of the libraries that get found/linked with my binaries in CMake. The final goal is, to generate binaries _&quot;as static as possible&quot;_ that is to link statically against every library that does have a static version available. This is important as would enable portability of binaries across different systems during testing. 

ATM this seems to be quite difficult to achieve as the FindXXX.cmake packages, or more precisely the find_library command always picks up the dynamic libraries whenever both static and dynamic are available. 

Tips on how to implement this functionality - preferably in an elegant way - would be very welcome!

CMake: how to produce binaries &quot;as static as possible&quot;

I&#39;ve had numerous problems compiling shared objects that link statically against static libraries. This problem only shows up on x84_64 platforms. When doing the same compilation work on x86_32 I do not have any problems. 

Perhaps this is a OS specific GCC configuration thing, but my research indicates that its how GCC works on x86_64 platforms. Anyhow, I am using gcc 4.4.3 on Ubuntu 10.04 x86_64.

How is the problem fixed ?... Making sure all the static library dependencies are compiled with -fPIC.

**Question 1:** What is the difference between -fpic and -fPIC (apparently -fPIC generates more instructions on x86) ? Why is the later type more relevant in the x86_64 context ? 

**Question 2:** My assumption is that when you link against static code you are hard-wiring the functions into your binary at link time, why does it need the level of indirection the &quot;position independant code&quot; machinery provides ? 

**Question 3:** Now if x86 doesn&#39;t need -fpic / -fPIC to link shared objects against static archives why is it needed in x86_64 ? 

**Question 4:** even if it is needed why isn&#39;t it supplied implicitly ? I thought breaking changes was supposed to be a big no-no

Why does gcc not implicitly supply the -fPIC flag when compiling static libraries on x86_64

Recently, I switched to Xcode4 and when I compile my project I got following error.

    ld: warning: ignoring file /Users/myname/Library/Developer/Xcode/DerivedData/appname-hezrgyqimckztgbdlslkavphdclw/Build/Products/Debug-iphoneos/libTapkuLibrary.a, file was built for archive which is not the architecture being linked (armv6)
    Undefined symbols for architecture armv6:
      &quot;_OBJC_CLASS_$_TKLoadingView&quot;, referenced from:
          objc-class-ref in RootViewController.o

I opened the TapkuLibrary and checked that it&#39;s Architectures set to &#39;Standard (armv6 armv7)&#39;.

What can I do to fix this problem?


Content Type	Original Author	Original Content on Stackoverflow
Question	Jichao	View Question on Stackoverflow
Solution 1 - Gcc	Mark Rushakoff	View Answer on Stackoverflow
Solution 2 - Gcc	Jeffrey Walton	View Answer on Stackoverflow
Solution 3 - Gcc	J. Winarske	View Answer on Stackoverflow

#pragma comment(lib, "xxx.lib") equivalent under Linux?

Gcc Problem Overview

Gcc Solutions

Solution 1 - Gcc

Solution 2 - Gcc

Solution 3 - Gcc

UITableView, how do I know what Section during cellForRowAtIndexPath?

How to automate documentation of a REST API (Jersey Implementation)

Attributions