Question: I tried to open pentaho spoon but it doesnt launch . The error is "System does not find the path"
I use "-Xms1024m" and C:\Program Files\Java\jre1.8.0\_261 path as an environment but still does not working. Can someone help me please?

[![enter image description here](https://i.stack.imgur.com/8hE1X.png)](https://i.stack.imgur.com/8hE1X.png)

Answer: 
> 
> "*I know the standard talks about temporary lifetime for structs that contain arrays, but in this case there is no array in the structure.*"
> 
> 
> 

You mean this paragraph:

> 
> A non-lvalue expression with structure or union type, where the structure or union contains a member with array type (including, recursively, members of all contained structures and unions) refers to an object with automatic storage duration and *temporary lifetime*.36) Its lifetime begins when the expression is evaluated and its initial value is the value of the expression. Its lifetime ends when the evaluation of the containing full expression ends. Any attempt to modify an object with temporary lifetime results in undefined behavior. An object with temporary lifetime behaves as if it were declared with the type of its value for the purposes of effective type. Such an object need not have a unique address.
> 
> 
>  36) The address of such an object is taken implicitly when an array member is accessed. 
> 
> 
> Source: ISO/IEC 9899:2018 (C18), §6.2.4/8
> 
> 
> 

The *temporary lifetime* was explicitly invented in the context of structures and unions which contain array members because since [array to pointer decay](https://stackoverflow.com/q/1461432/12139179), accessing an array member by its name would give you a pointer to the first element of the array, which invoked undefined behavior in earlier C standard before this paragraph was added in C11.

Chris Dodd explained it a little better [here](https://stackoverflow.com/a/55888080/12139179).

So *tempory lifetime* (as meant in the standard) isn't relevant for structures with non-array members.

> 
> "*So I guess that as soon as `foo()` has ended, its return value should be dead, right?*"
> 
> 
> 

No. `foo()` returns a copy of an object of `struct S` and not a reference to a local `struct S` object. Note that the return type of `foo()` is `struct S`, not `struct S *` (a pointer to `struct S`).

> 
> "*But apparently we can still access the `x` member. Why?*"
> 
> 
> 

Because you return a copy to the caller. You attempt to access the member `x` of this copy and not the `struct S` object `s` inside of `foo()`.
From the C Standard

> 
> 4 **A full expression is** an expression that is not part of another
> expression or of a declarator. Each of the following is a full
> expression: an initializer that is not part of a compound literal;
> **the expression in an expression statement**; the controlling expression of a selection statement (if or switch); the controlling
> expression of a while or do statement; each of the (optional)
> expressions of a for statement; the (optional) expression in a return
> statement. There is a sequence point between the evaluation of a full
> expression and the evaluation of the next full expression to be
> evaluated.
> 
> 
> 

The lifetime of a temporary object ends when the evaluation of the containing full expression ends.

So within this expression statement

```
a = foo(2, 4).x;

```

the returned object of the structure type is alive and the value of its data member `x` is assigned to the variable `a` that is declared in main and has the block scope of main.