Thread: General question about undefined behavior

Does compiler based undefined behavior exist, under the following
condition...

If under the circumstances a program compiled with a C compiler compiles ( compliant with the ANSI C standard ) without error or warning and executes without run-time errors, but exhibits a strange behavior that if diagnosed with a program such as gdb shows faults directly to a compiler's library, would this constitute as compiler based undefined behavior?

Let me rephrase my question...

Probably what I mean by compiler based undefined behavior is actually what is called implementation defined behavior

Lets say, not all compiler implementations can recognize outside of the scope of what is an error defined in ANSI C standard and that not all forms of undefined behavior can be traced to their origin. What I am talking about is if you write some code that compiles fine but exhibits a behavior that has nothing to do with your code and it is not even undefined behavior, but is part of how the compiler decides at each part of the source code, to develop what becomes the final binary executable. What I am saying, is that there is a gray area of how compilers are designed which allow a behavior to occur. For example, a program exhibits a behavior that you think is undefined, but actually its not undefined behavior since that's the way the compiler implementation decides ( and most likely every time in that circumstance ) that that is how your program is going become a binary executable. This is what I call a compiler based undefined behavior, since all compilers are programs too.

Well the thing is that this is not a hypothetical question, I am writing a console program using DJGPP ( a port of GCC ) for MS-DOS. For the past month, even after upgrading the compiler after the most recent bug fixes, the behavior still occurs. Well , today I found a way around the problem, but I still wondering what was causing the problem was since I cant tell what it is. My program is actually a interpreter , I am designing a programming language for MS-DOS, which is intended to be used from a bootable USB flash drive used in PCs. My program uses non-standard C functions that are part of DJGPP implementation. Well, I found what the undefined behavior was, which the compiler was allowing.

In textmode(C4350) ( of conio.h ) .... using clrscr() ( of conio.h ) ..inhibits strtok() (of string.h ) from reaching the last token
of a string ( in my programming language statement ) that is passed to it. So what I want to do is write a smaller program which will produce the same undefined behavior and post it on the usenet forum for DJGPP, to see what other posters say about it.
I still have to do that...

Thats why I wanted to know in the first place if there is such a thing as compiler based undefined behavior or implementation defined behavior.

Undefined behaviour <=> Expect the Unexpected.

@ledow

Code:

short int string_parser(char *userstring, char *target, char magic, short int word)
{

  static char subject[PARSE_SIZE_LIMIT]; subject[0] = '\0';


  char *w = &magic;//assign the address of magic to w

  char a = 0,b = 0,c = 0,x = 0,z = 0;//temp variables

  short int length = 0,orig = 0;// get the length of the string
  short int offset = 0,y = 1;//segment control
  char *p;//used for assigning pointer address returned by strtok()


  //** format subject array of 'natural' garbage with spaces & reset x **
  //for (x = 0;x < PARSE_SIZE_LIMIT; x++) { subject[x] = ' '; } x = 0;


  orig = strlen(userstring);//get size length target array


  //copy and reformat the userstring into, 0 - PARSE_SIZE_LIMIT ; format.

  //for lines larger or equal than the size limit....
  if (orig >= (PARSE_SIZE_LIMIT - 1))
  {
    for (x = 0; x <= (PARSE_SIZE_LIMIT - 1); x++)
    { subject[x] = userstring[x]; }
  }

  //for lines less than the size limit....
  if (orig < (PARSE_SIZE_LIMIT - 1))
  {
    for (x = 0; x <= orig; x++)
    { subject[x] = userstring[x]; }
  }

  subject[x+1] = '\0';//add terminating null character

  //if (word == -1) { printf("<%s> ",subject); }//temp - keep

  length = strlen(subject);//get string length of subject[];

  //count where all the "magic" characters are
  for(x = 0;x < length;x++)
  {
     //if the subject character = "magic" character then count it
     if(subject[x] == magic)
     {
       a = x;//set a to x , to match where x is currently at.

       // check for no characters between "magic" characters if x > 0
       // if x = 0 then do nothing....
       if(x > 0)
       {
         c = a - b;// c = the new count (of x) - the old count (of x)

        /*

         a magic character must have a difference between it's last
         position (if there is one) and its new position ( which is greater
         than 1 ) to be counted as magic character. Therefore, if "#" is a
         magic character and a string is, "##magic:" it would be discounted.
         However, a string such as,"# #magic:" would be counted as two
         magic characters

        */

         if(c > 1) { y++; } /* if c > 1 then add 1 to y */
       }

       b = a;//set b to a , to save the previous count.
     }
  }

  //if the original length of the userstring is (PARSE_SIZE_LIMIT - 1)
  //then subtract 1
  if (orig >= (PARSE_SIZE_LIMIT - 1)) { y -= 1; }


  //the value of word finalizes the work of string_parser


  //return the number parts in the string
  if(word == -1) { return y; }

  //return the modified user string
  if(word == 0) { strcpy(target,subject); }


  //** this is where strtok() is used **


  //copy the first word in the string (must be done to find the next words)
  if(word == 1)
  {
    p = strtok(subject,w);
    strcpy(target,p);
  }

  //copy all the next words (sequencially) in the string
  if(word > 1)
  {
    p = strtok(NULL,w);
    strcpy(target,p);
  }

  return 0;
}

Code:

  //for lines larger or equal than the size limit....
  if (orig >= (PARSE_SIZE_LIMIT - 1))
  {
    for (x = 0; x <= (PARSE_SIZE_LIMIT - 1); x++)
    { subject[x] = userstring[x]; }
  }

  //for lines less than the size limit....
  if (orig < (PARSE_SIZE_LIMIT - 1))
  {
    for (x = 0; x <= orig; x++)
    { subject[x] = userstring[x]; }
  }

  subject[x+1] = '\0';//add terminating null character

You have a buffer overflow in both cases. Use a debugger to step through your loops to find out the value of "x" after both loops.
You really need to be more careful if you use <= in for-loops.

Code:

  //** this is where strtok() is used **

  //copy the first word in the string (must be done to find the next words)
  if(word == 1)
  {
    p = strtok(subject,w);
    strcpy(target,p);
  }

  //copy all the next words (sequencially) in the string
  if(word > 1)
  {
    p = strtok(NULL,w);
    strcpy(target,p);
  }

When word > 1 strtok returns garbage or NULL because you never initialise it with a string to tokenize. You only do that when word == 1.

Furthermore, "w" is not a C-string but a pointer to a single character.

Bye, Andreas