Reading a file

[muser]

The following program reads two lines of a file in my A drive and
reads no more.
Can some sarmartian tell me why that is. Please copy and paste the
program into your own compiler please.

program is this.

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstring>
#include <cstdlib>
using namespace std;

struct crecord {
long customercode[5];
char customername[21];
char customeraddress[61];
double customerbalance ;
double creditlimit;
};

struct irrecord {
long customercode[5];
long partnum[5];
long issue_rec;
};

struct drecord {
long customercode;
};
////////////////////////////////////////////////////////////
bool IRRecordvalidle ngth(char* record)
{
int len;

switch(record[0])
{
case'i':
case'I':
case'r':
case'R':

len= strlen(record);
if(len<17)
return false;
break;
}

return true;
};
////////////////////////////////////////////////////////////
bool CRecordvalidlen gth(char* cstring)
{
int len;

switch(cstring[0])
{
case'c':
case'C':

len = strlen(cstring) ;
if(len<103)
return false;
break;

}
return true;

}
////////////////////////////////////////////////////////
bool Drecordvalidlen gth(char* record)
{
int len;

switch(record[0])
{
case'd':
case'D':

len = strlen(record);
if(len<7)
return false;
break;

}

return true;
}
//////////////////////////////////////////////////////////
bool CheckAllNumeric ( const char * string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string[i] ) )
return false;

return true;
}

////////////////////////////////////////////////////////////////
bool CheckFloatNumbe r( const char* string )
{
int Len = strlen( string );

for( int i = 0; i < Len; ++i )
if( !isdigit( string[i] ) &&
string[i] != '.' )
return false;

return true;
}

///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

crecord Newcrecord;
bool CheckAddress( char* alpha )
{

int max_alpha = 60;

for( int i = 0; i < max_alpha; ++i )
if( !isalpha( alpha[i] ) && ( alpha[i] != ';;;;' ) && ( alpha[i] !=
' ' ))
if(Newcrecord.c ustomeraddress[61] != (alpha[i]))
return false;

return true;
}
///////////////////////////////////////////////////////////////////////////////
bool CheckAddressN( char* record )
{

char* AN[4];
char* BAN;

strncpy(AN[4], &record[27], 4);
AN[4] = '\0';
for(int i=0; i < 4; i++)

if(AN[i] = " ") // check that last character is a number and the
next character
{
//is a char.
BAN = (AN[i] + 1 ) ;
if(!isalpha(BAN[i])){}

}
return false;

if(AN[i] = " ") // check that last character is a number and the
next character
{
//is a char.
BAN = (AN[i] - 1);
if(!isdigit(BAN[i])){};

}
return false;
if(AN[i] = ";")
{

BAN = (AN[i] - 1);

if(!isdigit(BAN[i])){};
}
return false;

if(AN[i] = ";")
{
BAN = (AN[i] + 1);

if(!isalpha(BAN[i])){};

}
return false;

if(AN[i] = ";")
{
BAN = (AN[i] + 1);

for(int i=0; i < 17; i++)
if(!isalpha(BAN[i]))
return false;
}

return true;

}



////////////////////////////////////////////////////////////////

bool Processcrecord( ofstream& prnfile, ofstream& validdata, char*
record )
{
char customercode[6];
char balance[10];
char limit[10];
char Addresscheck[4];

crecord Newcrecord;

//
// process the customer code
//
strncpy( customercode, &record[1], 5 );
customercode[5] = '\0';
if( !CheckAllNumeri c( customercode ) ) {
prnfile << "Invalid: customer code needs to be all numeric
[position 3 - 5 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.cust omercode[5] = atol( customercode );

//
// process the customer name
//
strncpy( Newcrecord.cust omername, &record[7], 20 );
Newcrecord.cust omername[20] = '\0';

//
// process the customer address
//
strncpy( Newcrecord.cust omeraddress, &record[27], 60 );
Newcrecord.cust omeraddress[60] = '\0';

if(!CheckAddres sN(Addresscheck ))
return false;

//
// process the customer balance
//
strncpy( balance, &record[87], 9 );
balance[9] = '\0';
if( !CheckFloatNumb er( balance ) ) {
prnfile << "Invalid: balance field is not a valid number [position
88 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.cust omerbalance = atof( balance );

validdata.write ((char*) record, Newcrecord.cust omerbalance );

//
// process the customer limit
//
strncpy( limit, &record[97], 9 );
limit[9] = '\0';
if( !CheckFloatNumb er( limit ) ) {
prnfile << "Invalid: limit field is not a valid number [position
98 - 9 characters]:\n";
prnfile << record << endl;
return false;
}
Newcrecord.cred itlimit = atof( limit );

validdata.write ((char*) record, Newcrecord.cred itlimit );

return true;

}

///////////////////////////////////////////////////////

bool processdrecord( ofstream& prnfile, ofstream& validdata, char*
record)
{
drecord NewDrecord;
char customercode[6];

strncpy( customercode, &record[2], 5);
customercode[6] = '\0';
if(!CheckAllNum eric( customercode )){
prnfile<< "Invalid: D record customer code does not contain
numerical format"<<endl;
prnfile<< record <<endl;
return false;
}
NewDrecord.cust omercode = atol( customercode );

validdata.write ((char*) record, NewDrecord.cust omercode);

return true;
}

/////////////////////////////////////////////////////////////////////////
bool ProcessIRecord( ofstream& prnfile, ofstream& validdata, char*
record )
{
char customer[6];
char issue_rec[5];
char code[4];
char part[6];

long customer_code;
long issuerec;
long partnum[6];

//
// process the customer code
//
strncpy( customer, &record[2], 5 );
customer[6] = '\0';
if( !CheckAllNumeri c( customer ) ) {
prnfile << "Invalid: customer code needs to be all numeric
[position 3 - 5 characters]:\n";
prnfile << record << endl;
return false;
}
customer_code = atol( customer );

//
// process the part number
//
strncpy( part, &record[7], 6 );
part[6] = '\0';
if( !CheckAllNumeri c( part ) ) {
prnfile << "Invalid: part number needs to be all numeric [position
9 - 6 characters]:\n";
prnfile << record << endl;
return false;
}
partnum[6] = atol( part );

validdata.write ((char*) record, partnum[6]);

return true;

//
// process the third number
//
strncpy( issue_rec, &record[13], 4 );
code[4] = '\0';
if( !CheckAllNumeri c( issue_rec ) ) {
prnfile << "Invalid: the code needs to be all numeric [position 16
- 4 characters]:\n";
prnfile << record << endl;
return false;
}
issuerec = atol( issue_rec );
return true;
}
///////////////////////////////////////////////////////////////////////////
bool CheckDigit(ofst ream& prnfile, char* record)
{

int weightingfactor ;
int remainder;
int weightitem1 = 0;
int weightitem2 = 0;
int weightitem3 = 0;
int weightitem4 = 0;
int weightitem5 = 0;
int product;
int Mod11 = 11;
int checkdigit;
char partnum[6];

irrecord Newirrecord;
strncpy(partnum , &record[7], 6);
partnum[5] = '\0';
Newirrecord.par tnum[5] = atol( partnum );
weightingfactor = 6;
weightingfactor = (Newirrecord.pa rtnum[1] * weightingfactor );

weightingfactor = 5;

weightitem2 = (Newirrecord.pa rtnum[2] * weightingfactor );

weightingfactor = 4;

weightitem3 = (Newirrecord.pa rtnum[3] * weightingfactor );

weightingfactor = 3;

weightitem4 = (Newirrecord.pa rtnum[4] * weightingfactor );

weightingfactor = 2;

weightitem5 = (Newirrecord.pa rtnum[5] * weightingfactor );
//int weigthinfactor = 6;
//int product = 0;
//for(int i = 1; i <= 5; ++i) {
// product += Newicrecord.par tnum[i] * weigthingfactor ;
// weigtingfactor--;
//}
//> remainder = (product % Mod11);

//I had to hunt around to find how Mod11 was defined. What's wrong
with
// remainder = product % 11;

product = (weightitem1 + weightitem2 + weightitem3 + weightitem4 +
weightitem5);

remainder = (product % Mod11);

checkdigit = (Mod11 - remainder);
if(! Newirrecord.par tnum[5] == checkdigit){
prnfile<< "Invalid part number";
prnfile<< record << endl;
}
return false;
return true;

}
/////////////////////////////////////////////////////////////////////////
bool CheckDigitForCu stomerCode(ofst ream& prnfile, char* record)
{
int weightfactor;
int counter1 = 0;
int counter2 = 0;
int counter3 = 0;
int counter4 = 0;
int remainder;
int prod;
int Mod11 = 11;
int check_digit;
char custcode[5];
int cust_code[5] = { 0, 0, 0, 0, 0 };

strncpy(custcod e, &record[2], 5);
custcode[5] = '\0';
cust_code[5] = atoi( custcode );

weightfactor = 5;

counter1 = cust_code[1] * weightfactor;

weightfactor = 4;

counter2 = cust_code[2] * weightfactor;

weightfactor = 3;

counter3 = cust_code[3] * weightfactor;

weightfactor = 2;

counter4 = cust_code[4] * weightfactor;

prod = (counter1 + counter2 + counter3 + counter4);

remainder = prod % Mod11;

check_digit = (Mod11 - remainder);

if(!cust_code[5] == check_digit)
return false;
return true;

}
int main()
{
const char infile[] = "A:\\514650TD.t xt";
const char outfile[] = "A:\\514650VD.D AT";
const char printerfile[] = "A:\\514650.TXT ";

char temp1[256];

ifstream testdata;
ofstream validdata;
ofstream prnfile;

testdata.open(" A:\\514650TD.tx t", ios::in);
if(!testdata)
{
cout<<"The file does not already exist" << infile << endl;
return EXIT_FAILURE;
}

validdata.open( "A:\\514650.DAT ", ios::out | ios::binary);
if(!validdata.i s_open())
{
cout<<" The file could not be opened " << outfile <<endl;
return EXIT_FAILURE;
}

prnfile.open("A :\\514650.TXT", ios::out);
if(!prnfile)
{
cout<< "File could not be opened" << prnfile << endl;
return EXIT_FAILURE;
};
prnfile << "C_RECORD, I-R RECORD, D_RECORD ERRORS" << endl;

while( testdata.getlin e( temp1, sizeof(temp1)))
{
if(!CRecordvali dlength( temp1 )){
prnfile<<"Inval id: record does not contain enough characters:\n";
prnfile<< temp1 <<endl;
continue;
};
if(!IRRecordval idlength( temp1 )){
prnfile<< "Invalid: record does not contain enough characters:\n";
prnfile<< temp1 << endl;
continue;
};
if(!Drecordvali dlength( temp1 )){
prnfile<< "Invalid: record does not contain enough characters:\n";
prnfile<< temp1 << endl;
continue;
};

switch( temp1[0] )
{
case 'c':
case 'C':
Processcrecord( prnfile, validdata, temp1 );
CheckDigitForCu stomerCode( prnfile, temp1 );
break;

case 'i':
case 'I':
case 'r':
case 'R':
ProcessIRecord( prnfile, validdata, temp1 );
break;

case 'd':
case 'D':
processdrecord( prnfile, validdata, temp1 );
break;
default: prnfile<< "Unknown record";
prnfile<< temp1 << endl;
};
testdata.close( );
validdata.close ();
prnfile.close() ;

};
return EXIT_SUCCESS;

};

The file it is reading contains the following.
c23454stevelaw 12sceptrerd;Ilf ord;Essex;IG39B y;
0000.25001600
D23456 etryteryyeyte
ir3456912345512 44
C234551212refck fklioiUIFJNGFJK GGJKFGJ

[Ron Natalie]

"muser" <ch**********@h otmail.com> wrote in message news:f9******** *************** ***@posting.goo gle.com...

testdata.close( );
validdata.close ();
prnfile.close() ;

These closes seem to be inside the while( testdata.getlin e( temp1, sizeof(temp1)))
loop. I think the reason why you get through the first line unscathed is that it hits
the continue (which continues the loop without executing these lines). The second
time through you close the files.

If you'd have indented things consistently you may have caught this.