`.a` files are [static][1] libraries typically generated by the [archive tool][2].  You usually include the header files associated with that static library and then link to the library when you are compiling.


  [1]: http://en.wikipedia.org/wiki/Library_%28computing%29#Static_libraries
  [2]: http://linux.about.com/library/cmd/blcmdl1_ar.htm

`.a` files are created with the `ar` utility, and they are libraries. To use it with `gcc`, collect all `.a files` in a `lib/` folder and then link with `-L lib/` and `-l&lt;name of specific library&gt;`.

Collection of all .a files into `lib/` is optional. Doing so makes for better looking directories with nice separation of code and libraries, IMHO.


Is it possible to create user-defined exceptions and be able to change the SQLERRM?

For example:


    DECLARE
        ex_custom       EXCEPTION;
    BEGIN
        RAISE ex_custom;
    EXCEPTION
        WHEN ex_custom THEN
            DBMS_OUTPUT.PUT_LINE(SQLERRM);
    END;
    /


The output is &quot;User-Defined Exception&quot;.  Is it possible to change that message?



EDIT:  Here is some more detail.

I hope this one illustrates what I&#39;m trying to do better.

    DECLARE
        l_table_status      VARCHAR2(8);
        l_index_status      VARCHAR2(8);
        l_table_name        VARCHAR2(30) := &#39;TEST&#39;;
        l_index_name        VARCHAR2(30) := &#39;IDX_TEST&#39;;
        ex_no_metadata      EXCEPTION;
    BEGIN
        
        BEGIN
            SELECT  STATUS
            INTO    l_table_status
            FROM    USER_TABLES
            WHERE   TABLE_NAME      = l_table_name;
        EXCEPTION
            WHEN NO_DATA_FOUND THEN
                -- raise exception here with message saying
                -- &quot;Table metadata does not exist.&quot;
                RAISE ex_no_metadata;
        END;
        
        BEGIN
            SELECT  STATUS
            INTO    l_index_status
            FROM    USER_INDEXES
            WHERE   INDEX_NAME      = l_index_name;
        EXCEPTION
            WHEN NO_DATA_FOUND THEN
                -- raise exception here with message saying
                -- &quot;Index metadata does not exist.&quot;
                RAISE ex_no_metadata;
        END;
        
    EXCEPTION
        WHEN ex_no_metadata THEN
            DBMS_OUTPUT.PUT_LINE(&#39;Exception will be handled by handle_no_metadata_exception(SQLERRM) procedure here.&#39;);
            DBMS_OUTPUT.PUT_LINE(SQLERRM);
    END;
    /



In reality, there are dozens of those sub-blocks.  I&#39;m wondering if there&#39;s a way to have a single user-defined exception for each of those sub-blocks to raise, but have it give a different message, instead of creating a separate user-defined exception for each sub-block.

In .NET, it would be sort of like having a custom exception like this:

        public class ColorException : Exception
        {
            public ColorException(string message)
                : base(message)
            {
            }
        }

And then, a method would have something like this:

            if (isRed)
            {
                throw new ColorException(&quot;Red is not allowed!&quot;);
            }

            if (isBlack)
            {
                throw new ColorException(&quot;Black is not allowed!&quot;);
            }

            if (isBlue)
            {
                throw new ColorException(&quot;Blue is not allowed!&quot;);
            }

Oracle PL/SQL - Raise User-Defined Exception With Custom SQLERRM

I want an iframe to initially have `src` as blank and then once the page loads; call a JS function and then set the `src` value to an actual one..

So is `&lt;iframe src=&quot;#&quot; /&gt;` valid OR do I need to use something else like `javascript:;`, etc

Is an empty iframe src valid?

I downloaded this: https://github.com/mongodb/mongo-c-driver

And now I&#39;m trying to use it inside my C program, but I don&#39;t know what to do with the generated .a files. What are they? I couldn&#39;t find any information, not even in the GCC manual. 

And I built it like so: 

      scons --c99

Also, can I use [C99][1] libraries with my C89 program? 

  [1]: https://en.wikipedia.org/wiki/C99


What is a file with extension .a?

I downloaded this: <a href="https://github.com/mongodb/mongo-c-driver" target="_blank" rel="noopener noreferrer">https://github.com/mongodb/mongo-c-driver</a>
And now I'm trying to use it inside my C program, but I don't know what to do with the generated .a files. What are they? I couldn't find any information, not even in the GCC manual.
And I built it like so:
<pre><code class="hljs language-css"> scons --c99
</code></pre>
Also, can I use <a href="https://en.wikipedia.org/wiki/C99" target="_blank" rel="noopener noreferrer">C99</a> libraries with my C89 program?

    void TestPrint(char* format, ...)
    {
        va_list argList;

        va_start(argList, format);
        printf(format, argList);
        va_end(argList);
    }


    int main()
    {
        TestPrint(&quot;Test print %s %d\n&quot;, &quot;string&quot;, 55);
        return 0;
    }

I need to get:

    Test print string 55

Actually, I get garbage output. What is wrong in this code?

call printf using va_list

In the file `file1.c`, there is a call to a function that is implemented in the file `file2.c`.
When I link `file1.o` and `file2.o` into an executable, if the function in `file2` is very small, will the linker automatically detect that the function is small and inline its call?



Can the linker inline functions?

I often see source code using types like uint32, uint64 and I wonder if they should be defined by the programmer in the application code or if they are defined in a standard lib header.

What&#39;s the best way to have these types on my application source code?


Are types like uint32, int32, uint64, int64 defined in any stdlib header?

Any portable code that uses bitfields seems to distinguish between little- and big-endian platforms. See the [declaration of struct iphdr in linux kernel](http://lxr.linux.no/#linux+v2.6.38/include/linux/ip.h) for an example of such code. I fail to understand why bit endianness is an issue at all.

As far as I understand, bitfields are purely compiler constructs, used to facilitate bit level manipulations.

For instance, consider the following bitfield:
&lt;code&gt;&lt;pre&gt;
struct ParsedInt {
    unsigned int f1:1;
    unsigned int f2:3;
    unsigned int f3:4;
};
uint8_t i;
struct ParsedInt *d = &amp;i;
&lt;/pre&gt;&lt;/code&gt;
Here, writing &lt;code&gt;d-&gt;f2&lt;/code&gt; is simply a compact and readable way of saying &lt;code&gt;(i&gt;&gt;1) &amp;  (1&lt;&lt;4 - 1)&lt;/code&gt;.

However, bit operations are well-defined and work regardless of the architecture. So, how come bitfields are not portable?

Why bit endianness is an issue in bitfields?

 - In simple terms what are pts and dts values?
 - Why are they important while transcoding [decode-encode] videos ?

What does this code bit do in [**ffmpeg.c**][1] , what is its purpose?

    01562    ist-&gt;next_pts = ist-&gt;pts = picture.best_effort_timestamp;
    01563    if (ist-&gt;st-&gt;codec-&gt;time_base.num != 0) {
    01564        int ticks= ist-&gt;st-&gt;parser ? ist-&gt;st-&gt;parser-&gt;repeat_pict+1 : ist-&gt;st-&gt;codec-&gt;ticks_per_frame;
    01565        ist-&gt;next_pts += ((int64_t)AV_TIME_BASE *
    01566                         ist-&gt;st-&gt;codec-&gt;time_base.num * ticks) /
    01567                         ist-&gt;st-&gt;codec-&gt;time_base.den;
    01568    }


  [1]: http://cekirdek.pardus.org.tr/~ismail/ffmpeg-docs/ffmpeg_8c-source.html

ffmpeg.c what are pts and dts ? what does this code block do in ffmpeg.c?

I&#39;ve been working on some C++ code that a friend has written and I get the following error that I have never seen before when compiling with gcc4.6:

    error: use of deleted function

    ‘GameFSM_&lt;std::array&lt;C, 2ul&gt; &gt;::hdealt::hdealt()’ is implicitly deleted because the default definition would be ill-formed:
    uninitialized non-static const member ‘const h_t FlopPokerGameFSM_&lt;std::array&lt;C, 2ul&gt; &gt;::hdealt::h’


Edit: This comes from a part of the code using boost MSM: [Boost Webpage][1]

Edit2: There is no `= delete()` used anywhere in the sourcecode.

Generally speaking, what does this error mean? What should I be looking for when this type of error occurs?


  [1]: http://www.boost.org/doc/libs/1_46_1/libs/msm/doc/HTML/index.html

error: use of deleted function

I set the CFLAGS in CMake by CMAKE_C_FLAGS.
Is something like this to set LDFLAGS?

How to set the LDFLAGS in CMakeLists.txt?

I came across a piece of code `void *p = &amp;&amp;abc;`. What is the significance of `&amp;&amp;` here?
I know about rvalue references but I think `&amp;&amp;` used in this context is different. What does `&amp;&amp;` indicate in `void *p = &amp;&amp;abc;` ?

What does &amp;&amp; mean in void *p = &amp;&amp;abc;

I have a huge number of functions totaling around 2.8&amp;nbsp;GB of object code (unfortunately there&#39;s no way around, scientific computing ...)

When I try to link them, I get (expected) `relocation truncated to fit: R_X86_64_32S` errors, that I hoped to circumvent by specifing the compiler flag `-mcmodel=medium`. All libraries that are linked in addition that I have control of are compiled with the `-fpic` flag.

Still, the error persists, and I assume that some libraries I link to are not compiled with PIC.

Here&#39;s the error:

    /usr/lib/gcc/x86_64-redhat-linux/4.1.2/../../../../lib64/crt1.o: In function `_start&#39;:
    (.text+0x12): relocation truncated to fit: R_X86_64_32S against symbol `__libc_csu_fini&#39;     defined in .text section in /usr/lib64/libc_nonshared.a(elf-init.oS)
    /usr/lib/gcc/x86_64-redhat-linux/4.1.2/../../../../lib64/crt1.o: In function `_start&#39;:
    (.text+0x19): relocation truncated to fit: R_X86_64_32S against symbol `__libc_csu_init&#39;    defined in .text section in /usr/lib64/libc_nonshared.a(elf-init.oS)
    /usr/lib/gcc/x86_64-redhat-linux/4.1.2/../../../../lib64/crt1.o: In function `_start&#39;:
    (.text+0x20): undefined reference to `main&#39;
    /usr/lib/gcc/x86_64-redhat-linux/4.1.2/../../../../lib64/crti.o: In function    `call_gmon_start&#39;:
    (.text+0x7): relocation truncated to fit: R_X86_64_GOTPCREL against undefined symbol      `__gmon_start__&#39;
    /usr/lib/gcc/x86_64-redhat-linux/4.1.2/crtbegin.o: In function `__do_global_dtors_aux&#39;:
    crtstuff.c:(.text+0xb): relocation truncated to fit: R_X86_64_PC32 against `.bss&#39; 
    crtstuff.c:(.text+0x13): relocation truncated to fit: R_X86_64_32 against symbol `__DTOR_END__&#39; defined in .dtors section in /usr/lib/gcc/x86_64-redhat-linux/4.1.2/crtend.o
    crtstuff.c:(.text+0x19): relocation truncated to fit: R_X86_64_32S against `.dtors&#39;
    crtstuff.c:(.text+0x28): relocation truncated to fit: R_X86_64_PC32 against `.bss&#39;
    crtstuff.c:(.text+0x38): relocation truncated to fit: R_X86_64_PC32 against `.bss&#39;
    crtstuff.c:(.text+0x3f): relocation truncated to fit: R_X86_64_32S against `.dtors&#39;
    crtstuff.c:(.text+0x46): relocation truncated to fit: R_X86_64_PC32 against `.bss&#39;
    crtstuff.c:(.text+0x51): additional relocation overflows omitted from the output
    collect2: ld returned 1 exit status
    make: *** [testsme] Error 1

And system libraries I link against: 

    -lgfortran -lm -lrt -lpthread

Any clues where to look for the problem?

**EDIT:**

First of all, thank you for the discussion...

To clarify a bit, I have hundreds of functions (each approx 1&amp;nbsp;MB in size in separate object files) like this:

    double func1(std::tr1::unordered_map&lt;int, double&gt; &amp; csc, 
                 std::vector&lt;EvaluationNode::Ptr&gt; &amp; ti, 
                 ProcessVars &amp; s)
    {
        double sum, prefactor, expr;

        prefactor = +s.ds8*s.ds10*ti[0]-&gt;value();
        expr =       ( - 5/243.*(s.x14*s.x15*csc[49300] + 9/10.*s.x14*s.x15*csc[49301] +
               1/10.*s.x14*s.x15*csc[49302] - 3/5.*s.x14*s.x15*csc[49303] -
               27/10.*s.x14*s.x15*csc[49304] + 12/5.*s.x14*s.x15*csc[49305] -
               3/10.*s.x14*s.x15*csc[49306] - 4/5.*s.x14*s.x15*csc[49307] +
               21/10.*s.x14*s.x15*csc[49308] + 1/10.*s.x14*s.x15*csc[49309] -
               s.x14*s.x15*csc[51370] - 9/10.*s.x14*s.x15*csc[51371] -
               1/10.*s.x14*s.x15*csc[51372] + 3/5.*s.x14*s.x15*csc[51373] +
               27/10.*s.x14*s.x15*csc[51374] - 12/5.*s.x14*s.x15*csc[51375] +
               3/10.*s.x14*s.x15*csc[51376] + 4/5.*s.x14*s.x15*csc[51377] -
               21/10.*s.x14*s.x15*csc[51378] - 1/10.*s.x14*s.x15*csc[51379] -
               2*s.x14*s.x15*csc[55100] - 9/5.*s.x14*s.x15*csc[55101] -
               1/5.*s.x14*s.x15*csc[55102] + 6/5.*s.x14*s.x15*csc[55103] +
               27/5.*s.x14*s.x15*csc[55104] - 24/5.*s.x14*s.x15*csc[55105] +
               3/5.*s.x14*s.x15*csc[55106] + 8/5.*s.x14*s.x15*csc[55107] -
               21/5.*s.x14*s.x15*csc[55108] - 1/5.*s.x14*s.x15*csc[55109] -
               2*s.x14*s.x15*csc[55170] - 9/5.*s.x14*s.x15*csc[55171] -
               1/5.*s.x14*s.x15*csc[55172] + 6/5.*s.x14*s.x15*csc[55173] +
               27/5.*s.x14*s.x15*csc[55174] - 24/5.*s.x14*s.x15*csc[55175] +
               // ...
               ;

            sum += prefactor*expr;
        // ...
        return sum;
    }

The object `s` is relatively small and keeps the needed constants x14, x15, ..., ds0, ..., etc. while `ti` just returns a double from an external library. As you can see, `csc[]` is a precomputed map of values which is also evaluated in separate object files (again hundreds with about ~1&amp;nbsp;MB of size each) of the following form:
    
    void cscs132(std::tr1::unordered_map&lt;int,double&gt; &amp; csc, ProcessVars &amp; s)
    {
        {
        double csc19295 =       + s.ds0*s.ds1*s.ds2 * ( -
               32*s.x12pow2*s.x15*s.x34*s.mbpow2*s.mWpowinv2 -
               32*s.x12pow2*s.x15*s.x35*s.mbpow2*s.mWpowinv2 -
               32*s.x12pow2*s.x15*s.x35*s.x45*s.mWpowinv2 -
               32*s.x12pow2*s.x25*s.x34*s.mbpow2*s.mWpowinv2 -
               32*s.x12pow2*s.x25*s.x35*s.mbpow2*s.mWpowinv2 -
               32*s.x12pow2*s.x25*s.x35*s.x45*s.mWpowinv2 +
               32*s.x12pow2*s.x34*s.mbpow4*s.mWpowinv2 +
               32*s.x12pow2*s.x34*s.x35*s.mbpow2*s.mWpowinv2 +
               32*s.x12pow2*s.x34*s.x45*s.mbpow2*s.mWpowinv2 +
               32*s.x12pow2*s.x35*s.mbpow4*s.mWpowinv2 +
               32*s.x12pow2*s.x35pow2*s.mbpow2*s.mWpowinv2 +
               32*s.x12pow2*s.x35pow2*s.x45*s.mWpowinv2 +
               64*s.x12pow2*s.x35*s.x45*s.mbpow2*s.mWpowinv2 +
               32*s.x12pow2*s.x35*s.x45pow2*s.mWpowinv2 -
               64*s.x12*s.p1p3*s.x15*s.mbpow4*s.mWpowinv2 +
               64*s.x12*s.p1p3*s.x15pow2*s.mbpow2*s.mWpowinv2 +
               96*s.x12*s.p1p3*s.x15*s.x25*s.mbpow2*s.mWpowinv2 -
               64*s.x12*s.p1p3*s.x15*s.x35*s.mbpow2*s.mWpowinv2 -
               64*s.x12*s.p1p3*s.x15*s.x45*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.p1p3*s.x25*s.mbpow4*s.mWpowinv2 +
               32*s.x12*s.p1p3*s.x25pow2*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.p1p3*s.x25*s.x35*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.p1p3*s.x25*s.x45*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.p1p3*s.x45*s.mbpow2 +
               64*s.x12*s.x14*s.x15pow2*s.x35*s.mWpowinv2 +
               96*s.x12*s.x14*s.x15*s.x25*s.x35*s.mWpowinv2 +
               32*s.x12*s.x14*s.x15*s.x34*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.x14*s.x15*s.x35*s.mbpow2*s.mWpowinv2 -
               64*s.x12*s.x14*s.x15*s.x35pow2*s.mWpowinv2 -
               32*s.x12*s.x14*s.x15*s.x35*s.x45*s.mWpowinv2 +
               32*s.x12*s.x14*s.x25pow2*s.x35*s.mWpowinv2 +
               32*s.x12*s.x14*s.x25*s.x34*s.mbpow2*s.mWpowinv2 -
               32*s.x12*s.x14*s.x25*s.x35pow2*s.mWpowinv2 -
               // ...
        
           csc.insert(cscMap::value_type(192953, csc19295));
        }

        {
           double csc19296 =      // ... ;

           csc.insert(cscMap::value_type(192956, csc19296));
        }

        // ...
    }

That&#39;s about it. The final step then just consists in calling all those `func[i]` and summing the result up.

Concerning the fact that this is a rather special and unusual case: Yes, it is. This is what people have to cope with when trying to do high precision computations for particle physics.

**EDIT2:**

I should also add that x12, x13, etc. are not really constants. They are set to specific values, all those functions are run and the result returned, and then a new set of x12, x13, etc. is chosen to produce the next value. And this has to be done 10&lt;sup&gt;5&lt;/sup&gt; to 10&lt;sup&gt;6&lt;/sup&gt; times...

**EDIT3:**

Thank you for the suggestions and the discussion so far... I&#39;ll try to roll the loops up upon code generation somehow, not sure how to this exactly, to be honest, but this is the best bet. 

BTW, I didn&#39;t try to hide behind &quot;this is scientific computing -- no way to optimize&quot;.  
It&#39;s just that the basis for this code is something that comes out of a &quot;black box&quot; where I have no real access to and, moreover, the whole thing worked great with simple examples, and I mainly feel overwhelmed with what happens in a real world application... 

**EDIT4:**

So, I have managed to reduce the code size of the `csc` definitions by about one forth by simplifying expressions in a computer algebra system ([Mathematica][1]). I see now also some way to reduce it by another order of magnitude or so by applying some other tricks before generating the code (which would bring this part down to about 100&amp;nbsp;MB) and I hope this idea works.  

Now related to your answers:

I&#39;m trying to roll the loops back up again in the `func`s, where a CAS won&#39;t help much, but I have already some ideas. For instance, sorting the expressions by the variables like `x12, x13,...`, parse the `csc`s with Python and generate tables that relate them to each other. Then I can at least generate these parts as loops. As this seems to be the best solution so far, I mark this as the best answer.

However, I&#39;d like to also give credit to VJo. GCC 4.6 indeed works *much* better, produces smaller code and is faster. Using the large model works at the code as-is. So technically this is the correct answer, but changing the whole concept is a much better approach.

Thank you all for your suggestions and help. If anyone is interested, I&#39;m going to post the final outcome as soon as I am ready.

**REMARKS:**

Just some remarks to some other answers: The code I&#39;m trying to run does not originate in an expansion of simple functions/algorithms and stupid unnecessary unrolling. What actually happens is that the stuff we start with is pretty complicated mathematical objects and bringing them to a numerically *computable* form generates these expressions. The problem lies actually in the underlying physical theory. Complexity of intermediate expressions scales factorially, which is well known, but when combining all of this stuff to something physically measurable -- an observable -- it just boils down to only a handful of very small functions that form the basis of the expressions. (There is definitely something &quot;wrong&quot; in this respect with the general and *only* available [ansatz][2] which is called &quot;perturbation theory&quot;) We try to bring this ansatz to another level, which is not feasible analytically anymore and where the basis of needed functions is not known. So we try to brute-force it like this. Not the best way, but hopefully one that helps with our understanding of the physics at hand in the end...

**LAST EDIT:**

Thanks to all your suggestions, I&#39;ve managed to reduce the code size considerably, using Mathematica and a modification of the code generator for the `func`s somewhat along the lines of the top answer :)

I have simplified the `csc` functions with Mathematica, bringing it down to 92&amp;nbsp;MB. This is the irreducible part. The first attempts took forever, but after some optimizations this now runs through in about 10&amp;nbsp;minutes on a single CPU.

The effect on the `func`s was dramatic: The whole code size for them is down to approximately 9&amp;nbsp;MB, so the code now totals in the 100&amp;nbsp;MB range. Now it makes sense to turn optimizations on and the execution is quite fast.

Again, thank you all for your suggestions, I&#39;ve learned a lot.

  [1]: http://en.wikipedia.org/wiki/Mathematica
  [2]: http://en.wiktionary.org/wiki/ansatz#Noun


How to fix GCC compilation error when compiling &gt;2 GB of code?

I have a virtual Debian system which I use to develop.

Today I wanted to try llvm/clang.

After installing clang I can&#39;t compile my old c-projects (with gcc).
This is the error:

    ...
    /usr/bin/ld: cannot find crt1.o: No such file or directory
    /usr/bin/ld: cannot find crti.o: No such file or directory
    collect2: ld returned 1 exit status
    ...

I uninstalled clang and it still did not work.

Does anyone have any idea how I can fix this?

Compiling problems: cannot find crt1.o

I am trying to create a static object written in Go to interface with a C program (say, a kernel module or something).

I have found documentation on calling C functions from Go, but I haven&#39;t found much on how to go the other way.  What I&#39;ve found is that it&#39;s possible, but complicated.

Here is what I found:

[Blog post about callbacks between C and Go](http://cheesesun.blogspot.com/2010/04/callbacks-in-cgo.html)

[Cgo documentation](http://golang.org/cmd/cgo/)

[Golang mailing list post](http://groups.google.com/group/golang-nuts/browse_thread/thread/4de85861de6ef204/f7d610e08b86d437?lnk=gst&amp;q=cgo+dynamic+linking+D#f7d610e08b86d437)

Does anyone have experience with this? In short, I&#39;m trying to create a PAM module written entirely in Go.

Call Go functions from C

I&#39;m trying to understand this LIB file business on Microsoft Windows, and I&#39;ve just made a discovery that will - I hope - dispel the confusion that hitherto has prevented me from getting a clear grasp of the issue. To wit, LIB files are not the one kind of file that their file extension suggests they are.

    :: cd &quot;C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Lib&quot;
    
    :: lib /nologo /list Ad1.Lib
    obj\i386\activdbgid.obj
    obj\i386\activscpid.obj
    obj\i386\ad1exid.obj
    obj\i386\dbgpropid.obj
    obj\i386\dispexid.obj
    
    :: lib /nologo /list oledb.lib
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbnewiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\cmdtreeiid.obj
    o:\winmain.obj.x86fre\enduser\…\oledb\uuid\objfre\i386\oledbdepiid.obj
    
    :: lib /nologo /list AdvAPI32.Lib | sort | uniq -c
        731 ADVAPI32.dll

The first two examples contain object files (appearing as relative or absolute paths when displayed by the `lib.exe` utility). The third example, however, only contains 731 references to a DLL. (I guess `lib.exe` isn&#39;t designed to display more useful information for this kind of file.)

Some contain object files, and they are static libraries. Others contain symbols, and they are import libraries. (There&#39;s a [short explanation here](https://stackoverflow.com/questions/2240737/2240777#2240777).)

So static libraries appear to be the equivalents of `.a` files on Linux, and DLLs appear to map to `.so` files on Linux. (By the way, how would import libraries fit into this Windows/Linux equivalence picture?)

Now I&#39;m wondering why this is so? Why did Microsoft decide to give import libraries the same file extension as static libraries? (I understand that historically, static libraries were first, like primitive forms of life preceded more complex forms.) Why wouldn&#39;t they say, okay, here&#39;s these new kind of libraries, they shall be referred to as import libraries, and they shall bear the file extension `.ILB` (or whatever)?

Why are LIB files beasts of such a duplicitous nature?

When I disassemble my small function, I happened to see this call

    call   0xf60d2f47 &lt;__i686.get_pc_thunk.bx&gt;.

I have no clue why I need this call in my program. Any explanation would be helpful. 

What is __i686.get_pc_thunk.bx? Why do we need this call?

I have a folder for my client code, a folder for my server code, and a folder for code that is shared between them

    Proj/
        Client/
            Client.py
        Server/
            Server.py
        Common/
            __init__.py
            Common.py

How do I import Common.py from Server.py and Client.py?

Importing from a relative path in Python

`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?

Content Type	Original Author	Original Content on Stackoverflow
Question	Blub	View Question on Stackoverflow
Solution 1 - C	GWW	View Answer on Stackoverflow
Solution 2 - C	Sriram	View Answer on Stackoverflow

What is a file with extension .a?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Is an empty iframe src valid?

Oracle PL/SQL - Raise User-Defined Exception With Custom SQLERRM

Attributions