Question: So I've been using Chris's article <https://css-tricks.com/multi-line-padded-text/> to help me get some centred text with a background. The only problem is I want the background to be semi transparent and I can't think of a way of doing it. I've played with line height and padding but can't come up with a solution. 

What I want to do is stop the backgrounds of each line overlapping but ensure that the space between each line is the same.

```
  <div class="ui-section__component">
   <div class="comp--hero-text">
    <h2>You're all clear, kid. Let's blow this thing and go home! You're all clear, kid. Let's blow this thing and go home!</h2>
   </div>
  </div>

$white: #fff;
$max-width: 1024px;
$small-spacing: 0.75em;

.ui-section__component{
  background-color: green; 
  display: flex; 
  height: 500px;
  width: 700px;
}

.comp--hero-text {
  align-self: center;
  margin: 0 auto;
  max-width: $max-width - 200px;
  text-align: center;
  width: 80%;

  h2 {
    background-color: rgba($white, 0.85);
    box-decoration-break: clone;
    box-shadow: $small-spacing / 2 0 0 rgba($white, 0.85), -$small-spacing / 2 0 0 rgba($white, 0.85);
    display: inline;
    line-height: 1.5;
    padding: 0.5em 0;
  }
}

```

My code can be found on Code Pen: <http://codepen.io/rmaspero/pen/VmVwNx>

Answer: 
This is not a *desired* behaviour, though not *explicitly* mentioned as undefined behaviour. This is a "Constraints violation".

Quoting `C11`, chapter 6.8.6.4

> 
> [...] A `return` statement without an expression shall only appear in a function
>  whose return type is `void`.
> 
> 
> 

and, from chapter §5.1.1.3, *Diagnostics*,

> 
> A conforming implementation shall produce at least one diagnostic message (identified in
>  an implementation-defined manner) if a preprocessing translation unit or translation unit
>  contains a violation of any syntax rule or constraint, even if the behavior is also explicitly
>  specified as undefined or implementation-defined. [....]
> 
> 
> 

In this case, compiler proceeds to generate the executable code, so, yes, executing this binary invokes [undefined behavior](https://en.wikipedia.org/wiki/Undefined_behavior).

Bottom line, for `main()` which is expected to return an `int` should not have a `return` statement without an expression. Refrain from writing code like that.

---

*[Note: [As per this discussion](https://groups.google.com/forum/#!topic/comp.std.c/WNVXRSCqrGU), there's a strong notion that this is undefined behaviour, but still, there's no **explicit** mention in the standard.]*
The program as shown is not legal C. The use of `return;` in a non-void function like that is a *constraint violation*, and your compiler is required to complain. Usually, that will be an error, but a compiler is allowed to produce a program - but the standard obviously does not make any requirements on the behaviour of such a program. Therefore its behaviour is not defined (technically, this is slightly different from Undefined Behaviour, as it's not something explicitly specified as "*undefined*" in the standard).

There's no point asking questions like, "*What happens when I cause Undefined Behaviour?*" because the answer is always, "*Anything*."

As an aside, you are allowed to **omit** a return statement (i.e. to run off the end of the function) *as long as your program does not use the return value*. If the program uses the return value, then the behaviour is Undefined (not merely unspecified). In particular, running off the end of `main()` is legal. Although there's no rationale for allowing functions with no `return` but not those with an explicit void `return`, I presume it's due to the logical undecidability of whether a function's end is reachable (it's a case of the Halting Problem).

Of particular interest in this case is that the function in question is `main()`. Options available to the compiler (in addition to emitting the required diagnostic) include (but are not limited to):

* Terminate compilation
* Optimise out `return;` as the last statement in a function, and treat it the same as `main()` with no return statement
* Return an uninitialized value (which might be a signalling value on architectures that support them, or it might be a recently-used stack value, or something else altogether)