#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>

/* struct to hold the lines/columns to/not to print in a for(;;) like
 * structure */

typedef struct fields_ {
  int *from,*to,*inc;
  int num;		/* number of fields allocated */
} fields;

typedef struct cellstr_ {
  int type;		/* BP_Mask means absolute columns */
  long long from, to, inc;	/* object number */
  fields *f;		/* fields of object */
} cellstr;

#define BT_EOL		0
#define BT_Wall		1
#define BT_Ball		2
#define BT_Cylinder	3
#define BT_Disk		4
#define BT_BallCC	5
#define BT_Force	6
#define BT_STBall	7
#define BT_DTEdge	8
#define BT_DGBall	9
#define BT_Ellipsoid	10
#define BT_Arrow	12
#define BT_Cone		13
#define BT_Triangle	14
#define BT_Triangle2	15
#define BT_Tetragon	16
#define BT_Quadratic	17
#define BT_NULL		18

/* body parameter (type 4) */
#define BP_Mask		31
#define BP_Size		0
#define BP_Pos		32
#define BP_Orient	64
#define BP_Coord	128
#define BP_Velo		256
#define BP_Force	512
#define BP_AngVelo	1024
#define BP_Torque	2048
#define BP_TrVelo	4096
#define BP_TrForce	8192
#define BP_TrAngVelo	16384
#define BP_Handle	32768
#define BP_LifeTime	65536
#define BP_MatPar	131072
#define BP_TrCoord	262144
#define BP_TrTorque	524288
#define BP_UpMask	0x1fffe0	/* one more bit is needed!!! */
#define BP_N 16	/* maximum parameter an object can have update! XXX */

int par_typ[BP_N] = { BP_Size, BP_Pos, BP_Orient, BP_Coord, BP_Velo,
  	BP_Force, BP_AngVelo, BP_Torque, BP_TrVelo, BP_TrForce,
	BP_TrAngVelo, BP_Handle, BP_LifeTime, BP_MatPar, BP_TrCoord,
	BP_TrTorque };

#define dble double
#define Buff_Size 65535

#ifndef min
#define min(a,b) (a>b?b:a)
#endif

#ifndef max
#define max(a,b) (a<b?b:a)
#endif

long line_length;	/* length of a line in bytes from header */
long long *start_pos;	/* position of the first line in the stream */
long long line_num;		/* number of lines */
long long line_max;		/* maximal number of lines */
int  file_type;		/* type of datafile currently 4 or 5 */
int long_prec;
char *outfile;
FILE *out;
int  output_type;
int noeol;
int nohead;
int append;
int split;
int formkrep;
size_t startpos;
int increment_time;
int debug;
/* 0-3: col, line, no col, no line */
#define CELLSIZE 100000	/* maximum number of ranges that can be given */
cellstr cells[4][CELLSIZE];
long long cellp[4];		/* pointer to all four of the cellstr */
#define C_COL		0
#define C_LINE		1
#define C_NOCOL		2	/* disabled for type 4 */
#define C_NOLINE	3
#define C_PARAM		4	/* just for ToNumber */

#define Col_type	-2
#define Col_tex		-3
#define Col_grp		-4
#define Col_tc		-5
#define Col_num		-6

/* array for objects */
#define OBJMAX 1000
int obj_typ[OBJMAX];	/* objects type */
int obj_tex[OBJMAX];	/* objects texture */
int *obj_num[OBJMAX];	/* objects number of this type */
long long *obj_pos[OBJMAX];/* their position in the file (obj. head not inc.) */
int obj_size[OBJMAX];	/* size of a single object */
int obj_col[OBJMAX];	/* number of columns that an object has */
int *obj_colt[OBJMAX];	/* type of the columns to be allocated */
			/* BP info included, int:1, double:2 */
int objp;		/* number of object groups */
int obj_timeall;	/* size of num and pos if line_length varies */
int *col_num;		/* size of line  in columns */

#define D_B	0
#define D_I	1
#define D_D	2
int data_size[3];	/* size of thses data types=sizeof(...) */
int dd,ii;

/* print out error message and stop */
void perr(char *format, ...)
{
  va_list arglist;

  va_start(arglist,format);
  vfprintf(stderr,format,arglist);
  fprintf(stderr,"\n");
  va_end(arglist);
  exit(0);
}

/* translate type information */
void Det_Obj_Params(int typ,int *size,int *col,int **colt)
{
  int t,a;

  t=typ&BP_Mask;
  if (t==BT_NULL) *colt=0;
  else *col=1;	/* everything has at least one double size */
  for (a=0;a<BP_N;a++) {
    if (typ&par_typ[a]) *col+=3;
  }
  if (typ&BP_Coord) *col-=2;
  if (typ&BP_Handle) *col-=2;
  if (typ&BP_LifeTime) *col-=2;
  if (typ&BP_TrCoord) *col-=2;
  if (typ&BP_Orient) *col+=1;
  *size=(*col-(((typ&BP_Coord)>0)+((typ&BP_Handle)>0)))*dd+
    		ii*(((typ&BP_Coord)>0)+((typ&BP_Handle)>0));
  if ((t==BT_Wall) || (t==BT_Cylinder) || (t==BT_Arrow)) {
    *col+=1;*size+=dd;
  }
  if ((t==BT_Force) || (t==BT_DTEdge)) {
    *col+=3;*size+=ii*2+dd;
  }
  if (t==BT_BallCC) {
    *col+=1;*size+=ii;
  }
  if ((t==BT_Ellipsoid) || (t==BT_Cone) || (t==BT_Triangle) ||
      (t==BT_Triangle2) || (t==BT_Tetragon) || (t==BT_Quadratic)) {
    *col+=2;*size+=2*dd;
  }
  /* put information in colt */
  (*colt)=(int *)malloc(ii*(*col));
  /* size */
  a=0;
  if (t!=BT_NULL) (*colt)[a++]=D_D;
  if ((t==BT_Ellipsoid) || (t==BT_Cone) || (t==BT_Triangle) ||
      (t==BT_Triangle2) || (t==BT_Tetragon) || (t==BT_Quadratic)) {
    (*colt)[a++]=D_D;
    (*colt)[a++]=D_D;
  }
  if (t==BT_BallCC) (*colt)[a++]=D_I;
  if ((t==BT_Wall) || (t==BT_Cylinder) || (t==BT_Arrow)) {
    (*colt)[a++]=D_D;
  }
  if ((t==BT_Force) || (t==BT_DTEdge)) {
    (*colt)[a++]=D_D;
    (*colt)[a++]=D_I;
    (*colt)[a++]=D_I;
  }
  for (t=0;t<BP_N;t++) {
    if (typ&par_typ[t]) {
      if ((par_typ[t]!=BP_Coord) && (par_typ[t]!=BP_Handle)) {
	(*colt)[a++]=D_D+par_typ[t];
	if ((par_typ[t]!=BP_LifeTime) && (par_typ[t]!=BP_TrCoord)) {
	  (*colt)[a++]=D_D+par_typ[t];
	  (*colt)[a++]=D_D+par_typ[t];
	}
	if (par_typ[t]==BP_Orient) (*colt)[a++]=D_D+par_typ[t];
      } else (*colt)[a++]=D_I+par_typ[t];
    }
  }
  if (a!=*col) perr("Internal error in Det_Obj_Params");
}

/* check outfile is set */
void Outfile(char **para,int np)
{
  int a;

  increment_time=0;
  outfile=NULL;
  for (a=1;a<np;a++) {
    if (strcmp(para[a],"-o")==0) {
      a++;
      outfile=strdup(para[a]);
    } else if (strcmp(para[a],"-it")==0) {
      increment_time=1;
    } else if (strcmp(para[a],"-ro")==0) {
      output_type=1;
    } else if (strcmp(para[a],"-nohead")==0) {
      /* undocumented option to remove header */
      nohead=1;
    } else if (strcmp(para[a],"-a")==0) {
      append=1;
    }
  }
}

/* check if line_max is set */
int Line_Max(char **para,int np)
{
  int a,rv;

  rv=(np==2);
  line_max=-1;
  for (a=1;a<np;a++) {
    if (strcmp(para[a],"-lm")==0) {
      a++;line_max=atoi(para[a]);
    } else if (strcmp(para[a],"-sp")==0) {
      startpos=atoi(para[++a]);
    } else if (strcmp(para[a],"-d")==0) {
      debug=1;
      rv=(np==3);
    }
  }
  return(rv);
}

/* analyze line: determine positions and type of each column */
void Analyze_Line(FILE *in,int mode,size_t startpos)
{
  int typ,tex,num,t,op,goon;
  double time,timen;

  if (line_length>0) {
    obj_timeall=1;
  } else {
    obj_timeall=100000;
  }
  col_num=(int *) malloc(ii*obj_timeall);
  start_pos=(long long *) malloc(sizeof(long long)*obj_timeall);
  col_num[0]=1;
  objp=0;
  /* skip time */
  if (startpos) start_pos[0]=startpos;
  else start_pos[0]=ftell(in);
  fseek(in,start_pos[0],SEEK_SET);
  fread(&time,dd,1,in);
  do {
    fread(&typ,ii,1,in);
    if (debug) printf("type %d (pos: %d)\n",typ,ftell(in));
    /* typ=0 at the end of the line */
    if ((typ>0) && (objp<OBJMAX)) {
      obj_num[objp]=(int *) malloc(ii*obj_timeall);
      obj_pos[objp]=(long long *) malloc(sizeof(long long)*obj_timeall);
      /* skip texture */
      if (file_type==4) tex=fgetc(in);
      else fread(&tex,ii,1,in);
      if (debug) printf("tex %x\n",tex);
      fread(&num,ii,1,in);
      if (debug) printf("num %d\n",num);
      obj_typ[objp]=typ;
      obj_tex[objp]=tex;
      obj_num[objp][0]=num;
      obj_pos[objp][0]=ftell(in);
      Det_Obj_Params(typ,&obj_size[objp],&obj_col[objp],&obj_colt[objp]);
      col_num[0]+=obj_col[objp]*num+3;
      if (debug) printf("seek %d = %d * %d\n",num*obj_size[objp],num,\
	  obj_size[objp]);
      fseek(in,num*obj_size[objp],SEEK_CUR);
      objp++;
    } else if (objp>=OBJMAX) perr("too many objects (>%d)",OBJMAX);
  } while (typ>0);
  if (mode) return;
  data_size[0]=1;
  data_size[1]=ii;
  data_size[2]=dd;
  if (line_length<=0) {
    /* line_length is not fixed */
    t=1;	/* time */
    goon=1;
    do {
      if ((line_max>0) && (t>line_max)) break;
      col_num[t]=1;
      start_pos[t]=ftell(in);
      fread(&timen,dd,1,in);
      if ((increment_time) && (timen<time)) break;
      time=timen;
      if (feof(in)) break;
      op=0;
      do {
	fread(&typ,ii,1,in);
	if (typ==0) t++;
	if (feof(in)) break;
	/* typ=0 at the end of the line */
	if ((typ>0) && (op<objp)) {
	  /* skip texture */
	  if (file_type==4) fgetc(in);
	  else fread(&num,ii,1,in);
	  fread(&num,ii,1,in);
	  while ((op<objp) && (obj_typ[op]!=typ)) {
	    obj_num[op][t]=0;
	    op++;
	  }
	  if (op==objp) {
	    fprintf(stderr,"wrong file structure at %d\n",t);
	    goon=0;
	    typ=0;
	    t--;
	    break;
	  }
	  obj_num[op][t]=num;
	  obj_pos[op][t]=ftell(in);
	  col_num[t]+=obj_col[op]*num+3;
	  fseek(in,num*obj_size[op],SEEK_CUR);
	  op++;
	} else if (typ>0)
	  perr("Cannot have new objects in time! %d",start_pos[t]);
      } while (typ>0);
      if (t>=obj_timeall) {
	obj_timeall*=2;
	obj_num[objp]=realloc(obj_num[objp],ii*obj_timeall);
	obj_pos[objp]=realloc(obj_pos[objp],ii*obj_timeall);
	col_num=realloc(col_num,ii*obj_timeall);
	start_pos=realloc(start_pos,sizeof(long long)*obj_timeall);
      }
    } while ((!feof(in)) && (goon));
    line_num=t-1;
  } else {
    fseek(in,0L,SEEK_END);
    line_num=(ftell(in)-start_pos[0])/line_length-1;
  }
}

void Print_File_Info(void)
{
  const char *obj_name[]= { "EOL(0)", "Wall(1)", "Ball(2)", "Cylinder(3)",
    			    "Disk(4)", "BallCC(5)", "Force(6)",
			    "STBall(7)", "DTEdge(8)", "DGBall(9)",
  			    "Ellipsoid(10)", "", "Arrow(12)", "Cone(13)",
  			    "Triangle(14)", "Triangle2(15)", 
			    "Tetragon(16)", "Quadratic(17)", "NULL(18)" };
  const char *par_name[]= { "Pos(x,y,z)", "Orient(rx,ry,rz,phi)",
    			    "Coord(Z)", "Velo(vx,vy,vz)",
			    "Force(fx,fy,fz)", "AngVelo(omx,omy,omz)",
			    "Torque(tx,ty,tz)", "TrVelo(tvx,tvy,tvz)",
			    "TrForce(tfx,tfy,tfz)",
			    "TrAngVelo(tox,toy,toz)",
  			    "Handle(hand)", "Lifetime(life)",
  			    "MatPar(mu,im,iI)", "TrCoord(tZ)",
			    "TrTorque(ttx,tty,ttz)" };
  int a,b;

  for (a=0;a<objp;a++) {
    printf("%d %s %d\n",a+1,
	obj_name[obj_typ[a]&BP_Mask],obj_num[a][0]);
    for (b=0;b<BP_N;b++) {
      if (obj_typ[a]&par_typ[b]) {
	printf("\t%s\n",par_name[b-1]);
      }
    }
  }
  exit(0);
}

/* convert a string to number +sign in front of number means from the
 * end */
long long ToNumber(char *s,int c)
{
  int a,b,number,end;
  static char params[BP_N][4][5] = { { "dx", "dy", "dz", "i2" },
  				     { "x", "y", "z", "" },
    				     { "rx", "ry", "rz", "phi" },
				     { "Z", "", "", "" },
				     { "vx", "vy", "vz", "" },
				     { "fx", "fy", "fz", "" },
				     { "omx", "omy", "omz", "" },
				     { "tx", "ty", "tz", "" },
				     { "tvx", "tvy", "tvz", "" },
				     { "tfx", "tfy", "tfz", "" },
				     { "tox", "toy", "toz", "" },
  				     { "hand", "", "", "" },
  				     { "life", "", "", "" },
  				     { "mu", "im", "iI", "" },
  				     { "tZ", "", "", "" },
				     { "ttx", "tty", "ttz", "" }};

  end=1;
  if (*s=='+') {
    end= -1;s++;
  }
  if ((c!=C_PARAM) || (isdigit(s[0]))) {
    if ((c==C_LINE) || (c==C_NOLINE)) {
      if (end==1) number=atoi(s);
      else number=line_num-atoi(s);
    } else if ((c==C_COL) && (!isdigit(s[0])) && (s[0]!='\0')) {
      if (strcmp(s,"type")==0) number=Col_type;
      if (strcmp(s,"tex")==0) number=Col_tex;
      if (strcmp(s,"grp")==0) number=Col_grp;
      if (strcmp(s,"tc")==0) number=Col_tc;
      if (strcmp(s,"num")==0) number=Col_num;
    } else {
      number=(atoi(s)+(end==-1))*end;
    }
  } else { /* C_PARAM and string */
    number=0;
    if (end<0) return(par_typ[BP_N-1]*2);
    for (a=0;a<BP_N;a++) {
      for (b=0;b<4;b++) {
	if (strlen(params[a][b])==0) break;
	if (strcmp(params[a][b],s)==0) number=b+par_typ[a];
      }
      if ((a==0) && (strcmp(s,"i1")==0)) number=2;
    }
  }
  return(number);
}

/* determine reange from a `from-to.inc' structure except from `from'
 * other fields may be missing */
void Range(char *s,int c,long long *from,long long *to,long long *inc)
{
  int end;
  char *sp,*spp;

  *inc=1;
  if (strlen(s)==0) {
    *from=0;
    *to=ToNumber("+",c);
    return;
  }
  sp=s;
  end=0;
  spp=strchr(sp,'-');
  if (spp==NULL) {
    spp=sp+strlen(sp);
    end=1;
  }
  *spp='\0'; *from=ToNumber(sp,c);
  if (!end) {
    /* we have `*to' field */
    *spp='-';
    sp=spp+1;
    spp=strchr(sp,'.');
    if (spp==NULL) {
      spp=sp+strlen(sp);
      end=1;
    }
    *spp='\0';
    if (*sp=='\0') *to=ToNumber("+",c);
    else *to=ToNumber(sp,c);
    if (!end) {
      /* we have `*inc' field */
      *spp='.';
      spp++;
      *inc=ToNumber(spp,c);
    }
  } else *to=*from;
}

/* understand cmd line options */
void Translate_para(char **para,int np)
{
  int a,c,type,b;
  int parp;
  long long from,to,inc;
  char *sp,*spnum,*sppar,ures[10];
  fields *f;

  c=0;
  for (a=2;a<np;a++) {
    if (strcmp(para[a],"-o")==0) {
      a++;
    } else if (strcmp(para[a],"-it")==0) {
    } else if (strcmp(para[a],"-ro")==0) {
    } else if (strcmp(para[a],"-noeol")==0) {
      /* undocumented option to remove eol */
      noeol=1;
    } else if (strcmp(para[a],"-m")==0) {
      formkrep=1;
    } else if (strcmp(para[a],"-s")==0) {
      split=1;
    } else if (strcmp(para[a],"-p")==0) {
      long_prec=atoi(para[++a]);
    } else if (strcmp(para[a],"-c")==0) {
      c=0;
    } else if (strcmp(para[a],"-l")==0) {
      c=1;
    } else if (strcmp(para[a],"-nl")==0) {
      c=3;
    } else if (strcmp(para[a],"-sp")==0) {
      a++;
    } else if (strcmp(para[a],"-lm")==0) {
      a++;
    } else if (strcmp(para[a],"-d")==0) {
      debug=1;
    } else {
      if (cellp[c]>CELLSIZE) {
	perr("Insufficient CELLSIZE (%d)\n",CELLSIZE);
	return;
      }
      if (para[a][0]=='%') {
	/* object */
	c=0;
	parp=0;
	ures[0]='\0';
	spnum=sppar=ures;
	sp=&para[a][1];
	/* object determination %a%b%c 
	 * `a': object type (number)
	 * `b': object num (range)
	 * `c': object param (range) */
	if ((*sp)=='g') {
	  sp++;
	  type=-atoi(sp);
	} else {
	  type=atoi(sp);
	}
	if (*sp!='%') sp=strchr(sp,'%');
	if (sp!=NULL) {
	  sp++;spnum=sp;
	  if (*sp!='%') sp=strchr(sp,'%');
	  if (sp!=NULL) {
	    *sp='\0';
	    sp++;sppar=sp;
	    /* count the number of fields */
	    b=1;
	    while (*sp) {
	      if (*sp==',') b++;
	      sp++;
	    }
	  } else sppar=NULL;
	} else spnum=sppar=NULL;
	/* allocate memory for the field struct */
	f=(fields *)malloc(sizeof(fields));
	f->from=(int *)malloc(b*ii);
	f->to=(int *)malloc(b*ii);
	f->inc=(int *)malloc(b*ii);
	f->num=0;
	/* fill the fields */
	sppar=strtok(sppar,",");
	if (sppar==NULL) sppar=ures;
	while (sppar) {
	  Range(sppar,C_PARAM,&from,&to,&inc);
	  f->from[f->num]=from;
	  f->to[f->num]=to;
	  f->inc[f->num]=inc;
	  f->num++;
	  sppar=strtok(NULL,",");
	}
	/* get object number */
	spnum=strtok(spnum,",");
	if (spnum==NULL) spnum=ures;
	while (spnum) {
	  Range(spnum,C_COL,&from,&to,&inc);
	  cells[c][cellp[c]].from=from;
	  cells[c][cellp[c]].to=to;
	  cells[c][cellp[c]].inc=inc;
	  cells[c][cellp[c]].f=f;
	  cells[c][cellp[c]].type=type;
	  cellp[c]++;
	  spnum=strtok(NULL,",");
	}
      } else {
	/* not an object */
	sp=para[a];
	sp=strtok(sp,",");
	while (sp) {
	  Range(sp,c,&from,&to,&inc);
	  cells[c][cellp[c]].type=BP_Mask;
	  cells[c][cellp[c]].from=from;
	  cells[c][cellp[c]].to=to;
	  cells[c][cellp[c]].inc=inc;
	  cellp[c]++;
	  sp=strtok(NULL,",");
	}
      }
    }
  }
}

/* and line ranges are checked with a for cycle nl arguments checked
 * for every available field, not too slow, but any better idea?
 * XXX */
int Not_In(long long l,int c)
{
  int a,rv;

  rv=1;
  for (a=0;a<cellp[c];a++) {
    if ((l>=cells[c][a].from) && (l<=cells[c][a].to) &&
	((l-cells[c][a].from)%cells[c][a].inc==0)) {
      return(0);
    }
  }
  return(1);
}

/* find file position of column c at time t */
long long Find_Col(int t,int c,long long *dt)
{
  long long pos,a,b,p;

  pos=start_pos[t];
  /* well it's time, easy job */
  *dt=D_D;
  if (c==0) return(pos);
  /* Skip time from loop */
  c--;pos+=dd;
  *dt=D_I;
  p=0;			/* local object pointer */
  while ((c>0) && (p<objp)) {
    c--;pos+=ii;	/* type (int) */
    *dt=D_I;
    if (c==0) break;
    c--;pos+=ii;		/* texture (byte) */
    *dt=D_I;
    if (c==0) break;
    c--;pos+=ii;	/* number of objects (int) */
    if (c<obj_num[p][t]*obj_col[p]) {
      /* c is whithin this object */
      a=c/obj_col[p];	/* a holds the index of the object c is in */
      c-=a*obj_col[p];
      pos+=a*obj_size[p];
      b=0;
      *dt=obj_colt[p][b]&BP_Mask;
      while (c>0) {
	c--;
	b++;
	pos+=data_size[*dt];
	*dt=obj_colt[p][b]&BP_Mask;
      }
      return(pos);
    }
    c-=obj_num[p][t]*obj_col[p];
    pos+=obj_num[p][t]*obj_size[p];
    p++;
  }
  if (p<objp) return(pos);
  else return(-1);
}

long long Get_Pos(int col,int op,int ft)
{
  long long a,c,t;

  t=obj_typ[op]&BP_Mask;
  if (col<BP_Mask) {
    /* size parameter */
    /* these bellow have only one parameter */
/*    if (((t==BT_Wall) || (t==BT_Disk) || (t==BT_STBall)) && (col>0)) {
      return(-1);
    }*/
    /* the rest has two except for BT_Force and BT_DTEdge */
/*    if ((col>1) && (t!=BT_Force) && (t!=BT_DTEdge)) return(-1);*/
    /* BT_Force has four parameters */
/*    if (col>3) return(-1);*/
    return(col);
  } else {
    /* optional parameter */
    c=col&BP_UpMask;
    if (ft) {
      for (a=0;a<obj_col[op];a++) {
	if (c<=(obj_colt[op][a]&BP_UpMask)) break;
      }
      if ((a==obj_col[op]) || (c<(obj_colt[op][a]&BP_UpMask))) a--;
    } else {
      for (a=obj_col[op]-1;a>=0;a--) {
	if (c>=(obj_colt[op][a]&BP_UpMask)) {
	  do {
	    a--;
	  } while ((a>=0) && (c==(obj_colt[op][a]&BP_UpMask)));
	  a++;
	  break;
	}
      }
      if ((a==-1) || (c>(obj_colt[op][a]&BP_UpMask))) a++;
    }
    /* parameter groups contain more columns */
    if (a<obj_col[op]-1) a+=(col&BP_Mask);
    if (a>=obj_col[op]) return(-1);	/* not that many column */
    return(a);
  }
}

void Print_ptr(void *ptr,int dt,FILE *out)
{
  if (output_type) {
    switch (dt) {
      case D_D:
	fwrite(ptr,dd,1,out);
	break;
      case D_I:
	fwrite(ptr,ii,1,out);
	break;
      case D_B:
	fwrite(ptr,sizeof(char),1,out);
	break;
    }
  } else {
    if (formkrep) {
      switch (dt) {
	case D_D:
	  fprintf(out,"%.*le ",long_prec,*((double *)ptr));
	  break;
	case D_I:
	  fprintf(out,"i %u ",*((int *)ptr));
	  break;
	case D_B:
	  fprintf(out,"%d ",*((char *)ptr));
	  break;
      }
    } else {
      switch (dt) {
	case D_D:
	  fprintf(out,"%.*le ",long_prec,*((double *)ptr));
	  break;
	case D_I:
	  fprintf(out,"%u ",*((int *)ptr));
	  break;
	case D_B:
	  fprintf(out,"%d ",*((char *)ptr));
	  break;
      }
    }
  }
}

/* print data according to determined options */
void Print_Data(FILE *in)
{
  long long a,b,l,c,t,dt,d,e,f,g,po;
  long long from,to,inc,cto,mm;
  long long lp,fp,ir;
  void *ptr;

  if (cellp[C_LINE]==0) {
    /* no column is specified, then print all */
    cells[C_LINE][0].from=0;
    cells[C_LINE][0].to=line_num;
    cells[C_LINE][0].inc=1;
    cellp[C_LINE]=1;
  }
  if (cellp[C_COL]==0) {
    /* no column is specified, then print only time */
    cells[C_COL][0].from=0;
    cells[C_COL][0].to=0;
    cells[C_COL][0].inc=1;
    cellp[C_COL]=1;
  }
  ptr=(void *)malloc(Buff_Size);	/* XXX carefull with this */
  for (a=0;a<cellp[C_LINE];a++) {
    /* line ranges */
    for (l=cells[C_LINE][a].from; l<=min(cells[C_LINE][a].to,line_num);
	 l+=cells[C_LINE][a].inc) {
      if (Not_In(l,C_NOLINE)) {
	/* go to start of the line */
	if (line_length<=0) {
	  lp=start_pos[l];t=l;
	} else {
	  lp=start_pos[0]+l*line_length;t=0;
	}
	if (output_type) {
	  if (line_length<=0) {
	    if (l+1>=line_num) {
	      fseek(in,0,SEEK_END);
	      fp=ftell(in);
	    } else {
	      fp=start_pos[l+1];
	    }
	  } else {
	    fp=start_pos[0]+(l+1)*line_length;
	  }
	  if (nohead) lp+=sizeof(double);
	  fseek(in,lp,SEEK_SET);
	  fp-=lp; /* length */
	  if (noeol) fp-=sizeof(int);
	  while (fp>0) {
	    ir=fread(ptr,1,min(Buff_Size,fp),in);
	    fwrite(ptr,1,ir,out);
	    fp-=ir;
	  }
	} else {
	  /* columns */
	  for (b=0;b<cellp[C_COL];b++) {
	    cto=cells[C_COL][b].to;
	    if (cto<0) {
	      switch (cells[C_COL][b].type) {
		case BP_Mask:	/* absolute column */
		  cto=col_num[t]+1-cto;
		  break;
		case 0:		/* all objects */
		  mm=0;
		  for (d=0;d<objp;d++) {
		    if (mm<obj_num[d][t]) mm=obj_num[d][t];
		  }
		  cto=mm+1-cto;
		  break;
		default:
		  if (cto<-1) {
		    d=-1-cells[C_COL][b].type;
		    switch (cto) {
		      case Col_type:
			Print_ptr(&obj_typ[d],D_I,out);
			break;
		      case Col_tex:
			e=obj_tex[d]&BP_Mask;
			Print_ptr(&e,D_I,out);
			break;
		      case Col_grp:
			Print_ptr(&d,D_I,out);
			break;
		      case Col_tc:
			Print_ptr(&obj_tex[d],D_I,out);
			break;
		      case Col_num:
			Print_ptr(&obj_num[d][t],D_I,out);
			break;
		    }
		    if (split) fprintf(out,"\n");
		    cto--;
		  } else {
		    for (d=0;d<objp;d++) {
		      if ((cells[C_COL][b].type==(obj_typ[d]&BP_Mask)) ||
			  ((cells[C_COL][b].type<0) &&
			   (-1-cells[C_COL][b].type==d))) {
			cto=obj_num[d][t]+1-cto;
		      }
		    }
		  }
		break;
	      }
	    }
	    for (c=cells[C_COL][b].from; c<=cto;
		 c+=cells[C_COL][b].inc) {
	      /* go to pos */
	      if (cells[C_COL][b].type==BP_Mask) {
		/* absolute column */
		fp=Find_Col(t,c,&dt);
		if (fp>0) {
		  fseek(in,fp,SEEK_SET);
		  fread(ptr,data_size[dt],1,in);
		  Print_ptr(ptr,dt,out);
		  if (split) fprintf(out,"\n");
		}
	      } else {
		/* object */
		for (d=0;d<objp;d++) 
		if ((cells[C_COL][b].type==0) ||
		    (cells[C_COL][b].type==(obj_typ[d]&BP_Mask)) ||
		    ((cells[C_COL][b].type<0) &&
		     (-1-cells[C_COL][b].type==d))) {
		  po=0;
		  for (e=0;e<cells[C_COL][b].f->num;e++) {
		    from=Get_Pos(cells[C_COL][b].f->from[e],d,0);
		    to=Get_Pos(cells[C_COL][b].f->to[e],d,1);
		    inc=cells[C_COL][b].f->inc[e];
		    if ((from>=0) && (to>=from) && (c<obj_num[d][t])) {
		      fp=obj_pos[d][t]+c*obj_size[d];
		      for (f=0;f<from;f++) {
			fp+=data_size[obj_colt[d][f]&BP_Mask];
		      }
		      for (f=from;f<=to;f+=inc) {
			dt=data_size[obj_colt[d][f]&BP_Mask];
			fseek(in,fp,SEEK_SET);
			fread(ptr,dt,1,in);
			Print_ptr(ptr,obj_colt[d][f]&BP_Mask,out);
			po=1;
			for (g=0;g<inc;g++) {
			  fp+=data_size[obj_colt[d][f+g]&BP_Mask];
			}
		      }
		    }
		  }
		  if ((po) && (split)) fprintf(out,"\n");
		}
	      }
	    }
	  }
	  if (!split) fprintf(out,"\n");
	}
      }
    }
  }
  if (outfile) fclose(out);
  free(ptr);
}

int main(np,para)
char *para[];
{
  int a,list;
  FILE *in;
  char s[100];

  if (np<2) {
    fprintf(stderr,"usage: getcol4 input [-p prec] [-lm num] [-s] [-ro] ... ");
    fprintf(stderr,"[-c] ... [-l] ... [-nl] ...\n");
    fprintf(stderr,"\t-o outfile = print output to file\n");
    fprintf(stderr,"\t-lm num = max number of lines to be read.\n");
    fprintf(stderr,"\t-it = time must increase. ");
    fprintf(stderr,"Good for broken files!\n");
    fprintf(stderr,"\t-ro = binary report output. Normal output is text.\n");
    fprintf(stderr,"\t... = number or %%type%%num%%par   type:\n");
    fprintf(stderr,"\t1 Wall  \t2 Ball  \t3 Cylinder\n");
    fprintf(stderr,"\t4 Disk  \t5 BallCC\t6 Force\n");
    fprintf(stderr,"\t7 STBall\t8 DTEdge\t9 DGBall\n");
    fprintf(stderr,"\t10 Ellipsoid\t12 Arrow\t13 Cone\n");
    fprintf(stderr,"\t14 Triangle 15 Triangle2 16 Tetragon\n");
    fprintf(stderr,"\t17 Quadratic 18 NULL\n");
    fprintf(stderr,"\n\tnum can be: type, tes, grp, tc, num\n");
    exit(0);
  }
  /* Open file */
  in=fopen(para[1],"rb");
  if (in==NULL) perr("input file (%s) cannot be open",para[1]);
  /* Header */
  file_type=0;
  output_type=0;
  long_prec=10;
  noeol=0;
  nohead=0;
  append=0;
  split=0;
  startpos=0;
  formkrep=0;
  debug=0;
  Outfile(para,np);
  if (outfile) {
    if (!append) {
      if ((out=fopen(outfile,"r"))) {
	fclose(out);
	perr("output file exists");
      }
      out=fopen(outfile,"wb");
    } else {
      out=fopen(outfile,"ab");
    }
  } else out=stdout;
  do {
    fgets(s,7,in);
    if ((output_type) && (!nohead)) fputs(s,out);
    if (feof(in)) perr("Premature end of file or wrong file type");
    if (strcmp(s,"#type ")==0) {
      /* type */
      fscanf(in,"%d %d %d %ld", &file_type,&ii,&dd,&line_length);
      if ((output_type) && (!nohead))
	fprintf(out,"%d %d %d %ld", file_type,ii,dd,line_length);
      if ((file_type!=4) && (file_type!=6))
		perr("This code is for type 4 or 6 datafiles");
      if (ii!=sizeof(int)) perr("Size of int does not match");
      if (dd!=sizeof(double)) perr("Size of double does not match");
    }
  } while ((s[0]!='#') || (s[1]!='\n'));
  list=Line_Max(para,np);
  Analyze_Line(in,list,startpos);
  if (list) Print_File_Info();
  for (a=0;a<4;a++) {
    cellp[a]=0;
  }
  Translate_para(para,np);
  Print_Data(in);
  fclose(in);
  return(0);
}