#include <Core/Core.h>

using namespace Upp;

// this construction is used a lot in upp
String SomeFunction()
{
	StringBuffer s;
	s.Cat("M\0nkey", 6); // some binary data
	return s;  // warning C4927: illegal conversion; more than one user-defined conversion has been implicitly applied

	// this contruction (returning a StringBuffer to a String return type) is used a LOT in UPP
	// it relies on the constructor of String(StringBuffer& )  to do the copying
	// However another path is from StringBuffer::Begin() -> String::String(const char*)
	// this however does not work for binary data (containing a 0)
	// Visual Studio 2019 picks the first or the second option depending on which *EXACT* version of it you're using, and gives this warning that it flipped a coin
	// IT IS NOT A BENIGN WARNING! It's roulette if the software works or not.
	// I cannot compile a stable executable of TheIde with VS2019 on my computer. It just keeps
	// crashing. My collegue can. 
}

CONSOLE_APP_MAIN
{
	String rv = SomeFunction();
	Cout() << rv.GetCount() << "\r\n"; // Should print 6, but prints 1
}

//return s;
return String(s);

#include <iostream>

typedef unsigned char bYte;
#define min(a,b) ( a<b ? a : b )

class B;

class A {
	public:
		bYte data[256]; bYte datalen;
		
	public:
		A(const void* b, bYte len); // assign binary data
		A(char* string); // assign C string
		A(B& b);
		operator char*() // to c string
		{
			data[sizeof(data)-1]=0;
			return (char*)data;
		};
};

class B {
	public:
		bYte data[256]; bYte datalen;
		
	public:
		B(const void* b, bYte len); // assign binary data
		B(char* string); // assign C string
		operator char* ()  // to c string
		{
			data[sizeof(data)-1]=0;
			return (char*)data;
		}
};


A::A(const void* b, bYte len) // assign binary data
{
	datalen = min(len, sizeof(data)-1);
	memcpy(data, b, datalen);
	data[datalen]=0;
}

A::A(char* string) // assign C string
{
	datalen = min(strlen(string)+1, sizeof(data));
	memcpy(data, string, datalen);
	data[sizeof(data)-1]=0;
}

A::A(B& b)
{
	datalen = b.datalen;
	memcpy(data, b.data, sizeof(data));
}

B::B(const void* b, bYte len) // assign binary data
{
	datalen = min(len, sizeof(data)-1);
	memcpy(data, b, datalen);
	data[datalen]=0;
}

B::B(char* string) // assign C string
{
	datalen = min(strlen(string)+1, sizeof(data));
	memcpy(data, string, datalen);
	data[sizeof(data)-1]=0;
}

A ReturnB()
{
	const char binary[10] = {1,2,0,3,4,5,6,7,8,0};
	B b(binary, 10);
	return b;
}

int main(int argc, const char *argv[])
{
	A a = ReturnB();
	int len = a.datalen;
	std::cout << "This should return 10 and it returns " << len << "\r\n";
	return 0;
}

// 		A(B& b);
		A(const B& b);

#include <iostream>

struct B;

struct A {
	A(char*) { std::cout << "A::A(char *)\n"; }
	A(B&)    { std::cout << "A::A(B&)\n"; }
};

struct B {
	operator char*() { std::cout << "B::operator char *()\n"; }
};

A Test()
{
	B b;
	return b;
}

int main(int argc, const char *argv[])
{
	A a = Test();
	return 0;
}

//	operator char*() { std::cout << "B::operator char *()\n"; }
	operator char*() { std::cout << "B::operator char *()\n";  return ""; }

return String(s);

return s;

	if(package == mainpackage)
		info << Join(SvnInfo(package), "\r\n");

	if(package == mainpackage)
		info << Join(SvnInfo(package), "\r\n") << "\r\n";