I'm filling a structure with data from a line, the line format could be 3 different forms:

1.-"LD "(Just one word)

2.-"LD A "(Just 2 words)

3.- "LD A,B "(The second word separated by a coma).

The structure called instruccion has only the 3 pointers to point each part (`mnemo`, `op1` and `op2`), but when allocating memory for the second word sometimes `malloc` returns the same value that was given for the first word. Here is the code with the `mallocs` pointed:

``instruccion sepInst(char *linea){instruccion nueva;char *et;while(linea[strlen(linea)-1]==32||linea[strlen(linea)-1]==9)//Eliminating spaces and tabs at the end of the linelinea[strlen(linea)-1]=0;et=nextET(linea);//Save the direction of the next space or tabif(*et==0){//If there is not, i save all in mnemonueva.mnemo=malloc(strlen(linea)+1);strcpy(nueva.mnemo,linea);nueva.op1=malloc(2);nueva.op1[0]='k';nueva.op1[1]=0;//And set a "K" for op1nueva.op2=NULL;return nueva;}nueva.mnemo=malloc(et-linea+1);<-----------------------------------strncpy(nueva.mnemo,linea,et-linea);nueva.mnemo[et-linea]=0;printf("\nj%xj",nueva.mnemo);linea=et;while(*linea==9||*linea==32)//Move pointer to the second wordlinea++;if(strchr(linea,',')==NULL){//Check if there is a comanueva.op1=malloc(strlen(linea)+1);//Do this if there wasn't any comastrcpy(nueva.op1,linea);nueva.op2=NULL;}else{//Do this if there was a comanueva.op1=malloc(strchr(linea,',')-linea+1);<----------------------------------strncpy(nueva.op1,linea,strchr(linea,',')-linea);nueva.op1[strchr(linea,',')-linea]=0;linea=strchr(linea,',')+1;nueva.op2=malloc(strlen(linea)+1);strcpy(nueva.op2,linea);printf("\n2j%xj2",nueva.op2);}return nueva;}``

When I print the pointers it happens to be the same number.

note: the function char *nextET(char *line) returns the direction of the first space or tab in the line, if there is not it returns the direction of the end of the line.

`sepInst()` is called several times in a program and only after it has been called several times it starts failing. These `mallocs` across all my program are giving me such a headache.

There are two main possibilities.

Either you are freeing the memory somewhere else in your program (search for calls to `free` or `realloc`). In this case the effect that you see is completely benign.

Or, you might be suffering from memory corruption, most likely a buffer overflow. The short term cure is to use a specialized tool (a memory debugger). Pick one that is available on your platform. The tool will require recompilation (relinking) and eventually tell you where exactly is your code stepping beyond previously defined buffer limits. There may be multiple offending code locations. Treat each one as a serious defect.

Once you get tired of this kind of research, learn to use the `const` qualifier and use it with all variable/parameter declarations where you can do it cleanly. This cannot completely prevent buffer overflows, but it will restrict them to variables intended to be writable buffers (which, for example, those involved in your question apparently are not).

On a side note, personally, I think you should work harder to call malloc less. It's a good idea for performance, and it also causes corruption less.

``````nueva.mnemo=malloc(strlen(linea)+1);
strcpy(nueva.mnemo,linea);
nueva.op1=malloc(2);
``````

should be

``````// strlen has to traverse your string to get the length,
// so if you need it more than once, save its value.
cbLineA = strlen(linea);
// malloc for the string, and the 2 bytes you need for op1.
nueva.mnemo=malloc(cbLineA + 3);
// strcpy checks for \0 again, so use memcpy
memcpy(nueva.mnemo, linea, cbLineA);
nueva.mnemo[cbLineA] = 0;
// here we avoid a second malloc by pointing op1 to the space we left  after linea
nueva.op1 = nueva.mnemo + cbLinea + 1;
``````

Whenever you can reduce the number of mallocs by pre-calculation....do it. You are using C! This is not some higher level language that abuses the heap or does garbage collection!

Top