I've been programming verge for a little while, and I recently needed a way to return two variables from a function in order for the function to have any use. I've been a C/C++ programmer for a few years now, doing alot of low-level hardware related work, so I use bitshifts quite often. Anyway, I came up with a method for returning two values from a function inside of a bit-packed integer. The only catch for this function being that the integers have a range of 0 to 65535 as the sign-bit becomes irrelevant. Here's the code for doing, and hopefully someone out there can find this useful:


/// 2-Dimensional vector structure
struct CVector2D
{
int magnitude;
int x;
int y;
}

...

// Returns The Lowest 16-bits, in this case the X coordinate.
int GetLow(int bitPackedValue)
{
return (bitPackedValue & 65535);
}

// Returns The Highest 16-bits, in this case the Y coordinate.
int GetHigh(int bitPackedValue)
{
int ret = bitPackedValue;
ret = ret >> 16;
ret = ret & 65535;
return (ret);
}

int Add_Vector2D(int x1, int y1, int x2, int y2)
{
x1 += x2;
y1 += y2;
log("add - x1: " + str(x1));
log("add - y1: " + str(y1));

int packed = y1;
// Shift Y value into high 16-bits
packed = packed << 16;
// Add In X Value to low 16-bits
packed = packed | x1;

return (packed);
}


Now you can use this something like this:


CVector2D v1;
CVector2D v2;


void autoexec() {
// Set Initial Vector Type Values
v1.x = 15;
v1.y = 15;
v2.x = 15;
v2.y = 15;

// Perform Vector Addition
int packedCoords = Add_Vector2D(v1.x, v1.y, v2.x, v2.y);
int x = GetLow(packedCoords);
int y = GetHigh(packedCoords);

// log it to make sure it worked
log("x coordinate: " + str(x) + " y coordinate: " + str(y));
}


I'm currently trying to find a method of preserving the sign-bit, though this would decrease the maximum value of the variable, but allow the return of signed integers as well.

It seems like it would be easier to just pass a pointer to a couple of quads or something.

The global thing probably would be easier. Gayo: I wasn't aware that Verge3 had the ability to use pointers, could you expand on that concept for a newb like myself?

Yeh, I've pretty much read through the entire doc. I suppose that could work, I might try formulating a system using that and possibly post results if I'm successful. DMA would allow me to keep signs and such as well, thanks for the information and ideas :)

object MakeFunctionsReturnStructsPlease(int a, int b)


{


PreMadeStruct Please;


Please.a = a;


Please.b = b;


return Please;


}





PreMadeStruct YourMom = (PreMadeStruct)MakeFunctionsReturnStructsPlease(1, 2);

It would be creamy, admit it.

Actually, Zip's idea is better than mine -- just have two "returnedvalue" globals and set them inside functions. Could get messy to debug, but it'd be way easier than DMA and would allow full integer range.

Couldn't agree more with you Omni, its a neat experiment but really I didn't plan on really using it. I've actually switched to DMA mode for now, but as you guys said the syntax is quite verbose, and so I won't post the code here. I wrote encapsulation functions for reading/writing bytes,words of data, both signed and unsigned from the DMA memory, I also wrote functions to add two vectors given their offsets in DMA memory. Also, Zaril, why not have functions take structs as data types:

struct Blah


{


	int x;


	int y;


}





int AddTwoBlahs(Blah blah1, Blah blah2)


{


	blah1.x += blah2.x;


	blah1.y += blah2.y;


}

Though as mcgrue stated, thats probably not gonna happen any time soon. Also a quick off-topic question to the VERGE3 developers, did you guys write your own parser, because if so I would also recommend you check out the Spirit(http://spirit.sourceforge.net/) parser that is part of the Boost library, I've used it countless times as it makes parsing most data formats a breeze.

It's just that passing the index is kind of a pain. It's not one of the worst deficiencies in that there's an easy workaround, but it is a mite painful.

I should note that it's incredibly valuable to be able to pass by reference for integers, too, since there isn't any workaround for that.

What we need is for someone to make an executable that parses upper-level custom preproc things in code, then outputs a vc file, then calls VERGE to compile that. :D

McGrue: Wasn't expecting you guys to actually change to Spirit, but just a suggestion.

As for VERGE-C its alot like C, as has probably been stated countless times, I personally don't mind using alot of globals, its just something new I've got to adjust to as in my C++ code I rarely if ever use a global variable. Also that reference passing code isn't quite right above, you're passing a pointer into a function that takes a reference, the correct way would be more like:

PreMadeStruct YourDad;


NoNeedToReturnStructs(YourDad, 1, 2);

Thats what made C++ references so powerful, you didn't have to convert it into a pointer, you just passed the variable in and the compiler generated all the code needed to make it like you were passing a pointer. I like VERGE-C though, its a nice change from what I'm used to.