WARNING: RobotC bug prevents having more than 100 methods!!!

chadgeorge · Thu Feb 26, 2009 1:15 pm

Okay, so I was really ticked off at 3:00am when I ran into this bug (again). I posted the first time about this but the developers never did anything about it...and now that I know what it is I realize they didn't even remotely try. Because they should have been able to tell me immediately what the issue was.

So now after a some sleep I'm only a little ticked off. Not because of the bug or even the limitation to RobotC, but because I believe the developers knew about the limitation (maybe even the bug too), and are intentionally trying to hide this limitation. If they were being up front they'd say on the description page. "Hey, this is RobotC. Its sorta like C but for Robots. Also you can only have 14 files and 100 functions, but its really alot like C so use it."

So the limitation is simple. You can't use more than 100 functions in a program. One nice thing is the compiler stats tell you how many you have. DEVELOPERS: WHY DIDN'T YOU SAY SOME THING LIKE "using 25 of 100 methods". Its just common sense to list limits next to usage!

The lack of documentation is just laziness, but the bug is something truely awesome to behold. Talk about a total lack of unit testing!

If you happen to use more 7-8 functions in each of your 14 allowed files ... then when you try to call the 101st function you get a RUNTIME ERROR. Yes, that's right. The compiler happily compiles as many functions as you are willing to type, but it CAN'T ACTUALLY CALL THEM.

I'm sorry but the excuse that "99.9% of RobotC users over the past 3 years haven't needed this functionality" just doesn't cut it. I call your bluff. I think its a limitation of your runtime and like all the other limitations you just fail to document it. Because I don't honestly believe you could successfully build something a complex as RobotC and the different firmwares and "overlook" the fact that you have a limit on the number of functions or files allowed in a program.

I can't even begin to imagine why this isn't at least flagged by the compiler. This lack of compiler warnings/errors and the total lack of documentation related to exactly how RobotC isn't ANSI C seems to say you're intentionally hiding RobotC limits. WE'RE PROGRAMMING A MICROCONTROLLER WE EXPECT LIMITS. WE JUST NEED TO KNOW WHAT THEY ARE BEFORE WE RUN HEADFIRST INTO THEM!

Oh, for those who don't want to type 101 functions for yourself to see the bug. Here's a test file to play with. Even the debugger can't break on the 101st function call


	Code: int foo0() {return 0;} int foo1() {return 1;} int foo2() {return 2;} int foo3() {return 3;} int foo4() {return 4;} int foo5() {return 5;} int foo6() {return 6;} int foo7() {return 7;} int foo8() {return 8;} int foo9() {return 9;} int foo10() {return 10;} int foo11() {return 11;} int foo12() {return 12;} int foo13() {return 13;} int foo14() {return 14;} int foo15() {return 15;} int foo16() {return 16;} int foo17() {return 17;} int foo18() {return 18;} int foo19() {return 19;} int foo20() {return 20;} int foo21() {return 21;} int foo22() {return 22;} int foo23() {return 23;} int foo24() {return 24;} int foo25() {return 25;} int foo26() {return 26;} int foo27() {return 27;} int foo28() {return 28;} int foo29() {return 29;} int foo30() {return 30;} int foo31() {return 31;} int foo32() {return 32;} int foo33() {return 33;} int foo34() {return 34;} int foo35() {return 35;} int foo36() {return 36;} int foo37() {return 37;} int foo38() {return 38;} int foo39() {return 39;} int foo40() {return 40;} int foo41() {return 41;} int foo42() {return 42;} int foo43() {return 43;} int foo44() {return 44;} int foo45() {return 45;} int foo46() {return 46;} int foo47() {return 47;} int foo48() {return 48;} int foo49() {return 49;} int foo50() {return 50;} int foo51() {return 51;} int foo52() {return 52;} int foo53() {return 53;} int foo54() {return 54;} int foo55() {return 55;} int foo56() {return 56;} int foo57() {return 57;} int foo58() {return 58;} int foo59() {return 59;} int foo60() {return 60;} int foo61() {return 61;} int foo62() {return 62;} int foo63() {return 63;} int foo64() {return 64;} int foo65() {return 65;} int foo66() {return 66;} int foo67() {return 67;} int foo68() {return 68;} int foo69() {return 69;} int foo70() {return 70;} int foo71() {return 71;} int foo72() {return 72;} int foo73() {return 73;} int foo74() {return 74;} int foo75() {return 75;} int foo76() {return 76;} int foo77() {return 77;} int foo78() {return 78;} int foo79() {return 79;} int foo80() {return 80;} int foo81() {return 81;} int foo82() {return 82;} int foo83() {return 83;} int foo84() {return 84;} int foo85() {return 85;} int foo86() {return 86;} int foo87() {return 87;} int foo88() {return 88;} int foo89() {return 89;} int foo90() {return 90;} int foo91() {return 91;} int foo92() {return 92;} int foo93() {return 93;} int foo94() {return 94;} int foo95() {return 95;} int foo96() {return 96;} int foo97() {return 97;} int foo98() {return 98;} int foo99() {return 99;} int foo100() {return 100;} task main() { foo0(); foo1(); foo2(); foo3(); foo4(); foo5(); foo6(); foo7(); foo8(); foo9(); foo10(); foo11(); foo12(); foo13(); foo14(); foo15(); foo16(); foo17(); foo18(); foo19(); foo20(); foo21(); foo22(); foo23(); foo24(); foo25(); foo26(); foo27(); foo28(); foo29(); foo30(); foo31(); foo32(); foo33(); foo34(); foo35(); foo36(); foo37(); foo38(); foo39(); foo40(); foo41(); foo42(); foo43(); foo44(); foo45(); foo46(); foo47(); foo48(); foo49(); foo50(); foo51(); foo52(); foo53(); foo54(); foo55(); foo56(); foo57(); foo58(); foo59(); foo60(); foo61(); foo62(); foo63(); foo64(); foo65(); foo66(); foo67(); foo68(); foo69(); foo70(); foo71(); foo72(); foo73(); foo74(); foo75(); foo76(); foo77(); foo78(); foo79(); foo80(); foo81(); foo82(); foo83(); foo84(); foo85(); foo86(); foo87(); foo88(); foo89(); foo90(); foo91(); foo92(); foo93(); foo94(); foo95(); foo96(); foo97(); foo98(); foo99(); foo100(); PlaySound(soundBeepBeep); while(true) {wait1Msec(10);} }

I'm going to write a Python script to automatically refactor code to remove the least needed functions. So I'll post that when I get it done. Right now my robot code is sitting at exactly 100 methods. I've been sitting right at the bleeding edge of disaster for a week and never knew it. And I still need to put autonomous back in

WARNING: RobotC bug prevents having more than 100 methods!!!

Who is online