portability

pls post the code.

this is the code- i have indicated the line which is causing the problem.
thanks for any help.

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>
#include<ctype.h>
#include<printer.h>
#define TRUE 1
#define FALSE 0
#define SPACE ' '
#define LINES_PER_PAGE 45
#define STR_SIZE1 sizeof(struct issue_receipt)
#define STR_SIZE2 sizeof(struct rec_delete)
#define STR_SIZE3 sizeof(struct rec_create)
#define STR_SIZE4 sizeof(struct link)


struct issue_receipt{
             char rec_type;
             char cust_code[6];
             char part_num[7];
             char ir_quantity[5];
             };

struct rec_delete{
             char rec_type;
             char cust_code[6];
             };

struct rec_create{
             char rec_type;
             char cust_code[6];
             char cust_name[21];
             char cust_address[61];
             char cust_balance[10];
             char credit_limit[8];
             };

struct link{
             char rec_type;
             char cust_code[6];
                         char part_num[7];
             char ir_quantity[5];
                         char cust_name[21];
             char cust_address[61];
             char cust_balance[10];
             char credit_limit[8];
             short *next;
             };

struct position{
             char cust_code[6];
             long pos;
             }rec_ptr[500];


void totals_calc(FILE *file_ptr,int tot_recs);

void main()
{
  FILE *validdat_ptr, *sortdat_ptr;
  struct issue_receipt trans_STR;
  struct rec_delete del_STR;
  struct rec_create create_STR;
  struct link *list;
  char type, newline='\n', sstore[6];
  int rec_num=0,loop=0, loop1=0;
  long  store;

  /*Open files and streams*/
  if((validdat_ptr = fopen("A:486981VF.DAT","rb")) == NULL)
  {
     printf("\nERROR OPENING TEST DATA FILE");
     exit(1);
  }

  if((sortdat_ptr = fopen("A:486981SD.DAT","wb+")) == NULL)                      
  {
     printf("\nERROR OPENING SORTED DATA FILE");
     exit(1);
  }

  list = (struct link *)malloc(STR_SIZE4);
  rec_ptr[rec_num].pos = list;


  /*Main loop*/
  while(!feof(validdat_ptr))
  {
     /*Read first character to identify record type*/
     fread(&type,1,1,validdat_ptr);

     if(feof(validdat_ptr)) /*Prevents last record from */
        break;              /*being output twice          */


     /*Move the pointer back to the start of the record*/
     fseek(validdat_ptr,-1,SEEK_CUR);
     type = toupper(type);

        /*deal with record*/
     switch(type)
     {

        case 'I':fread(&trans_STR,STR_SIZE1,1,validdat_ptr);
                    list->next = (struct link *)malloc(STR_SIZE4);
                    list->rec_type = type;
                    strcpy(list->cust_code,trans_STR.cust_code);
                    strcpy(list->part_num,trans_STR.part_num);
                    strcpy(list->ir_quantity,trans_STR.ir_quantity);
                    break;

        case 'R':fread(&trans_STR,STR_SIZE1,1,validdat_ptr);
                    list->next = (struct link *)malloc(STR_SIZE4);
                    list->rec_type = type;
                    strcpy(list->cust_code,trans_STR.cust_code);
                    strcpy(list->part_num,trans_STR.part_num);
                    strcpy(list->ir_quantity,trans_STR.ir_quantity);
                    break;

        case 'D':fread(&del_STR,STR_SIZE2,1,validdat_ptr);
                    list->next = (struct link *)malloc(STR_SIZE4);
                    list->rec_type = type;
                    strcpy(list->cust_code,del_STR.cust_code);
                    break;

        case 'C':fread(&create_STR,STR_SIZE3,1,validdat_ptr);
                    list->next = (struct link *)malloc(STR_SIZE4);
                    list->rec_type = type;
                    strcpy(list->cust_code,create_STR.cust_code);
                    strcpy(list->cust_name,create_STR.cust_name);
                    strcpy(list->cust_address,create_STR.cust_address);
                    strcpy(list->cust_balance,create_STR.cust_balance);
                    strcpy(list->credit_limit,create_STR.credit_limit);
                    break;

        default: break;
     }
     strcpy(rec_ptr[rec_num].cust_code,list->cust_code);
     rec_num ++;


     fread(&newline,1,1,validdat_ptr);    /*Read the newline after each record*/


     list = list->next;


     rec_ptr[rec_num].pos = list;
  }


  for(loop1=0;loop1<rec_num;loop1++)
  {
     for(loop=0;loop<rec_num-1;loop++)
     {
        if(strcmp(rec_ptr[loop].cust_code,rec_ptr[loop+1].cust_code) > 0)
        {
          store = rec_ptr[loop].pos;
          rec_ptr[loop].pos = rec_ptr[loop+1].pos;
          rec_ptr[loop+1].pos = store;

          strcpy(sstore,rec_ptr[loop].cust_code);
          strcpy(rec_ptr[loop].cust_code,rec_ptr[loop+1].cust_code);
          strcpy(rec_ptr[loop+1].cust_code,sstore);
        }
     }
  }


  for(loop1=0;loop1<rec_num;loop1++)
  {
     list = rec_ptr[loop1].pos;    /*****this line is causing the problem *****/

     type = list->rec_type;
     switch(type)
     {
        case 'I':trans_STR.rec_type = type;
                    strcpy(trans_STR.cust_code,list->cust_code);
                    strcpy(trans_STR.part_num,list->part_num);
                    strcpy(trans_STR.ir_quantity,list->ir_quantity);
                    fwrite(&trans_STR,STR_SIZE1,1,sortdat_ptr);
                    break;

        case 'R':trans_STR.rec_type = type;
                    strcpy(trans_STR.cust_code,list->cust_code);
                    strcpy(trans_STR.part_num,list->part_num);
                    strcpy(trans_STR.ir_quantity,list->ir_quantity);
                    fwrite(&trans_STR,STR_SIZE1,1,sortdat_ptr);
                    break;

        case 'D':del_STR.rec_type = type;
                    strcpy(del_STR.cust_code,list->cust_code);
                    fwrite(&del_STR,STR_SIZE2,1,sortdat_ptr);
                    break;

        case 'C':create_STR.rec_type = type;
                    strcpy(create_STR.cust_code,list->cust_code);
                    strcpy(create_STR.cust_name,list->cust_name);
                    strcpy(create_STR.cust_address,list->cust_address);
                    strcpy(create_STR.cust_balance,list->cust_balance);
                    strcpy(create_STR.credit_limit,list->credit_limit);
                    fwrite(&create_STR,STR_SIZE3,1,sortdat_ptr);
                    break;

        default :break;
     }

     fwrite(&newline,1,1,sortdat_ptr);
  }

  /*rewind(sortdat_ptr); */
  rewind(sortdat_ptr);
  totals_calc(sortdat_ptr,rec_num);

  free(list);
  fclose(sortdat_ptr);
  fclose(validdat_ptr);
}
/*End of main*/



void totals_calc(FILE *file_ptr,int tot_recs)
{
  char type,newline='\n';
  struct issue_receipt trans_STR;
  struct rec_delete del_STR;
  struct rec_create create_STR;



  while(!feof(file_ptr))
  {
     /*Read first character to identify record type*/
     fread(&type,1,1,file_ptr);

     if(feof(file_ptr)) /*Prevents last record from */
        break;             /* being output twice          */


     /*Move the pointer back to the start of the record*/
     fseek(file_ptr,-1,SEEK_CUR);
     type = toupper(type);

     switch(type)
     {
        case 'I':fread(&trans_STR,STR_SIZE1,1,file_ptr);
                                      fwrite(&trans_STR,STR_SIZE1,1,stdout);
                    break;
        case 'R':fread(&trans_STR,STR_SIZE1,1,file_ptr);
                                      fwrite(&trans_STR,STR_SIZE1,1,stdout);
                    break;
        case 'D':fread(&del_STR,STR_SIZE2,1,file_ptr);
                                      fwrite(&del_STR,STR_SIZE2,1,stdout);
                    break;
        case 'C':fread(&create_STR,STR_SIZE3,1,file_ptr);
                                      fwrite(&create_STR,STR_SIZE3,1,stdout);
                    break;
     }
     fread(&newline,1,1,file_ptr);
     fwrite(&newline,1,1,stdout);
  }

}

list is a pointer and rec_ptr[loop1].pos is a long
why are you trying to assign a long to a pointer?
struct link *list;
struct position{
             char cust_code[6];
             long pos;
             }rec_ptr[500];

Go to Borland "settings" and you can change which expressions are considered to errors or just a warnings

> I often use a long to calculate offsets in a memory buffer
When two pointers to elements of the same array object are subtracted, the result is the
difference of the subscripts of the two array elements.  The size of the result is implementation-
defined, and its type (a signed integral type) is ptrdiff_t defined in the <stddef.h> header.

to ozo:

imagine the following struct:

typedef struct
{
   int i;
   char c;
   long l;
} myType;

you can calculate the offset of field l in the struct in the following way.

myType m;
long offset = (long)(&m.l) - (long)&m;

The portable way to do that is

#include <stddef.h>
size_t offset = offsetof(myType,l);

aperdon, ozo: right, but offsetof is only specified for offsets within structs. if one wants to calculate the offset between two arbitrary pointers, this might be more portable than using longs (which usually should be 32bit, where addresses might be wider):

  size_t offset = (char *)ptr_a - (char *)ptr_b;

Unless both pointers point to elements of the same array object, or one past the last element of the array object, the behavior is undefined.

to aperdon:

i have changed the type for the pos field in the position struct to struct link *pos(also struct link *store) and code compiles ok but when i run the prog it just loops in the function totals_calc and there is no output to screen. any ideas on this?

thanks to all for your continued help.

ozo: It's not always undefined, example:

  void foo(FILE *f, int a, double b, char c, long d) {
    size_t size = ((char *)&d - (char *)&a) + sizeof(long);
    fwrite(&a, size, 1, f);
  }

has the defined behaviour of writing all relevant data from the parameters to f, plus some optional fill data for alignment. ok, it's a perfectly useless piece of code :-) and I guess we're getting a bit off-topic.

Undefined behavior - behavior, upon use of a nonportable or erroneous program construct,
of erroneous data, or of indeterminately valued objects, for which the standard imposes no
requirements.

ptrdiff_t size = ((char *)&d - (char *)&a)
(not size_t) would be portable if d and a were elements of the same array object, but the layout of the storage for function parameters is unspecified.

Add some printf's in the while-loop.

ozo> [...] but the layout of the storage for function parameters is unspecified

No. This is specified:

  void foo(int a, int b, int c) {
    int *arr = &a;
    /* ... */
  }

then:

  arr[0] -> a
  arr[1] -> b
  arr[2] -> c

otherwise the parameter ellipsis (...) would not be usable.

fremsley, a particular implementation is allowed to define it that way, in which case it must define the appropriate va_start and va_arg  macros in <stdarg.h> to make parameter ellipsis useable,
but the C standard imposes no such requirement.

ozo: I checked the header files; looks like you're right. I just couldn't believe still to learn something new about C after using for some 12 years :-)

to aperdon,

have solved problem! when the pointer to(sortdat_ptr) is passed to the functon it seems to have been lost so the while loop can not find eof. am i right with this? what i have done is replaced rewind(sortdat_ptr) with fclose(sortdat_ptr) and then reopened the file inside the function -file_ptr = fopen etc.
also have used printf as suggested.

regarding initial problem, please would you explain the reason for using struct link *pos and struct link *store.
is pos now replaced with a pointer to pos of data type struct link for example?

many thanks for your help.