Hi Konstantin

nice puzzle!

I think you are confused about how stack variables (value vs. reference) work.

hth

Arnd

Hi.

It looks ok, and of course little confusing.

f_show_string( ls_str, f_set_string( 1, ls_str))

                  ^                        ^
                  |                        |
                copy                      ref

1st call f_show_string copies ls_str. f_set_string is executed later.

2nd call, f_show_string gets ls_str modified. It then calls f_set_string.

I guess your question is if f_set_string should be evaluated before copying ls_string to f_show_string. In my opinion no. What PB does seems to be the right thing. Function f_show_string is called before f_set_string. The copy of ls_string should happen before f_set_string alters it.

In first call of f_set_string ls_str is correctly IMHO passed as "". In second call it is again correctly passed as "one"...

Anyway, those are the dangers of working with pointers... In these case statements may not be very obvious about what they do...

Also, I tested that in c# .net:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            string ls_str = "";
            
            f_show_string(ls_str, f_set_string(1, ref ls_str));
            f_show_string(ls_str, f_set_string(2, ref ls_str));

            Console.ReadKey();
        }
        static public int f_set_string(int ai_in, ref string as_out)
        {
            if (ai_in == 1)
                as_out = "one";
            else
                as_out = "two";

            return ai_in;
        }

        static public void f_show_string(string as_string, int ai_int)
        {
            Console.WriteLine("Result: " + as_string + " - " + ai_int.ToString());
        }
    }
}

Here is the result:

Result:  - 1
Result: one - 2

Andreas.

I took it a step further and extended f_show_string with the third argument:

global subroutine f_show_string (string as_string, integer ai_int, string as_string_again);
messageBox( 'Result', as_string + ' - ' + string(ai_int) + ' - ' + as_string_again )

end subroutine

So, the calling script changed to:

string ls_str

f_show_string( ls_str, f_set_string( 1, ls_str), ls_str)
f_show_string( ls_str, f_set_string( 2, ls_str), ls_str)

The result:

K

To @Arnd Schmidt:

Left to right stuff...
This is how the PBVM adds values to the stack.

How about C# :-) ?

Modified C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            string ls_str = "";

            f_show_string(ls_str, f_set_string(1, ref ls_str), ls_str);
            f_show_string(ls_str, f_set_string(2, ref ls_str), ls_str);
            Console.ReadKey();
        }
        static public int f_set_string(int ai_in, ref string as_out)
        {
            if (ai_in == 1)
                as_out = "one";
            else
                as_out = "two";

            return ai_in;
        }

        static public void f_show_string(string as_string, int ai_int, string as_string_again)
        {
            Console.WriteLine("Result: " + as_string + " - " + ai_int.ToString() + " - " + as_string_again);
        }

    }
}

The result is:

Result: - 1 - one
Result: one - 2 - two

But This wouldn't be the same in C++. Here is an implementation of the first example Konstantin provided (as I'm not at all a C++ expert it may not be 100% accurate - correct):

#include <iostream>
#include <string>

int fSetString(int num1, std::string &str1) {
    if (num1 == 1)
        str1 = "one";
    else
        str1 = "two";

    return num1;
}

void fShowString(std::string str1, int num1) {
    std::cout << "Result " + str1 + " - " + std::to_string(num1) + "\n";
}

int main()
{
    std::string str1{ };

    fShowString(str1, fSetString(1, str1));
    fShowString(str1, fSetString(2, str1));
}

Here the result is:

Result one - 1
Result two - 2

The result is what I understand Konstantin was expecting in his initial example. But I believe this is due because C++ is working in a lower level...

Andreas.