nsz | NSZ - Homebrew compatible NSP/XCI compressor/decompressor | Compression library

This is covered in section 6.9/5 of the latest C Standard:

Semantics

An external definition is an external declaration that is also a definition of a function (other than an inline definition) or an object. If an identifier declared with external linkage is used in an expression (other than as part of the operand of a sizeof or _Alignof operator whose result is an integer constant), somewhere in the entire program there shall be exactly one external definition for the identifier; otherwise, there shall be no more than one.

The term "external definition" should not be confused with "external linkage" or the extern keyword, those are are entirely different concepts that happen to have similar spelling.

"external definition" means a definition that is not tentative, and not inside a function.

Regarding tentative definition, ths is covered by 6.9.2/2:

A declaration of an identifier for an object that has file scope without an initializer, and without a storage-class specifier or with the storage-class specifier static , constitutes a tentative definition. If a translation unit contains one or more tentative definitions for an identifier, and the translation unit contains no external definition for that identifier, then the behavior is exactly as if the translation unit contains a file scope declaration of that identifier, with the composite type as of the end of the translation unit, with an initializer equal to 0.

So in your file 1.c, as per 6.9.2/2 the behaviour is exactly as if it had said int i = 0; instead. Which would be an external definition. This means 0.c and 1.c both behave as if they had external definitions which violates the rule 6.9/5 saying there shall be no more than one external definition.

Violating a semantic rule means the behaviour is undefined with no diagnostic required.

See also: Undefined, unspecified and implementation-defined behavior

In case it is unclear, the C Standard saying "the behaviour is undefined" means that the C Standard does not define the behaviour. The same code built on different conforming implementations (or rebuilt on the same conforming implementation) may behave differently, including rejecting the program , accepting it, or any other outcome you might imagine.

(Note - some programs can have the defined-ness of their behaviour depend on runtime conditions; those programs cannot be rejected at compile-time and must behave as specified unless the condition occurs that causes the behaviour to be undefined. But that does not apply to the program in this question since all possible executions would encounter the violation of 6.9/5).

Compiler vendors may or may not provide stable and/or documented behaviour for cases where the C Standard does not define the behaviour.

For the code in your question it is common (ha ha) for compiler vendors to provide reliable behaviour ; this is documented in a non-normative Annex J.5.11 to the Standard:

J.5 Common extensions

J.5.11 Multiple external definitions 1 There may be more than one external definition for the identifier of an object, with or without the explicit use of the keyword extern ; if the definitions disagree, or more than one is initialized, the behavior is undefined (6.9.2).

It seems the gcc compiler implements this extension if -fcommon switch is provided, and disables it if -fno-common is provided (and the default setting may vary between compiler versions).

Footnote: I intentionally avoid using the word "defined" in relation to behaviour that is not defined by the C Standard as it seems to me that is one of the cause of confusion for OP.

There shouldn't be any text after the included file.

Section 6.10.2 of the C standard regarding #include states:

2 A preprocessing directive of the form

To find out what is wrong with help of gdb you usually need to run program in step mode to see where and why it hangs or loops.

1. Ensure that you compiled your program with debug symbols (if you are using gcc or similar compiler then -g option is needed).
2. To avoid going over whole program in step mode you can just hit Ctrl-C in gdb at the time you think your program hanged and then enter command bt. It will show you where your program is. You can then enter command cont, and break program execution after some time to see if you are in different place, or in the same...
3. If you still don't know what is the reason of your problem after step 2, you can kill program and set up break point before the place you have identified as being the one in which your program hangs/loops --- read gdb documentation about break to see how to set up breakpoint.

Here is link for gdb tutorial hosted at CMU: https://www.cs.cmu.edu/~gilpin/tutorial/

As @kaylum said above. You should use the a debuggger when you see the Segmentation Fault. For me, i always try to run the program with valgrind when i see this fault. With valgrind (Use -g when you compile the code, firstly) you can see where is memory fault.

For your program, it figures out this line *n = nsz;. So look at the variable n and nsz.

Btw, you have to allocate for 2 varibale n and stv instead of assigning them to 0.