You must be reading some outdated copies of the manpages (emphasis added):

&gt; -rpath=dir&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;Add a directory to the **runtime** library search path.  This is used&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;when linking an ELF executable with shared objects.  All -rpath&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;arguments are concatenated and passed to the **runtime** linker, which&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;uses them to locate shared objects at **runtime.**

vs. 

&gt; -L searchdir&lt;br&gt;
&gt; --library-path=searchdir&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;Add path searchdir to the list of paths that **ld** will search for&lt;br&gt;
&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;archive libraries and ld control scripts.  

So, `-L` tells `ld` where to look for libraries to link against when linking. You use this (for example) when you&#39;re building against libraries in your build tree, which will be put in the normal system library paths by `make install`. `--rpath`, on the other hand, stores that path inside the executable, so that the runtime dynamic linker can find the libraries. You use this when your libraries are outside the system library search path.

I want to count the number of lines in a string 

i tried to use this stackoverflow answer :

    lines = str.split(&quot;\r\n|\r|\n&quot;); 
    return  lines.length;

on this string(which was originally a buffer):

     GET / HTTP/1.1
     Host: localhost:8888
     Connection: keep-alive
     Cache-Control: max-age=0
     User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_2) AppleWebKit/535.2 (KHTML,like Gecko) Chrome/15.0.874.121 Safari/535.2
     Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
     Accept-Encoding: gzip,deflate,sdch
     Accept-Language: en-US,en;q=0.8
     Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3

and for some reason i got lines=&#39;1&#39;.

any idea how to make it work?

How to count the number of lines of a string in javascript

is it possible to use Jasmine unit testing framework&#39;s spyon method upon a classes private methods?

The documentation gives this example but can this be flexivble for a private function?

    describe(&quot;Person&quot;, function() {
        it(&quot;calls the sayHello() function&quot;, function() {
            var fakePerson = new Person();
            spyOn(fakePerson, &quot;sayHello&quot;);
            fakePerson.helloSomeone(&quot;world&quot;);
            expect(fakePerson.sayHello).toHaveBeenCalled();
        });
    });


using Jasmines spyon upon a private method

`gcc` and `ld` provide many ways to specify a search path for libraries—among them the `-rpath` and `-L` flags. The manpages reveal no differences between these two flags, effectively saying each flag adds a library to the library search path. Yet it seems strange that both flags do *exactly* the same thing. What are the differences, if any, between these two options?

What&#39;s the difference between -rpath and -L?

<p><code>gcc</code> and <code>ld</code> provide many ways to specify a search path for libraries—among them the <code>-rpath</code> and <code>-L</code> flags. The manpages reveal no differences between these two flags, effectively saying each flag adds a library to the library search path. Yet it seems strange that both flags do <em>exactly</em> the same thing. What are the differences, if any, between these two options?</p>


In C, the compiler will lay out members of a struct in the order in which they&#39;re declared, with possible padding bytes inserted between members, or after the last member, to ensure that each member is aligned properly.

gcc provides a language extension, `__attribute__((packed))`, which tells the compiler not to insert padding, allowing struct members to be misaligned.  For example, if the system normally requires all `int` objects to have 4-byte alignment, `__attribute__((packed))` can cause `int` struct members to be allocated at odd offsets.

Quoting the gcc documentation:

&gt; The \`packed&#39; attribute specifies that a variable or structure field
&gt; should have the smallest possible alignment--one byte for a  variable,
&gt; and one bit for a field, unless you specify a larger value with the
&gt; \`aligned&#39; attribute.

Obviously the use of this extension can result in smaller data requirements but slower code, as the compiler must (on some platforms) generate code to access a misaligned member a byte at a time.

But are there any cases where this is unsafe?  Does the compiler always generate correct (though slower) code to access misaligned members of packed structs?  Is it even possible for it to do so in all cases?

Is gcc&#39;s __attribute__((packed)) / #pragma pack unsafe?

In a C program if we want to give some input from terminal then we can give it by:

    int main(int argc, char *argv[])

In the same way, if we want to get return value of `main()` function then how can we get it?

In each `main()` we write `return 1` or `return 0`; how can I know what my `main()` has returned at terminal?


**Edit:1**

I get it that by `echo $?` we can get the return value of `main()` but it only allows me to return a value less then 125 (in Linux) successfully. A return value more than that cannot be be successfully received by the `$ variable` so 

**why is `int` the return type of `main()`? Why not keep it `short int`?**

**Edit2**

From where can I find out the meaning of the error code if `main()` returns a value greater than 125?

How can I get what my main function has returned?

I&#39;m trying to make a simple fibonacci calculator in C but when compiling `gcc` tells me that I&#39;m missing the pow and floor functions. What&#39;s wrong?

Code:

    #include &lt;stdio.h&gt;
    #include &lt;math.h&gt;
    
    int fibo(int n);
    
    int main() {
            printf(&quot;Fib(4) = %d&quot;, fibo(4));
            return 0;
    }
    
    int fibo(int n) {
            double phi = 1.61803399;
    
            return (int)(floor((float)(pow(phi, n) / sqrt(5)) + .5f));
    }

Output:

    gab@testvm:~/work/c/fibo$ gcc fib.c -o fibo
    /tmp/ccNSjm4q.o: In function `fibo&#39;:
    fib.c:(.text+0x4a): undefined reference to `pow&#39;
    fib.c:(.text+0x68): undefined reference to `floor&#39;
    collect2: ld returned 1 exit status



Undefined reference to `pow&#39; and `floor&#39;

&gt; **Possible Duplicate:**  
&gt; [How to implement getch() function of C in Linux?](https://stackoverflow.com/questions/3276546/how-to-implement-getch-function-of-c-in-linux)  

&lt;!-- End of automatically inserted text --&gt;

What is the equivalent `Linux` version of the `conio.h` header file from MS-DOS?

Is there a way to replace its functionality? *e.g. `getch()`*

&gt; I&#39;m using `gcc` and the text editor `Geany` to compile `C` code.



Where is the &lt;conio.h&gt; header file on Linux? Why can&#39;t I find &lt;conio.h&gt;?

There is a laptop on which I have no root privilege. 

onto the machine I have a library installed using `configure --prefix=$HOME/.usr` .

after that, I got these files in `~/.usr/lib` :

    libXX.so.16.0.0
    libXX.so.16
    libXX.so
    libXX.la
    libXX.a

when I compile a program that invokes one of function provided by the library with this command :
`gcc XXX.c -o xxx.out -L$HOME/.usr/lib -lXX`

xxx.out was generated without warning, but when I run it error like this was thrown:

`./xxx.out: error while loading shared libraries: libXX.so.16: cannot open shared object file: No such file or directory` , though `libXX.so.16` resides there.

my clue-less assumption is that `~/.usr/lib` wasn&#39;t searched when xxx.out is invoked.
but what can I do to specify path of .so , in order that xxx.out can look there for .so file?




An addition is when I feed `-static` to gcc, another error happens like this:

    undefined reference to `function_proviced_by_the_very_librar&#39;

It seems `.so` does not matter even though `-L` and `-l` are given to gcc.
what should I do to build a usable exe with that library?

------------------
### For other people who has the same question as I did

I found [a useful article at tldp](http://tldp.org/HOWTO/Program-Library-HOWTO/index.html) about this.

It introduces static/shared/dynamic loaded library, as well as some example code to use them.

How to specify non-default shared-library path in GCC Linux? Getting &quot;error while loading shared libraries&quot; when running

 I have been involved in some debate with respect to libraries in Linux, and would like to confirm some things.

It is to my understanding (please correct me if I am wrong and I will edit my post later), that there are two ways of using libraries when building an application:

 1. Static libraries (.a files): At link time, a copy of the entire library is put into the final application so that the functions within the library are always available to the calling application
 2. Shared objects (.so files): At link time, the object is just verified against its API via the corresponding header (.h) file. The library isn&#39;t actually used until runtime, where it is needed.

The obvious advantage of static libraries is that they allow the entire application to be self-contained, while the benefit of dynamic libraries is that the &quot;.so&quot; file can be replaced (ie: in case it needs to be updated due to a security bug) without requiring the base application to be recompiled.

I have heard some people make a distinction between shared objects and dynamic link libraries (DLL&#39;s), even though they are both &quot;.so&quot; files. Is there any distinction between shared objects and DLLs when it comes to C/C++ development on Linux or any other POSIX compliant OS (ie: MINIX, UNIX, QNX, etc)? I am told that one key difference (so far) is that shared objects are just used at runtime, while DLL&#39;s must be opened first using the dlopen() call within the application.

Finally, I have also heard some developers mention &quot;shared archives&quot;, which, to my understanding, are also static libraries themselves, but are never used by an application directly. Instead, other static libraries will link against the &quot;shared archives&quot; to pull some (but not all) functions/resources from the shared archive into the static library being built.

Thank you all in advance for your assistance.

# Update

----------

**In the context in which these terms were provided to me, it was effectively erroneous terms used by a team of Windows developers that had to learn Linux. I tried to correct them, but the (incorrect) language norms stuck.**

1. Shared Object: A library that is automatically linked into a program when the program starts, and exists as a standalone file. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylib` for a library file named `mylib.so`). **The library must be present at compile time, and when the application starts.**
2. Static Library: A library that is merged into the actual program itself at build time for a single (larger) application containing the application code and the library code that is automatically linked into a program when the program is built, and the final binary containing both the main program and the library itself exists as a single standalone binary file. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylib` for a library file named `mylib.a`). **The library must be present at compile time.**
3. DLL: Essentially the same as a shared object, but rather than being included in the linking list at compile time, the library is loaded via `dlopen()`/`dlsym()` commands so that the library does not need to be present at build time for the program to compile. **Also, the library does not need to be present (necessarily) at application startup or compile time**, as it is only needed at the moment the `dlopen`/`dlsym` calls are made.
4. Shared Archive: Essentially the same as a static library, but is compiled with the &quot;export-shared&quot; and &quot;`-fPIC`&quot; flags. The library is included in the linking list at compile time (ie: `LDOPTS+=-lmylibS` for a library file named `mylibS.a`). The distinction between the two is that this additional flag is required if a shared object or DLL wants to statically link the shared archive into its own code AND be able to make the functions in the shared object available to other programs, rather than just using them internal to the DLL. This is useful in the case when someone provides you with a static library, and you wish to repackage it as an SO. **The library must be present at compile time.**

# Additional Update

The distinction between &quot;`DLL`&quot; and &quot;`shared library`&quot; was just a (lazy, inaccurate) colloquialism in the company I worked in at the time (Windows developers being forced to shift to Linux development, and the term stuck), adhering to the descriptions noted above.

Additionally, the trailing &quot;`S`&quot; literal after the library name, in the case of &quot;shared archives&quot; was just a convention used at that company, and not in the industry in general.


Difference between shared objects (.so), static libraries (.a), and DLL&#39;s (.so)?

The [LD manual](http://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_mono/ld.html#SEC2) does not explain what the `KEEP` command does. Below is a snippet from a third-party linker script that features `KEEP`. What does the `KEEP` command do in `ld`?

    SECTIONS
    {  
        .text :
        {
            . = ALIGN(4);
            _text = .;
            PROVIDE(stext = .);
            KEEP(*(.isr_vector))
            KEEP(*(.init))
            *(.text .text.*)        
            *(.rodata .rodata.*)        
            *(.gnu.linkonce.t.*)
            *(.glue_7)
            *(.glue_7t)
            *(.gcc_except_table)
            *(.gnu.linkonce.r.*)
            . = ALIGN(4);
            _etext = .;
    		_sidata = _etext;
            PROVIDE(etext = .);   
         		_fini = . ;
    				*(.fini)
    
        } &gt;flash

What does KEEP mean in a linker script?

What is the way to print the search paths that in looked by **ld** in the order it searches.

How to print the ld(linker) search path

I&#39;m very new to C and I have this code: 

    #include &lt;stdio.h&gt;
    #include &lt;math.h&gt;
    int main(void)
    {
      double x = 0.5;
      double result = sqrt(x);
      printf(&quot;The square root of %lf is %lf\n&quot;, x, result);
      return 0;
    }

But when I compile this with:

    gcc test.c -o test

I get an error like this:

    /tmp/cc58XvyX.o: In function `main&#39;:
    test.c:(.text+0x2f): undefined reference to `sqrt&#39;
    collect2: ld returned 1 exit status


Why does this happen? Is `sqrt()` not in the `math.h` header file? I get the same error with `cosh` and other trigonometric functions. Why?


Why am I getting &quot;undefined reference to sqrt&quot; error even though I include math.h header?

When loading shared libraries in Windows, `LoadLibrary()` call causes `DllMain` in library to execute for each new process and thread library attaches to, and for each process and thread library deattaches from.

Is there similar mechanism for Mac OS X, Linux and possibly other POSIX-compatible OSs?

Automatically executed functions when loading shared libraries

I&#39;m currently trying to port a C application to [AIX][1] and am getting confused. What are .a and .so files and how are they used when building/running an application?

  [1]: https://en.wikipedia.org/wiki/IBM_AIX


What are .a and .so files?

When developing for native platform, I can use ldd to list all the shared libraries (.so files) a binary executable I build will try to load upon start-up. But when cross-compiling, I don&#39;t know how to get the same information. The `ldd` is not a normal binutils utility, like `strip` or `ar`, that can be built alongside `gcc` for cross compiling, but instead, it is a cryptic shell script that apparently can only run on native platform.

So, using the cross-target binutils tools, is there any way to get a list of the dynamically linked dependency for of a foreign binary?

How to list library dependencies of a non-native binary?

I found the following command: `strings /usr/lib/libstdc++.so.6 | grep GLIBC` from [here][1]. It seems to work but this is an ad-hoc/heuristic method.

Is there a specific command that can be used to query the library version of C++? Or is the method I found the accepted method?


  [1]: https://stackoverflow.com/questions/5216399/usr-lib-libstdc-so-6-version-glibcxx-3-4-15-not-found

How do you find what version of libstdc++ library is installed on your linux machine?

I am trying to compile a program which uses [udis86][1] library. Actually I am using an example program given in the [user-manual][2] of the library. But while compiling, it gives error. The errors I get are: 

    example.c:(.text+0x7): undefined reference to &#39;ud_init&#39;
    example.c:(.text+0x7): undefined reference to &#39;ud_set_input_file&#39;
    .
    .
    example.c:(.text+0x7): undefined reference to &#39;ud_insn_asm&#39;


The command I am using is:

    $ gcc -ludis86 example.c -o example 
as instructed in the user-manual.

Clearly, linker is not able to link libudis library. But if I change my command to:

    $ gcc example.c -ludis86 -o example 
It starts working. So can please someone explain what is the problem with the first command? 

  [1]: http://udis86.sourceforge.net/
  [2]: http://udis86.sourceforge.net/manual/manual.html#id486176

Why does the order of &#39;-l&#39; option in gcc matter?

I know an `.so` file is a kind of dynamic library (lots of threads can share such libraries so there is no need to have more than one copy of it in memory). But what is the difference between `.a` and `.la`? Are these all static libraries?

If dynamic libs have big advantages over static ones, why there are still lots of static libraries? When should I try to build code into `.so` or `.a`?

    [mirror@home ins_openvpn]$ ls lib/openvpn/plugins/ -l
    total 96
    -rw-r--r-- 1 mirror mirror 22892 Sep  2 23:25 openvpn-plugin-auth-pam.a
    -rwxr-xr-x 1 mirror mirror   931 Sep  2 23:25 openvpn-plugin-auth-pam.la
    -rwxr-xr-x 1 mirror mirror 23621 Sep  2 23:25 openvpn-plugin-auth-pam.so
    -rw-r--r-- 1 mirror mirror 17228 Sep  2 23:25 openvpn-plugin-down-root.a
    -rwxr-xr-x 1 mirror mirror   932 Sep  2 23:25 openvpn-plugin-down-root.la
    -rwxr-xr-x 1 mirror mirror 18805 Sep  2 23:25 openvpn-plugin-down-root.so

What&#39;s the difference between .so, .la and .a library files?

I&#39;m trying to create a simple kernel using Ubuntu. In the terminal I typed 

    ld -Ttext 0x1000 -o kernel.bin loader.o main.o Video.o

But I got the following error message in return:

    ld: i386 architecture of input file `loader.o&#39; is incompatible with i386:x86-64 output
    ld: warning: cannot find entry symbol _start; defaulting to 0000000000001000



Content Type	Original Author	Original Content on Stackoverflow
Question	Craig M. Brandenburg	View Question on Stackoverflow
Solution 1 - Gcc	derobert	View Answer on Stackoverflow

What's the difference between -rpath and -L?

Gcc Problem Overview

Gcc Solutions

Solution 1 - Gcc

using Jasmines spyon upon a private method

How to count the number of lines of a string in javascript

Attributions