On Stack :: Starzan and Cheetae Question

Rommel-kun: char Starzan[strlen(Cheetae)];
Rommel-kun: bossing do you remember our conversation regarding the above code?
Rommel-kun: What is the weakness of the above code?
GovZ Repuspolo: ok game .. in your opinion what is its weakness …
Rommel-kun: hmm …it is possible to fail if the string is empty…
Rommel-kun: zero…
Rommel-kun: ahhh
Rommel-kun: wait i will verify with msdn ….
GovZ Repuspolo: hahahahah
Rommel-kun: there it is!
Rommel-kun: strlen will return -1 if string contains invalid char
Rommel-kun: haha
Rommel-kun: is that the one?
GovZ Repuspolo: hahahah partially correct
Rommel-kun: partially? hahahaha it is like a new puzzle
GovZ Repuspolo: ok let us try to share the answer on your question …
GovZ Repuspolo: i will answer via my blog site …
Rommel-kun: thanks
GovZ Repuspolo: no problem

For everyone to understand, alwyn, rommel and I had dinner one time and i told them how i hated malloc, calloc and realloc. And as far as I can, I try to stay away from them, for reasons I will disclose further blogs. But for now, please accept the fact I hate the three commands.

In my avoidance of malloc() or any of its forms, I ended up using the following kind of technique :
==============================
/* C++ int32 = 32bit integer int8 = char */
int32 vic_sotto(0);
vic_sotto = function_that_returns_int32(2,5);
int8 jimmy_santos[vic_sotto + 1];
==============================
Assuming the above code is valid according to the coding guidelines, there is an innate flaw to the code. But first let me get back to rommel’s responses …

1. Rommel-kun: wait i will verify with msdn ….

-> 20 Points for attitude : ANY DEVELOPER SHOULD ALWAYS CHECK HIS OR HER PLATFORMS AUTHORITATIVE MANUAL … hmmm though this may be overkill, it is imperative, we check what we do not know. Especially windows implementations (i have so many stories about windows interoperability… hahahah i can write a document about it. nahhh … not my style )

2. Rommel-kun: strlen will return -1 if string contains invalid char

-> 10 points for attitude : Be patient until one finds an authoritative answer for a simple or complex question. In my experience though, most of the times the answer will elude you depending on the question’s level of difficulty.

However, as I have said, the answer is partially correct. In an embedded platform, and or in Windows for that matter, one should always think that any form of used resource has a limit. In this case, the STACK IS NOT INFINITE, NOTHING IS INFINITE. So therefore, aside from having a negative sized allocation, you may end up with something like :

==============================
/* C++ int32 = 32bit integer int8 = char */
int32 vic_sotto(0);
vic_sotto = function_that_returns_int32(2000000,50000000);
/* vic_sotto = 2,000,000,000 */
int8 jimmy_santos[vic_sotto + 1];
==============================

Now what do you think will happen? This is what I call stack failure (stack overflow). You see for each process ( or thread or task) we create, the OS allocates a defined size for its stack. (As for the idea of stack, check wiki for it ) This is where your local variables are stored temporarily. Once the function exits, (or thread/process/task for that matter) it releases the used memory.

The stack is the best place to get memory from, and the fastest. But in my experience it can be really really small in terms of size. For example, in one of the non-RTOS I have worked on, the stack size was only 8Kb. In one of my RTOS adventures, I came across a 2K byte stack. So whether you are in windows or not, or you have a hell of a freeway for stack … DONT ABUSE YOUR RESOURCES… its much like life too, never abuse your resources in life.

So to correct the above code, assuming we still want to do it the same way :
==============================
/* C++ int32 = 32bit integer int8 = char */
int32 vic_sotto(0);
vic_sotto = function_that_returns_int32(2000000,50000000);
/* guard the damn thing with a macro JOEY_DE_LEON = 20 */
if ((vic_sotto<0) || (vic_sotto + 1 > JOEY_DE_LEON)) {
return -1; /* function failure */
}
int8 jimmy_santos[vic_sotto + 1];
==============================

Remember :
1. When you can, if it is ok, use STACK.
2. The STACK is NEVER INFINITE.
3. Apply a guard appropriately.
4. hehehe, for political reasons, follow the damned coding guidelines!!!
5. Only the stupid and arrogant think they are perfectly perfect.