Some grammar actions can be removed

[mingodad]

Looking through the grammar at https://github.com/LilyOSullivan/SymbolicExecutionForCWithParser/blob/main/LexYacc/Parser_source/GRAMMAR.Y I noticed that there are several actions that can be removed and achieve the same result with less work/allocations:

{
        $$ = (char*) malloc(strlen($1) + 1);
	strcpy($$, $1);
        free($1);
}

Rule actions like the above can be removed, because the default rule is $$ = $1, so no need to copy and delete $1.

	{
		struct_flag = NO;
		
		// Visual C extension
		$$ = (char*) malloc(strlen($2) + 1);
		strcpy($$, $2);
		free($1);
		free($2);
	}

Rule actions like the above can be reduced to :

	{
		struct_flag = NO;
		
		// Visual C extension
		$$ = $2;
		free($1);
	}

[mingodad]

Also to simplify the code you can replace all:

newstr = (char*)malloc(strlen(src_str) + 1);
strcpy(newstr, src_str);

by

newstr = strdup(src_str);

[mingodad]

I also notice that you are comparing identifiers in some sort of case insensitive way but C is always case sensitive:

int traverse_types(char typedefname[])
{
	/*	
		This function is called with the parameter 'typedefname'.
		If 'typedefname' exists in the linked list of typedefs, YES (1) is returned;
		else NO (0) is returned.
	*/

	int result = NO;				// return result of the function
									// by default, the result is 0 - NO
	
	// allocate space to param_string, assign it upper case of 'typedefname'
	char* param_string = upper(typedefname);  //<<<<<<!!!!!!  HERE
	// Traverse the linked list and compare the typedefs therein with 'typedefname'.
	typenode = typestart.typenext;
	while (typenode && (result == NO))
	{
		// allocate space to linkedlist_string, assign it upper case of current node string
		char* linkedlist_string = upper(typenode->type_name); //<<<<<<!!!!!!  HERE
		
		// Compare the UPPER CASE equivalent of both strings.
		// If they are the same, result = EXISTS
		if (strcmp(param_string, linkedlist_string) == 0) //<<<<<<!!!!!!  HERE						
			result = YES;		
		typenode = typenode->typenext;
		free(linkedlist_string);
	}
	free(param_string);
	
	return result;		
}

The code shown above will mistakenly consider SuperType equal superType but in C they are two different symbols.

[mingodad]

Also in several places you have:

strcpy(newstring, initialisestring(newstring, strlen(string) + 1));

You do not need to copy the initialized string over itself, this seems to be enough:

initialisestring(newstring, strlen(string) + 1);

And remember that there is a standard function memset in <string.h> that does what your initialisestring is doing and the compiler can optimize it:

memset(newstring, 0, strlen(string) + 1);

Or in case you are previously also allocating the newstring you can use calloc from <stdlib.h> and already get memory zeroed:

char* newstring = calloc(strlen(string) + 1, sizeof(char*));