What is wrong with pointer expression in c? - c

Question

I am using a function that has a segment (shown below) that was used in qsort to compare variable fields that are sorted in either ascending or desending order. I added a third order (assending is 0, descending is 1 and the third order is 2) where I sort gas and oil well classifications in the NormalizeResClass function that returns a different int for the classifications.
I added the code for (typsort == 2) as shown below, but it only sorts properly when I have the reserve class as the only type of sort. If I sort with a secondary sort like by reserve class and well name it dose not sort.
The original code in the else block uses *((int *) before xval and yval and I am weak on pointers. I know that it is casting to int but the NormalizeResClass function already returns an int so I don't need the cast, and if I use it I get a segmentaion fault.
static char *Strings = NULL; // Global var
int result= 0; // local var
int ft; // local var
// ft is checked before going to this to be >= 0
if (typsort == 2)
{
// the code that I have added
result = strncmp (Strings + NormalizeResClass (xval),
Strings + NormalizeResClass (yval), ft);
}
else
{
// this code was there and the sorting was right
result = strncmp (Strings + *((int *) xval),
Strings + *((int *) yval), ft);
}
This is the Normalize Function below I might need to make sure all of these have a unique
number a few have the same.
int NormalizeResClass (char rc)
{
/
Given a reserve class string , return a reserve class number.
*/
register int i;
register char *p, *q;
static struct
{
int index;
char str;
} RCposs[] =
{
{
1, "PROVED DEVELOPED PRODUCING"},
{
2, "PROVED PRODUCING SECONDARY"},
{
3, "PROVED PRODUCING TERTIARY"},
{
1, "PROVED PRODUCING"},
{
4, "PROVED SHUT-IN"},
{
5, "PROVED DEVELOPED NON-PRODUCING"},
{
5, "PROVED NON-PRODUCING"},
{
6, "PROVED DEVELOPED BEHIND-PIPE"},
{
6, "PROVED BEHIND-PIPE"},
{
8, "PROVED UNDEVELOPED SECONDARY"},
{
9, "PROVED UNDEVELOPED TERTIARY"},
{
7, "PROVED UNDEVELOPED"},
{
1, "PROVED"},
{
10, "PROBABLE DEVELOPED PRODUCING"},
{
11, "PROBABLE PRODUCING SECONDARY"},
{
12, "PROBABLE PRODUCING TERTIARY"},
{
13, "PROBABLE SHUT-IN"},
{
10, "PROBABLE PRODUCING"},
{
14, "PROBABLE DEVELOPED NON-PRODUCING"},
{
14, "PROBABLE NON-PRODUCING"},
{
15, "PROBABLE DEVELOPED BEHIND-PIPE"},
{
15, "PROBABLE BEHIND-PIPE"},
{
17, "PROBABLE UNDEVELOPED SECONDARY"},
{
18, "PROBABLE UNDEVELOPED TERTIARY"},
{
16, "PROBABLE UNDEVELOPED"},
{
20, "PROBABLE PRIMARY/SECONDARY"},
{
21, "PROBABLE SECONDARY"},
{
19, "PROBABLE"},
{
22, "POSSIBLE DEVELOPED PRODUCING"},
{
23, "POSSIBLE PRODUCING SECONDARY"},
{
24, "POSSIBLE PRODUCING TERTIARY"},
{
25, "POSSIBLE SHUT-IN"},
{
22, "POSSIBLE PRODUCING"},
{
26, "POSSIBLE DEVELOPED NON-PRODUCING"},
{
26, "POSSIBLE NON-PRODUCING"},
{
27, "POSSIBLE DEVELOPED BEHIND-PIPE"},
{
27, "POSSIBLE BEHIND-PIPE"},
{
29, "POSSIBLE UNDEVELOPED SECONDARY"},
{
30, "POSSIBLE UNDEVELOPED TERTIARY"},
{
28, "POSSIBLE UNDEVELOPED"},
{
22, "POSSIBLE"},
{
32, "PROSPECTIVE PRIMARY/SECONDARY"},
{
33, "PROSPECTIVE SECONDARY"},
{
31, "PROSPECTIVE"},
{
34, "ANALOGY"},
{
35, "DEPLETE"},
{
36, "PROV+PROB+POSS UNDEVELOPED RESERVES"},
{
37, "PROV+PROB+POSS DEVELOPED RESERVES"},
{
38, "PROV+POSS UNDEVELOPED RESERVES"},
{
39, "PROV+POSS DEVELOPED RESERVES"},
{
40, "PROB+POSS UNDEVELOPED RESERVES"},
{
41, "PROB+POSS DEVELOPED RESERVES"},
{
42, "PROV+PROB UNDEVELOPED RESERVES"},
{
43, "PROV+PROB DEVELOPED RESERVES"},
{
44, "RISKED PROV UNDEVELOPED RESERVES"},
{
45, "RISKED PROB UNDEVELOPED RESERVES"},
{
46, "RISKED POSS UNDEVELOPED RESERVES"},
{
47, "RISKED PROV BEHIND-PIPE RESERVES"},
{
48, "RISKED PROB BEHIND-PIPE RESERVES"},
{
49, "RISKED POSS BEHIND-PIPE RESERVES"},
{
50, "PLANT PRODUCTS SALES"},
{
51, "PROBABLE PLANT PRODUCTS SALES"},
{
52, "POSSIBLE PLANT PRODUCTS SALES"},
{
53, "POTENTIAL PLANT PRODUCTS SALES"},
{
54, "PROVED GAS PIPELINE SALES"},
{
55, "PROBABLE GAS PIPELINE SALES"},
{
56, "POSSIBLE GAS PIPELINE SALES"},
{
57, "POTENTIAL GAS PIPELINE SALES"},
{
58, "PROVED OIL PIPELINE SALES"},
{
59, "PROBABLE OIL PIPELINE SALES"},
{
60, "POSSIBLE OIL PIPELINE SALES"},
{
61, "POTENTIAL OIL PIPELINE SALES"},
{
0, NULL / terminator */ }};
for (i = 0; (q = RCposs[i].str); i++)
{
p = rc;
while (*p++ == *q++)
{
if ((*q == '\0'))
return RCposs[i].index;
}
}
return (0);
}

Answer 1

Based on the code that you have shown, it looks like the global Strings variable is a large block of memory which contains many different strings (one per record, presumably).
The original code:
result = strncmp (Strings + *((int *) xval),
Strings + *((int *) yval), ft);
compares the string at Strings[xval] to the string at Strings[yval], with maximum length ft.
I don't know what the NormalizeResClass(x) function does, but if it is going to work the in a similar fashion to the old code, it needs to return an int which represents the location of the beginning of a string in the Strings memory block. It must not return an index which would fall outside of that memory block, otherwise the call to strncmp would start reading from who knows where.
Update:
It looks like your NormalizeResClass function returns an integer ranking for a resource class string. In that case, you should not be using strncmp() and Strings[] at all. The code should look something like this:
if (typsort == 2)
{
int xRank = NormalizeResClass (xval);
int yRank = NormalizeResClass (yval);
if (xRank == yRank) { result = 0; }
else if (xRank > yRank) { result = 1; }
else if (xRank < yRank) { result = -1; }
}