When I try to compile a C file under 64-bit Linux using command:

```
gcc -o strain_from_faults_new strain_from_faults_new.c gen.h eqf.h

```

I met the following errors:

```
eqf.h:16:3: error: unknown type name ‘Point’
   Point loc; 
   ^
eqf.h:32:3: error: unknown type name ‘Point’
   Point p[33]; 
   ^
eqf.h:44:3: error: unknown type name ‘Point’
   Point p[33]; 
   ^
eqf.h:61:3: error: unknown type name ‘Point’
   Point xy[NSEG]; 
   ^

```

It seems that type 'Point' is not defined, but it does defined in the file

> 
> gen.h
> 
> 
> 

```
struct point {
  double x;
  double y;
 };
typedef struct point Point;

```

I don't know why it have such an error, since this C file can be compiled in other computers. Is this 32bit-64bit compatible issue?
Any comment(s) would be highly appreciated!

According to the comments I `#include "gen.h"` in eqf.h file, but it not doing well. Since the two head files `gen.h eqf.h` have already been included in the C file `strain_from_faults_new.c`, the compiler have errors:

```
In file included from eqf.h:12:0,
                 from strain_from_faults_new.c:6:
gen.h:11:8: error: redefinition of ‘struct point’
 struct point {
        ^
In file included from strain_from_faults_new.c:5:0:
gen.h:11:8: note: originally defined here
 struct point {
        ^

```

Does anybody have any ideas?

Well, following are the entire codes:

> 
> gen.h
> 
> 
> 

```
#define MAX_NAME 50
#define MAXNAME 50
#define EARTH_RADIUS 6371.0
#define MU (3.0e11)
#define PI 3.1415927
#define D2R 0.0174532
#define SUNIT (1.0e-9)
#define KAPA 0.25
#include <stdio.h>

struct point {
  double x;
  double y;
};

typedef struct point Point;

extern int enclose(Point *, int, Point);
extern int enclose2(Point *, int, Point, Point);
extern int lenclose(Point *p, int n, Point p1);
extern int lenclose2(Point *p, int n, Point p1, Point p2);
extern double azimuth(double, double);
extern double atan2d(double, double);
extern double sind(double);
extern double cosd(double);
extern double dsign(double);
extern double dmax(double, double);
extern double dmin(double, double);
extern double diag_len(Point p[]);
extern void make_tensor(double z[][3],  double, double, double);
extern void read_a_line(FILE *);
extern void strip_a_line(FILE *);
extern char *get_a_string(FILE *f, char* str);
extern int line_to_string(FILE *f, char* str);
extern int in_region(int node[], int N, int p);
extern double convert_date_to_year(int);

```

> 
> eqf.h
> 
> 
> 

```
#define MAXP 10
#define MAXN 400
#define MAXB 1000
#define MAXF 37000
#define MAXE 1000
#define TYPE_F 1
#define TYPE_E 0
#define T 149 
#define DEPTH 15.0 
#define NSEG 2074
#include <stdio.h>
#include "gen.h"

struct earthquake {
  int  date;
  Point loc; 
  double mom[3][3];
  double m0;
  int type;
};
struct merr {
  double m[3][3];
};

struct mom {
  double m0;
  double mxx;
  double myy;
  double mxy;
};
struct region {
  Point p[33]; 
  double area; 
  double t0; 
  struct earthquake event[50];
  int ne; 
  struct earthquake *e[100];
  double strainrate[9]; 
  double strain[9]; 
  double strainr[9]; 
  double strain0[9]; 
};
 struct regionf {
   Point p[33]; 
   double area; 
   int ix;
   int iy;
   int ia;
};

 struct fault {
   double strike;
   double rake;
   double dip;
   double rate;
   double ratemin;
   double ratemax;
   char name[50];
   int  date;
   int n; 
   Point xy[NSEG]; 
 };

 extern void test();
 extern void read_faults(FILE *inf, struct fault *f);
 extern void test_mom();
 extern void print_event (FILE *inf, struct earthquake e);
 extern int bydate(struct earthquake *, struct earthquake *);
 extern void sort_event(FILE *);
 extern int write_mom_tensor(struct earthquake *, int *, double);
 extern void fill_regionf(struct regionf *, int *);
 extern void fill_region(struct region *, int *);
 extern void print_mom_in_region(struct region *b, int nb);
 extern double strain_rate(double ex, double ey, double exy);
 extern double strain_rate_var(double ex, double ey, double exy, double dex, double dey, double dexy, double cxy, double cxxy, double cyxy);

```

> 
> strain\_from\_faults\_new.c
> 
> 
> 

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "gen.h"
#include "eqf.h"

void deal_with_options(int, char **);

int no_faults, n_events;
double sdepth;
double ub = 0.01;
char faultin[25];
FILE *strain1;

int main(int argc, char *argv[]) {
  Point p[MAXN], p1[10];
  struct fault f[MAXF];
  struct regionf b[MAXB];
  double  plat=0.0, plon=0.0, prat=0.0;
  int n=0, i, j, nb=0, np, num, ia, k, l, nrect=0, nfree=0, ix=0, iy=0;
  FILE *faults, *strain0;

  sdepth = DEPTH*1.0e5;
  strcpy(faultin, "fault.in");

  deal_with_options(argc, argv);

  if( (faults = fopen(faultin, "r")) == NULL ) {
     printf("Error: File %s does not exist.\n", faultin);
     exit(-1);
  }
  if( (strain0 = fopen("spline_fit.dat", "r")) == NULL) {
     printf("Error: File spline_fit.dat cannot open\n");
     exit(-1);
  }
  if( (strain1 = fopen("strain_from_faults.dat", "w")) == NULL) {
     printf("Error: File strain_from_faults.dat cannot open\n");
     exit(-1);
  }

  fscanf(strain0, "%d%d%d", &ix, &iy, &num);
  fscanf(strain0, "%d", &nfree);
  fprintf(strain1, "%10d %10d %10d\n", ix, iy, num);
  fprintf(strain1, "%10d\n", nfree);
  for(i=nfree; i<num; i++) {
    if(fscanf(strain0, "%d%lf%lf%lf",  &np, &plat, &plon, &prat) != 4) {
      printf("Error: format error in spline_fit.dat\n");
      exit(1);
     }
     fprintf(strain1, "%10d %10.3f %10.3f %12.6e\n", np, plat, plon, prat);

     }
     fscanf(strain0, "%d", &nrect);
     fprintf(strain1, "%10d\n", nrect);
     close(strain0);

     for(i = 0; i < nrect; i += MAXB) {
       nb = i;
       printf("Working on regions %d to %d ...\n", i, i+MAXB);
       fill_regionf(b, &nb);
       read_clip_faults(faults, f, b, nb);   
     }
     return 0;
 }

 int read_clip_faults(FILE *inf, struct fault *f, struct regionf *b, int nb) {
 int i, j, k, l, ib, jj, kk, ii, n, nf;
 double x, y, dx, dy, d, mt[3][3], c, theta;
 double sd, md, strainrate[9];
 double clip_seg = 0.05;
 struct mom m1;
 struct mom m0;
 struct merr m2;
 struct fault f0;
 Point p[100], p0;

 i=0;
 fseek(inf, 0, SEEK_SET);
 while( (k = fscanf(inf, "%d%lf%lf%lf%lf%lf%s",
        &n, &(f[i].rake), &(f[i].dip), &(f[i].ratemin),
         &(f[i].rate), &(f[i].ratemax), f[i].name)) == 7) {
     printf("Fault no. %d, %s\n", i, f[i].name);

   f[i].rate = f[i].rate;
   f[i].ratemin = f[i].ratemin;
   f[i].ratemax = f[i].ratemax;
   f[i].n = 0;

   for(j=0; j<n; j++) {
     if( (l = fscanf(inf, "%lf%lf", &(p[j].y), &(p[j].x))) != 2) {
       printf("Error at fault %s, line %d in fault.in\n", f[i].name, j);
       exit(1);
     }
   }

   jj=0;
  for(j=0; j<n-1; j++) {
k = 0;
while( k < nb && (l = enclose(b[k].p, 33, p[j])) == 0)
...  

```

Following Mike Kinghan's comments, I added 

```
#ifndef GEN_H
#define GEN_H

```

and 

```
#endif

```

in the head and tail of the gen.h file, respectively. But it not doing well, here are the errors:

```
/tmp/ccteT25z.o: In function `read_clip_faults':
strain_from_faults_new.c:(.text+0x6a4): undefined reference to `enclose'
strain_from_faults_new.c:(.text+0x7c5): undefined reference to `enclose'
strain_from_faults_new.c:(.text+0xa14): undefined reference to `enclose'
strain_from_faults_new.c:(.text+0xa7b): undefined reference to `dsign'
strain_from_faults_new.c:(.text+0xaae): undefined reference to `dsign'
strain_from_faults_new.c:(.text+0xad9): undefined reference to `dsign'
strain_from_faults_new.c:(.text+0xb5a): undefined reference to `dsign'
...

```