File lesen mit read -->dann wird file gelöscht

[zipwoo]

hallo leute!

habe bisher nicht allzuviel erfahrung in c/c++ und möchte einen scanner für einen compiler schreiben. leider löscht mein scanner immer mein zu scannedes file.
der code für den scanner ist in c geschrieben und wird mit c++ compiler compiliert.

der code ist leider etwas lange aber wenn ich was auslasse kennt man sich vielleicht nicht aus

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>

int NO_BLOCKS_MORE=0, ERROR=-1, FILE_END=3;
int BLOCKSIZE=64;

struct charReader {
 char buffer[64];
 char actuelSym;
 int fh;
 int charsIn;
 int pos;
 int row;
 int column;
};
struct charReader reader;
struct charReader lhReader; //lookahead Reader

/*TOKENS*/ 

int tabulator=9;
int newline=10;
int space=32;

int assOp=0; //=
int notOp=1; //!
int addOp =2; //+
int diffOp= 3; //-
int multOp= 4; //*
int divOp= 5;// /
int ifSym = 6; //if
int whileSym=7; //while
int voidSym =8; //void
int intSym =9; //int
int charSym=10; //char
int elseSym=11; //else
int returnSym = 12;//return
int adrOp=13; //&
int externSym=14; //extern
int structSym=15; //struct
int andOp =16;//&&
int orOp=17; //||

int eqOp=18; //==
int modOp=19; //%
int greaterOp=20;//>
int lessOp=21; //<
int greaterEqOp=22; //>=
int lessEqOp=23; //<=
int notEqOp =24; //!=

//klammern
int leftBr=25; //(
int rightBr=26; //)
int lSetBr=27; //{
int rSetBr=28; //}
int lCornerBr=29; //[
int rCornerBr=30; //]
int semikolon=31; //;
int comma=32;//,
int highComma33; //'

struct Token {
 int line,colum;
 int sym;
 int value;
};

/*liest nachsten Block des Files (BLOCKSIZE) in den char array buffer*/
int readNextBlock(){
reader.charsIn=read(reader.fh,reader.buffer,BLOCKSIZE);
reader.pos=0;
if(reader.charsIn==0) return NO_BLOCKS_MORE;
if(reader.charsIn==-1) return ERROR;
}

/*liefert nächstes char eines Files wenn verwendeter Buffer gelesen wird Methode
* readNextBlock aufgerufen um nachsten Block aus File zu lesen
* Wenn Buffer zu Ende gelesen und keine weiteren Blöcke vorhanden -->FILE_END */
void getNextSym(){
 if(reader.pos==reader.charsIn){
  int readNext=readNextBlock();
  if(readNext==NO_BLOCKS_MORE){
   reader.actuelSym= FILE_END; //TODO return FILE_END
  // return;
  }
  if(readNext==ERROR){
   reader.actuelSym =ERROR;
  // return;
 }
 }

 if(reader.actuelSym!=FILE_END && reader.actuelSym!=ERROR){

 reader.actuelSym= reader.buffer[reader.pos];
 reader.pos++;
 reader.column++;
 }

}

//lookahead
/*liest nachsten Block des Files (BLOCKSIZE) in den char array buffer*/
int readNextBlock2(){
lhReader.charsIn=read(lhReader.fh,lhReader.buffer,BLOCKSIZE);
lhReader.pos=0;
if(lhReader.charsIn==0) return NO_BLOCKS_MORE;
if(lhReader.charsIn==-1) return ERROR;
}

/*liefert nächstes char eines Files wenn verwendeter Buffer gelesen wird Methode
* readNextBlock aufgerufen um nachsten Block aus File zu lesen
* Wenn Buffer zu Ende gelesen und keine weiteren Blöcke vorhanden -->FILE_END */
void getNextSym2(){
 if(lhReader.pos==lhReader.charsIn){
  int readNext2=readNextBlock2();
  if(readNext2==NO_BLOCKS_MORE){
   lhReader.actuelSym= FILE_END; //TODO return FILE_END
  // return;
  }
  if(readNext2==ERROR){
   lhReader.actuelSym =ERROR;
  // return;
 }
 }

 if(lhReader.actuelSym!=FILE_END && lhReader.actuelSym!=ERROR){

 lhReader.actuelSym= lhReader.buffer[lhReader.pos];
 lhReader.pos++;

 }

}
//END lookahead

int isDigit(char sym){
 if(sym>='0' && sym <='9'){
 return 1;
 }
 else return 0;
}

int isLetter(char sym){
 if((sym>='a' && sym <='z') || (sym>='A' && sym <='Z')){
 return 1;
 }
 else return 0;
}

int isIgnoreToken(char sym){
 if(sym==newline){
 reader.row++;
 reader.column=0;
 return 1;
 }
 if(sym==tabulator||sym==space){
 return 1;
 }
 else return 0;

}

int number(){
 int sym;
 int val=0;

 val= reader.actuelSym -'0';
 while(isDigit(lookAhead())){ //LookAHead
 val= 10*val +reader.actuelSym -'0';
 }

 return val;
}

struct Token getNextToken(){
}

void testIT(){
}

void writeToLogFile(){
}

int main() {

 reader.charsIn=0;
 reader.column=0;
 reader.pos=0;
 reader.row=0;

 lhReader.charsIn=0;
 lhReader.pos=0;

 printf("fh: %d\n",reader.fh);

 //int fhWrite= open("test.txt","rw");
 //write(fhWrite,"ddddfgd",4); 

 char fileN[]="scanner.c";
 //init(fileN);
 int more=1;
 reader.fh=open(fileN,'r');
 lhReader.fh=open(fileN,'r');//lookaheda

 printf("fh: %d\n",reader.fh);

 if(reader.fh==NO_BLOCKS_MORE) printf("FILE empty");
 if(reader.fh==ERROR) printf("ERROR");

 printf("[%d,%d]", reader.row,reader.column);
 printf("__");
 getNextSym2();
 while(more && reader.fh!=ERROR){

  //actuelChar=getNextSym();
  getNextSym(); 
  getNextSym2();
  //charsIn=read(fh,buffer,64);

  //printf("[%d,%d]", row,column);

  if(reader.actuelSym==FILE_END ){
  more=0;
  printf("__________________________FILE_END___________");
  }
  /*else if(isIgnoreToken(actuelSym)){
  printf("%c",actuelSym);
  }
  else if(isDigit(actuelSym)){
  //printf("%d ",number());
  printf("%c",actuelSym);
  }*/
  else if(1){
  printf("%c",reader.actuelSym);//putchar(ne);
  printf("%c",lhReader.actuelSym);//putchar(ne);
  //printf("%c",lookAhead());//putchar(ne);
  //lookAhead();
  }
  //write(buffer,charsIn);
  //printf("\n");
  //printf("in= %d\n",charsIn);
  //if(charsIn==0)more =0;

 } 
 close(reader.fh);
 close(lhReader.fh);

 return 0;
}

vielen Dank
zippwoo

[GPC]

ähem, jo, also wenn du jetzt noch [cpp ][/cpp ] Tags (ohne die Leerzeichen) um den Code bastelst, dann liest es sich vllt. einer durch...

MfG

GPC

[CStoll]

Kannst du das Problem mal etwas eingrenzen? Tritt es noch auf, wenn du die Datei nur öffnest und wieder schließt?

PS: Bitte pack deinen Quelltext in cpp-Tags, das erleichtert anderen die Fehlersuche etwas.

[zipwoo]

danke erstmal für die schnelle antwort
hatte gestern schon einige male diesen fehler, da kam der fehler wenn ich nur eine kleinigkeit im code änderte, zB: irgendwo ein printf("bla"); hinzugefügte, was ja schon eigenartig ist.
doch jetzt tritt der fehler immer auf, wenn das file geöffnet und gelesen wird.