#!/usr/bin/perl
package Sdbm;
my($SDBM_VERSION) = "3.0";
my($DSWITCH) = 1;
my(@DATABASE) = undef;
my(@FTYPE) = undef;
my(@FNAME) = undef;
my(@FTEXT) = undef;
my(@FOPTION) = undef;
my($TOTAL_ROWS) = undef;
my($TOTAL_FIELDS) = undef;
my($MEMO_DIR) = "./memo/";
my($BIN_DIR) = "./binary/";
my($PTR) = &GET_SCRIPT_PATH_TRANSLATED;
my($_D_S_) = "²·°˜÷";
my($DELETED_LOG) = "./logs/deleted.txt";
###########################################################################################
###########################################################################################
BEGIN {
use Exporter();
@ISA = qw(Exporter);
@EXPORT = qw    (
        @FNAME @FTYPE @FOPTION @FTEXT @DATABASE $DATABASE_FILENAME $FSEPARATOR $DSEPARATOR $MEMO_DIR
        &SELECT &INSERT &DELETE &UPDATE $DSWITCH $SDBM_VERSION &GET_FTEXT &GET_FTYPE &GET_TOTALRECORDS
        &SORTBY &GET_SORTBY &GET_JUMPID &GET_IDFTYPE &CONVERT_DATE &GET_FNAMES &SORTBY_FORCED
        );
@EXPORT_OK = qw();
}
###########################################################################################
sub GET_PROCESSED_DATA
{
my($columnid) = $_[0];
my($data) = $_[1];
my($d_type) = $FTYPE[$columnid];
my($memofilename) = undef;
my($temp) = undef;
my($returndata) = undef;
my($savefilename) = undef;
my($deletefilename) = undef;
my($ltemp,$rtemp) = undef;

    if ($d_type eq "DATE")
    {
        if ($data =~ m/NOW/ig)
        {
        $returndata = time;    
        } else {
        
        $returndata = $data;
        };
    };

    if ($d_type eq "WEBLINK")
    {
        if ($data)
        {
        $returndata = "<a href=\"$data\" target=\"_blank\">WEBLINK</a>";
        };
    };
    
if ($returndata) {return $returndata} else {return $data};    

};
###########################################################################################
sub GET_JUMPID
{
my($jstart) = $_[0];
my($sfield) = $_[1];
my(@SELECTED) = undef;
my($TEMP) = undef;
#$DSWITCH = 1;
#&CHECK_DSWITCH;    
my($sql) = "ID where $sfield LIKE "."^"."$jstart"."*";

@SELECTED = SELECT("$sql","1","1");
my($count) = undef;


foreach (@SELECTED)
{
    $r_line = $_;
    if ($$r_line[0]) {$TEMP[$count] = $$r_line[0]; last};    

    $count++;
};

return $TEMP[0];
};

sub GET_SORTBY
{
my($sortby) = undef;
my($sortbyfile) = "sortby";    
my(@RAW) = undef;
my(@RETURN) = undef;
my($temp) = undef;
my($count) = undef;

if (-e $sortbyfile) {@RAW = READ_FILE("$sortbyfile")};
foreach (@RAW)
{
$temp = $_;
if ($temp) {$temp = CLEAN_LINE($temp); $RETURN[$count] = $temp; $count++};
};
return @RETURN;
};

sub GET_FTEXT
{
my($fname) = $_[0];
my($ftext) = undef;
my($found) = 0;
my($count) = undef;

    while ($count < @FNAME)
    {
    if ($fname eq $FNAME[$count]) {$ftext = $FTEXT[$count]; $found=1; last};
    $count++;
    };
return $ftext;
};

sub GET_FID
{
my($fname) = $_[0];
my($fid) = undef;
my($found) = 0;
my($count) = undef;

    while ($count < @FNAME)
    {
    if ($fname eq $FNAME[$count]) {$fid = $count; $found=1; last};
    $count++;
    };
return $fid;
};
sub GET_TOTALRECORDS
{
my($total) = undef;
$total = @DATABASE;
return $total;    
};

sub GET_IDFTYPE
{
my($fid) = $_[0];
my($ftype) = undef;
my($found) = 0;
my($count) = undef;

return $FTYPE[$fid];
};

sub GET_FTYPE
{
my($fname) = $_[0];
my($fource) = $_[1];
my($ftype) = undef;
my($found) = 0;
my($count) = undef;
if ($fource) {READ_DATABASE($DATABASE_FILENAME,$FSEPARATOR,$DSEPARATOR)};
    while ($count < @FNAME)
    {
    if ($fname eq $FNAME[$count]) {$ftype = $FTYPE[$count]; $found=1; last};
    $count++;
    };
return $ftype;
};


sub GET_FNAMES
{
my($fource) = $_[1];
my($ftype) = undef;
my($found) = 0;
my($count) = undef;
if ($fource) {READ_DATABASE($DATABASE_FILENAME,$FSEPARATOR,$DSEPARATOR)} else {&CHECK_DSWITCH};

return @FNAME;
};
###########################################################################################
###########################################################################################

sub UPDATE
{
my($sql) = $_[0];
$sql = TODB($sql);
my(@update) = @_[1..@_-1];
my(@UPDATE_ID) = undef;
my($rcount,$fcount) = undef;
&CHECK_DSWITCH;    
my($sqlprobe) = "ID "."$sql";  
my(@COLUMN) = undef;
my(@LINE) = undef;
my($r_line) = undef;    
my($count) = undef;
my($delfilename,$memofilename,$binfilename) = undef;

#print "<br>UPDATE: $sqlprobe\n<br>";
$uline = ":";
@COLUMN = SELECT("$sqlprobe");
#print "UPDATE: \@COLUMN = @COLUMN\n<br>";
$count=0;
    foreach (@COLUMN)
    {
    $r_line = $_;
    @LINE = @$r_line;
    $UPDATE_ID[$count] = $LINE[0];
    if ($UPDATE_ID[$count]) {$uline = "$uline"."$UPDATE_ID[$count]".":";};
    $count++;
    };
#print "<br>UPDATE: UPDATING: @UPDATE_ID\n\$uline = $uline\n<br>";    

$count = 0;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {
        if ($uline =~ m/:$DATABASE[$rcount][0]:/) 
        {
#        print "UPDATE: Updating: $DATABASE[$rcount][0] - $DATABASE[$rcount][1] - $DATABASE[$rcount][2]\n";        
#        $DATABASE[$rcount][0] = "";
            
                foreach (@update)
                {
                ($fid, $data) = split(/=/,$_);
                $fid = CLEAN_LINE($fid);    
                $data = CLEAN_ENDS($data);    
                $columnid = GET_COLUMNID($fid);
#                print "UPDATE: UPDATING FIELD: $fid DATA: $data\n\$columnid = $columnid\n";
                    if ($columnid > 0) 
                    {
                            if  (PROCESS_DATA_TYPE($columnid,$data)) 
                            {
                                # PROCESS MEMO FIELD
                                if ($FTYPE[$columnid] eq "MEMO") 
                                {
                                    if ($data)
                                    {
                                        $memofilename = $DATABASE[$rcount][$columnid];
                                        $delfilename = "$MEMO_DIR"."$memofilename";
                                    #    print "Unlinking Memo $data =  $delfilename ? <br>";
                                        if ((-e $delfilename) && ($memofilename) )
                                        {    unlink "$delfilename";
                                        
                                            SAVE_REPORT("$DELETED_LOG","$delfilename"," - ",time," - ",scalar localtime(time),"\n");
                                        };
                                    
                                    };
                                };
                                if ($FTYPE[$columnid] eq "DATE") 
                                {
                                    if ($FOPTION[$columnid] =~ m/CONSTANT/gi)
                                    {
                                        $data = $DATABASE[$rcount][$columnid];
                                    };
                                };
                                
                                
                                if ($FTYPE[$columnid] eq "DATABASE") 
                                {
                                $data = $DATABASE[$rcount][$columnid];
                                };
                                
                                
                                if ($FTYPE[$columnid] eq "BINARY") 
                                {
                                    if ($data)
                                    {
                                        $binfilename = $DATABASE[$rcount][$columnid];
                                        $delbinfilename = "$BIN_DIR"."$binfilename";
                                        if ((-e $delbinfilename) && ($binfilename ) )
                                        {    unlink "$delbinfilename";
                                            SAVE_REPORT("$DELETED_LOG","$delbinfilename"," - ",time," - ",scalar localtime(time),"\n");
                                        };
                                    };
                                };                                
                                
                            $data = GET_PROCESSED_DATA($columnid,$data);
                            if ($data) {$DATABASE[$rcount][$columnid] = $data};
                            };

                    };
                };

        };
    $rcount++;    
    };

        if ($ERROR_MESSAGE) 
        {
#        print "$ERROR_MESSAGE";
        return 0;
        } else     {
            &REPUBLISH_DATABASE;

            return 1;
            };
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub DELETE
{
my($sql) = $_[0];
$sql = TODB($sql);
my(@DELETE_ID) = undef;
my($rcount,$fcount) = undef;
&CHECK_DSWITCH;    
my($sqlprobe) = "ID "."$sql";  
my(@COLUMN) = undef;
my(@LINE) = undef;
my($r_line) = undef;
my($delfilename,$memofilename,$binfilename) = undef;
#print "DELETE: $sqlprobe\n";
$dline = ":";
@COLUMN = SELECT("$sqlprobe");
#print "DELETE: \@COLUMN = @COLUMN";
$count=0;
foreach (@COLUMN)
{
$r_line = $_;
@LINE = @$r_line;
$DELETE_ID[$count] = $LINE[0];
$dline = "$dline"."$LINE[0]".":";
$count++;
};
#print "DELETE: DELETING: @DELETE_ID\n\$dline = $dline\n";

$count = 0;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {
        if ($dline =~ m/:$DATABASE[$rcount][0]:/) 
        {
#        print "DELETE: Deliting: $DATABASE[$rcount][0] - $DATABASE[$rcount][1] - $DATABASE[$rcount][2]\n";        
        $DATABASE[$rcount][0] = "";
        $fcount = 0;
        
            foreach (@FTYPE)
            {
            $temp = undef;
            $temp = $_;
            
                if ($temp eq "MEMO") 
                {
                $memofilename = $DATABASE[$rcount][$fcount];
                $delfilename = "$MEMO_DIR"."$memofilename";
                    if ((-e $delfilename) && ($memofilename) )
                    {    unlink "$delfilename";
                        SAVE_REPORT("$DELETED_LOG","$delfilename"," - ",time," - ",scalar localtime(time),"\n");
                    };
                
                };

# CREATE DELETE DATABASE PROCEDURE!
                if ($temp eq "DATABASE") 
                {
                $dbfilename = $DATABASE[$rcount][$fcount];
                $dbfilename = "$PTR"."database/"."$dbfilename";
                    
                    #HANDLING WIN32 ENVIRONMENT:
                    if ($^O =~ m/Win32/i) 
                    {
                    $dbfilename  =~ s!/!\\!g;
                    $command = "RD /S /Q \"$dbfilename\"";
                #    print "COMMAND: $command <br>";
                    system("$command");
                } else {
                    #print "removing $dbfilename<br>";
                        system("rm -r -f $dbfilename");
                        };

                SAVE_REPORT("$DELETED_LOG","DATABASE: $dbfilename"," - ",time,"-",scalar localtime(time),"\n");
                };

                
                if ($temp eq "BINARY") 
                {
                    
                    $binfilename = $DATABASE[$rcount][$fcount];
                    $delbinfilename = "$PTR"."binary/"."$binfilename";
                    $delbininfofilename = "$PTR"."binary/"."_"."$binfilename";
    #                print "DELETING: $delbinfilename\n<br>";
                    if ((-e $delbinfilename) && ($binfilename ) )
                    {    unlink "$delbinfilename";
                        unlink "$delbininfofilename";
    #                print "DELETING: $delbinfilename\n<br>";
                        SAVE_REPORT("$DELETED_LOG","$delbinfilename"," - ",time," - ",scalar localtime(time),"\n");
                    };
                };                                
                


            $fcount++;
            };
        
        
        
        };
    $rcount++;    
    };


&REPUBLISH_DATABASE;

};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub INSERT
{
@add=@_;

        &CHECK_DSWITCH;
        my($id,$fid,$data) = undef;
        
        $id = &GET_UNUSED_ID;
#        print "ADD: UNUSED ID: $id\n<br>";
        $newposition = $#DATABASE+2;
        $DATABASE[$newposition][0] = "$id";
        
            foreach (@add)
            {
            ($fid, @adddata) = split(/=/);
            $data = join("=",@adddata);
            
            $fid = CLEAN_LINE($fid);    
            if ($fid eq "ID") {next};
            $data = CLEAN_ENDS($data);    
#            print "INSERT: ADDING to FIELD: $fid DATA: $data\n<br>";    
#            sleep(2);
            $columnid = GET_COLUMNID($fid);
        # identify the type of a column
        
                if  (PROCESS_DATA_TYPE($columnid,$data)) 
                {
                $data = GET_PROCESSED_DATA($columnid,$data);
                $DATABASE[$newposition][$columnid] = $data;
                };
        
            };
        
                if ($ERROR_MESSAGE) 
                {
                print "$ERROR_MESSAGE";
                return 0;
                } else     {
                    &REPUBLISH_DATABASE;
                    return 1;
                    };
        


};
###########################################################################################
###########################################################################################

###########################################################################################
sub PROCESS_DATA_TYPE
{
my($columnid) = $_[0];
my($data) = $_[1];
my($d_type) = $FTYPE[$columnid];    
my($rcount) = undef;
my($check) = 1;
my($returnvalue) = 1;

    if (($d_type =~ m/INDEX/i) && ($check)) 
    {
#    print "PROCESS_DATA_TYPE: Checking id $data is an INDEX\n";
    if (CHECK_INDEX($columnid,$data)) {$returnvalue = 1} else {$returnvalue= 0;$ERROR_MESSAGE = $ERROR_MESSAGE."Error: FIELD:$FNAME[$columnid]=\"$data\" is not a unique value.<br>\n";};    
    $check = 0;
    };

    if (($d_type =~ m/NUMBER/i) && ($check)) 
    {
#    print "PROCESS_DATA_TYPE: Checking id $data is a NUMBER\n";
    if ($data =~ /^\d+$/) {$returnvalue = 1; } else {$returnvalue = 0;$ERROR_MESSAGE = $ERROR_MESSAGE."Error: FIELD:$FNAME[$columnid]=\"$data\" is not a digit value.<br>\n";};    
    $check = 0;
    };


return $returnvalue;
};

###########################################################################################
###########################################################################################
sub CHECK_INDEX
{
my($columnid) = $_[0];
my($data) = $_[1];
my($rcount) = undef;
my($returnvalue) = 1;

    $rcount = 1;
    while ($rcount < $#DATABASE)
    {
    if ($data eq $DATABASE[$rcount][$columnid]) {$returnvalue = 0;};
    $rcount++;
    };

return $returnvalue;
};


###########################################################################################
sub ADD_TO_DATABASE
{
my($count) = undef;
my($fcount) = undef;
my($position) = $_[0];
my($LINE) = undef;
my($fline) = undef;


    $count = 0;
    
    while ($count < @FNAME)
    {
    $LINE = "$LINE"."$DATABASE[$position][$count]"."$DSEPARATOR";
    $count++;
    };
    $LINE = "$LINE"."\n";
#    print "ADD_TO_DATABASE: \$LINE = $LINE";


SAVE_REPORT("$DATABASE_FILENAME",$LINE);
};
###########################################################################################
sub REPUBLISH_DATABASE
{
my($count) = undef;
my($fcount) = undef;
my(@LINE) = undef;
my($fline) = undef;

    $count = 0;
    foreach (@FNAME)
    {
    $temp[$count] = "$FTYPE[$count]"."$DSEPARATOR"."$FNAME[$count]"."$DSEPARATOR"."$FOPTION[$count]"."$DSEPARATOR"."$FTEXT[$count]";     
    $count++;
    };
    $LINE[0] = join "$FSEPARATOR", @temp;
    $LINE[0] = "$LINE[0]"."\n";
    $count = 1;
    foreach (@DATABASE)
    {
        if (@$_[0]) 
        {
        $TEMP = undef;
        $TEMP = join ("$DSEPARATOR", @$_[1..@$_-1]);
        $TEMP = "$count"."$DSEPARATOR".$TEMP;
        push(@LINE,("$TEMP"."\n"));
        $count++;
        };

    };    
SAVE_FILE("$DATABASE_FILENAME",@LINE);

@LINE = undef;
};
###########################################################################################
###########################################################################################
sub SORTBY
{
&CHECK_DSWITCH;
my($count) = undef;
my(@TEMP) = undef;
my(@LINE) = undef;
my($sfield) = $_[0];
$sortfield = GET_FID($sfield);
my($order) = 1;
my(@RAW) = undef;
@RAW = GET_SORTBY;

    if ($sfield eq $RAW[0]) 
    { 
        $order = $RAW[1]; 
        if ($order > 0) {$order = 0} else {$order = 1};
    };

SAVE_FILE("sortby","$sfield\n","$order");

if ($sortfield) 
{
    my(%SORTHASH) = undef;

    $count = @DATABASE;
#        SAVE_REPORT("report.txt","$count\n");      
        $count = 1;
        foreach (@DATABASE)
        {
            $SORTHASH{@$_[0]} = @$_[$sortfield]; 
        };    
    
    
    if ($order > 0) 
    {
        @LINE = sort {
                    $SORTHASH{$a} <=> $SORTHASH{$b}
                    ||
                    $SORTHASH{$a} cmp $SORTHASH{$b}
                    ||
                     $a <=> $b
                    } keys %SORTHASH;        
    } else     {
        @LINE = sort {
                    $SORTHASH{$b} <=> $SORTHASH{$a}
                    ||
                    $SORTHASH{$b} cmp $SORTHASH{$a}
                    ||
                     $b <=> $a
                    } keys %SORTHASH;        
        };

    
    $count = 1;
    $rcount = 1;
        foreach (@LINE)
        { 
            if ($_) 
            {
            $checkline = $_;
            $rcount = 1;
    #        SAVE_REPORT("sorted1.txt","line : $checkline\n");
            $TEMP[$count][0] = $checkline;
                while ($rcount < @FNAME)
                {
    #            SAVE_REPORT("sorted1.txt","row: $rcount DATA: $DATABASE[$checkline][$rcount]\n");
                $TEMP[$count][$rcount] = $DATABASE[$checkline][$rcount];
                $rcount++;
                };    
            
    
            $count++;
            };
        };
        
    @DATABASE = @TEMP;
    @LINE = undef;
    @TEMP = undef;
    $count = undef;
    &REPUBLISH_DATABASE;
};
};
###########################################################################################
###########################################################################################
sub SORTBY_FORCED
{
&CHECK_DSWITCH;
my($count) = undef;
my(@TEMP) = undef;
my(@LINE) = undef;
my($sfield) = $_[0];
my($order) = $_[1];
$sortfield = GET_FID($sfield);
my(@RAW) = undef;

if ($sortfield) 
{
    my(%SORTHASH) = undef;

    $count = @DATABASE;
#        SAVE_REPORT("report.txt","$count\n");      
        $count = 1;
        foreach (@DATABASE)
        {
            $SORTHASH{@$_[0]} = @$_[$sortfield]; 
        };    
    
    
    if ($order > 0) 
    {
        @LINE = sort {
                    $SORTHASH{$a} <=> $SORTHASH{$b}
                    ||
                    $SORTHASH{$a} cmp $SORTHASH{$b}
                    ||
                     $a <=> $b
                    } keys %SORTHASH;        
    } else     {
        @LINE = sort {
                    $SORTHASH{$b} <=> $SORTHASH{$a}
                    ||
                    $SORTHASH{$b} cmp $SORTHASH{$a}
                    ||
                     $b <=> $a
                    } keys %SORTHASH;        
        };

    
    $count = 1;
    $rcount = 1;
        foreach (@LINE)
        { 
            if ($_) 
            {
            $checkline = $_;
            $rcount = 1;
    #        SAVE_REPORT("sorted1.txt","line : $checkline\n");
            $TEMP[$count][0] = $checkline;
                while ($rcount < @FNAME)
                {
    #            SAVE_REPORT("sorted1.txt","row: $rcount DATA: $DATABASE[$checkline][$rcount]\n");
                $TEMP[$count][$rcount] = $DATABASE[$checkline][$rcount];
                $rcount++;
                };    
            
    
            $count++;
            };
        };
        
    @DATABASE = @TEMP;
    @LINE = undef;
    @TEMP = undef;
    $count = undef;
    &REPUBLISH_DATABASE;
};
};
###########################################################################################
###########################################################################################
sub GET_UNUSED_ID
{
my($rcount) = undef;
my($fcount) = undef;
my($freeid) = undef;
my($found) = 0;




        $freeid = $#DATABASE+1;
        $found = 1;
        $rcount = 1;
                while ($rcount <= $#DATABASE)
                {
    #        print "GET_UNUSED_ID:checking if:  \$DATABASE[$rcount][0]=$DATABASE[$rcount][0]\n";
                    if ($DATABASE[$rcount][0]== $freeid) 
                    {
    #                print "GET_UNUSED_ID: \$DATABASE[$rcount][0]=$DATABASE[$rcount][0]\n";
                    $found = 0;
                    };
                
                $rcount++;    
                };    
        
            unless ($found)
            {
                while (!$found)
                {
                $freeid++;
                $found = 1;
                $rcount = 1;
                        while ($rcount <= $#DATABASE)
                        {
            #        print "GET_UNUSED_ID:checking if:  \$DATABASE[$rcount][0]=$DATABASE[$rcount][0]\n";
                            if ($DATABASE[$rcount][0]== $freeid) 
                            {
            #                print "GET_UNUSED_ID: \$DATABASE[$rcount][0]=$DATABASE[$rcount][0]\n";
                            $found = 0;
                            };
                        
                        $rcount++;    
                        };    
                
                };
            
                    if ($freeid == ($#DATABASE+1)) 
                    {
                    SAVE_FILE("c_trigger")};
                    } else     {
                #        print "GET_UNUSED_ID: Skipped long process :)\n";
            };

    






#print "GET_UNUSED_ID: \$freeid = $freeid\n";
#sleep(2);
return $freeid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub RETURN_COLUMN
{
my($rcount,$fcount) = undef;
my($columnid) = $_[0];
my($totalrecords) = undef;
my(@column) = undef;
&CHECK_DSWITCH;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {
    $column[$rcount] = $DATABASE[$rcount][$columnid];
    $rcount++;    
    };

return  @column;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub SELECT
{
my($sql) = $_[0];
$sql = TODB($sql);
my($readforce) = $_[1];
my($exact) = $_[2];
my($rcount,$fcount) = undef;
my($fieldid,$condition,$cond_count) = undef;
my($returnfieldcount) = undef;
my($columnid) = undef;
my(@ID,@RETURN,@IDLIST,@TEMP,@REF_IDLIST) = undef;
my($returnfieldcount,$returnfieldcount,$idlistcount,$fname) = undef;
my(@MATRIX) = undef;
$sql = UPPER_CASE($sql);
my(@cond_list) = undef;

($fieldid,$condition) = split(/WHERE/,$sql);
$fieldid =~ s/\s+//g;
#print "SELECT: \$DSWITCH = $DSWITCH $FSEPARATOR -  $DSEPARATOR\n";
unless ($readforce) {&CHECK_DSWITCH} else {READ_DATABASE($DATABASE_FILENAME,$FSEPARATOR,$DSEPARATOR)};

$columnid = GET_COLUMNID($fieldid);

# Processing AND conditions;
    if ($condition =~ m/\s+AND\s+/i) 
    {
    @cond_list = split(/AND/,$condition);
#    print "SELECT: \$condition contains AND\n";
    
        foreach (@cond_list)
        {
        $cond_line = CLEAN_ENDS($_);
#        print "SELECT: \$cond_line = $cond_line\n";
            unless ($cond_count) 
            {
            @REF_IDLIST = GET_IDLIST($cond_line);
#            print "SELECT: \@REF_IDLIST[$cond_count] = @REF_IDLIST\n";
            } else {
                
                $TEMPLINE = join(":",GET_IDLIST($cond_line)); 
                $TEMP[$cond_count] = ":"."$TEMPLINE".":";
#                print "SELECT: \$TEMP[$cond_count] = $TEMP[$cond_count]\n";
                };

        $cond_count++;
#        sleep(1);
        };    
    
        $count =1;
        $id_count = 0;
        @IDLIST = undef;
                
            while ($count < @TEMP)
            {
                foreach (@REF_IDLIST)
                {
                $refline = CLEAN_ENDS($_);                
                    if ($TEMP[$count] =~ m/:$refline:/i) 
                    {
                    $IDLIST[$id_count] = $refline;
                    $id_count++;
                    };
                
                };
            @REF_IDLIST = @IDLIST;
#                print "SELECT: \@IDLIST = @IDLIST :\n \@REF_IDLIST=@REF_IDLIST\n";
#                sleep(1);                
            $id_count = 0;
            @IDLIST = undef;
            $count++;
            };
    @IDLIST = @REF_IDLIST;
    } else     {
        @IDLIST = GET_IDLIST($condition,$exact); 
        };



#    @IDLIST = GET_IDLIST($condition,$exact); 
    $temp = @IDLIST;
#    print "SELECT: \@IDLIST = @IDLIST = $temp\n";
    
    if (@IDLIST)
    {
        $returnfieldcount = 0;                        
        @RETURN_FIELDS = split(/,/,$fieldid);
#        print "SELECT: \@RETURN_FIELDS = @RETURN_FIELDS\n";
#        
        while ($returnfieldcount < @RETURN_FIELDS)
        {
        $fname = CLEAN_LINE($RETURN_FIELDS[$returnfieldcount]);
        $columnid = GET_COLUMNID($fname);
    
        $idlistcount = 0;
#        print "SELECT: FIELDNAME: $fname FIELDID:$columnid\n";
            while ($idlistcount < @IDLIST)
            {
#            $MATRIX[$idlistcount][$returnfieldcount] = $DATABASE[$IDLIST[$idlistcount]][$columnid];
            $MATRIX[$idlistcount][$returnfieldcount] = FROMDB($DATABASE[$IDLIST[$idlistcount]][$columnid]);
#            print "SELECT: MATRIX=$MATRIX[$idlistcount][$returnfieldcount]\n";
            $idlistcount++;
            };
        
        $returnfieldcount++;
        };
        
    };
return @MATRIX;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_IDLIST
{
my($condition) = $_[0];
my($exact) = $_[1];
my($opfield,$opdata,$opcolumnid) = undef;
my($operation) = 0;
my(@ID) = undef;

#print "GET_IDLIST: \$condition = $condition\n";
    unless ($operation)
    {
        if ($condition =~ m/=/) 
        {
            ($opfield,$opdata) = split(/=/,$condition);
            $opfield = CLEAN_LINE($opfield);
            $opdata = CLEAN_ENDS($opdata);
                        
        $opcolumnid = GET_COLUMNID($opfield);
                        
        @ID = GET_EQUAL($opcolumnid,$opdata);
        $operation = 1;
        };
    };

    unless ($operation)
    {
        if ($condition =~ m/</) 
        {
            ($opfield,$opdata) = split(/</,$condition);
            $opfield = CLEAN_LINE($opfield);
            $opdata = CLEAN_ENDS($opdata);
            $opcolumnid = GET_COLUMNID($opfield);
            @ID = GET_GREATERTHAN($opcolumnid,$opdata);    
            
        $operation = 1;
        };
    };
    unless ($operation)
    {
        if ($condition =~ m/>/) 
        {
            ($opfield,$opdata) = split(/>/,$condition);
            $opfield = CLEAN_LINE($opfield);
            $opdata = CLEAN_ENDS($opdata);
            $opcolumnid = GET_COLUMNID($opfield);
            @ID = GET_LESSTHAN($opcolumnid,$opdata);        
        $operation = 1;
        };
    };

    unless ($operation)
    {
        if ($condition =~ m/\s+LIKE\s+/) 
        {
            ($opfield,$opdata) = split(/\s+LIKE\s+/,$condition);
            $opfield = CLEAN_LINE($opfield);
            $opdata = CLEAN_ENDS($opdata);
                        
        $opcolumnid = GET_COLUMNID($opfield);
                        
        @ID = GET_LIKE($opcolumnid,$opdata,$exact);
        $operation = 1;
        };
    };

#print "GET_IDLIST: \$operation=$operation\n";
    unless ($operation)
    {
        $condition = CLEAN_ENDS($condition);
        
        
        if ($condition =~ m/DISTINCT/i) 
        {
            ($opfield,$opdata) = split(/\s+DISTINCT/,$condition);
#        print "GET_IDLIST: \$condition = $condition, \$opfield = $opfield, \$opdata=$opdata\n";    

            
            $opfield = CLEAN_LINE($opfield);
            $opdata = CLEAN_ENDS($opdata);
                        
        $opcolumnid = GET_COLUMNID($opfield);
#        print "GET_DISTINCT: \$opfield = $opfield, \$opcolumnid = $opcolumnid\n";            
        @ID = GET_DISTINCT($opcolumnid);
        $operation = 1;
        };
    };





    
#print "GET_IDLIST: \@ID = @ID\n";    
return @ID;    
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub CLEAN_ENDS
{
my($line) = $_[0];
$line =~ s/^\s+//;
$line =~ s/\s+$//;    
return $line;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_EQUAL
{
my($columnid) = $_[0];
my($data) = $_[1];
my($rcount,$fcount) = undef;
my(@returnid) = undef;
my($idcount) = undef;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {

#        print "testing if $data is equal to $DATABASE[$rcount][$columnid]\n";    
        if ($DATABASE[$rcount][$columnid] eq $data) 
        {
        $returnid[$idcount] = $rcount;
#        print "EQUAL FOUND! $returnid[$idcount]\n";
        $idcount++;    
        };
    
    $rcount++;    
    };
#print "GET_EQUAL: \@returnid = @returnid\n";
return @returnid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_LIKE
{
my($columnid) = $_[0];
my($data) = $_[1];
my($exact) = $_[2];
my($rcount,$fcount) = undef;
my(@returnid) = undef;
my($idcount) = undef;
#$data =~ s/*//g;
$rcount = 1;

if ($exact) 
{
if($data) {$data =~ s/\*/\.\*/g; $pattern = "$data"};    
} else {
    if($data) {$data =~ s/\*/\.\*/g; $pattern = "^"."$data"."\$"};    
    };


    while ($rcount <= $TOTAL_ROWS)
    {
#        print "\ntesting if $data is equal to $DATABASE[$rcount][$columnid]\n";
        if ( ( $DATABASE[$rcount][$columnid] =~ m/$data/ig ) && ( CLEAN_LINE($DATABASE[$rcount][$columnid]) ) )
        {
        $returnid[$idcount] = $rcount;
#        print "EQUAL FOUND! $returnid[$idcount]\n";
        $idcount++;    
        };
    
    $rcount++;    
    };
#print "GET_LIKE: \@returnid = @returnid\n";
return @returnid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_DISTINCT
{
my($columnid) = $_[0];
my($data) = $_[1];
my($rcount,$fcount,$idcount) = undef;
my(@returnid) = undef;
my($idcount) = undef;
my(%DISTINCT) = undef;
my($h_elem) = undef;
my($temp) = undef;
        foreach $h_elem (sort(keys(%DISTINCT))) 
        { 
                $DISTINCT{$h_elem} = undef;; 
               
                
    };
    
#$data =~ s/*//g;
$rcount = 1;
if($data) {$data =~ s/\*/\.\*/g; $pattern = "^"."$data"."\$"};
    while ($rcount < $TOTAL_ROWS)
    {
    $temp = undef;
#        print "\ntesting if $data is equal to $DATABASE[$rcount][$columnid]\n";
    $temp = $DATABASE[$rcount][$columnid];
    
        unless ($DISTINCT{$temp})
        {
        if (CLEAN_LINE($temp)) {$DISTINCT{$temp} = $rcount;print "GET_DISTINCT: DISTINCT= $temp\n";};    
        
    
        };

    
    $rcount++;    
    };
  
        foreach $h_elem (sort(keys(%DISTINCT))) 
        { 
                $returnid[$idcount] = $DISTINCT{$h_elem}; 
                $idcount++;
                
    };



   
 

#print "GET_LIKE: \@returnid = @returnid\n";


return @returnid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_GREATERTHAN
{
my($columnid) = $_[0];
my($data) = $_[1];
my($rcount,$fcount) = undef;
my(@returnid) = undef;
my($idcount) = undef;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {

        if ($DATABASE[$rcount][$columnid] < $data) 
        {
        $returnid[$idcount] = $rcount;
        $idcount++;    
        };
    
    $rcount++;    
    };
#print "GET_GREATERTHAN: \@returnid = @returnid\n";
return @returnid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_LESSTHAN
{
my($columnid) = $_[0];
my($data) = $_[1];
my($rcount,$fcount) = undef;
my(@returnid) = undef;
my($idcount) = undef;
$rcount = 1;
    while ($rcount <= $TOTAL_ROWS)
    {

        if ($DATABASE[$rcount][$columnid] > $data) 
        {
        $returnid[$idcount] = $rcount;
        $idcount++;    
        };
    
    $rcount++;    
    };
#print "GET_LESSTHAN: \@returnid = @returnid\n";
return @returnid;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub GET_COLUMNID
{
my($fieldid) = $_[0];
my($fcount) = undef;
#print "GET_COLUMNID: for $fieldid\n";
    while ($fcount < $TOTAL_FIELDS)
    {
#    print "GET_COLUMNID: checking if $FNAME[$fcount] = $fieldid\n";
        if ($FNAME[$fcount] eq $fieldid) 
        {
        
        return $fcount; 
        last;
        };        
    $fcount++;
    };

};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub CHECK_DSWITCH
{
my(@RAW) = undef;
if ($DSWITCH) {@RAW = READ_DATABASE($DATABASE_FILENAME,$FSEPARATOR,$DSEPARATOR)};    
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
#####################################################################
# ID:002                                                   
# TITLE:Function - Convert string to Uppercase (UPPER_CASE)                                                   
# AUTHOR: SERGY STOUK                                               
# SUBMITTED: Sunday, December 10, 2000                                                  
#####################################################################
sub UPPER_CASE
{
my($string)= $_[0];
$string =~ tr/a-z/A-Z/;
return $string;
        };
#####################################################################
# END OF:002                                               
#####################################################################
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub READ_DATABASE
{
my($datafile) = $_[0];
my($fieldseparator) = $_[1];
my($dataseparator) = $_[2];
my($filedsline) = undef;
my(@rows) = undef;
my($fcount) = 0;
my($rcount) = 0;
my(@fields) = undef;
my($line) = undef;
my(@rawdata) = undef;
my($totalrows) = undef;
my($totalfields) = undef;
my($line) = undef;
my(@temp) = undef;
my(@ftype) = undef;
my(@fname) = undef;
my(@ftext) = undef;
my(@foption) = undef;
my(@database) = undef;

# reading database file:
my(@rawdata) = READ_FILE("$datafile");

# getting the first line with field definition:
$fieldsline = $rawdata[0];
$fieldsline = CLEAN_LINE($fieldsline);


# getting the rest of the database:
@rows = @rawdata[1..@rawdata-1];

# identifying fields:
@fields = split(/$fieldseparator/,$fieldsline);

    #identifying field typesm names and options;
    foreach (@fields)
    {
    $line = $_;
    $line = CLEAN_LINE($line);

        if ($line) 
        {
#        print "READ_DATABASE:$line\n";
        ($ftype[$fcount],$fname[$fcount],$foption[$fcount],$ftext[$fcount]) = split(/$dataseparator/,$line);
#        print "READ_DATABASE:TYPE: $fcount = $ftype[$fcount]\n";
#        print "READ_DATABASE:TYPE: $fcount = $fname[$fcount]\n";
#        print "READ_DATABASE:TYPE: $fcount = $foption[$fcount]\n";
#        print "READ_DATABASE:TYPE: $fcount = $ftext[$fcount]\n";
        $fcount++;
        };
    };
$totalfields = $fcount;
    #generating array of arrays of database data:
    $line = undef;
    $rcount = 0;
    while ($rcount <= @rows)
    {
    $line = $rows[$rcount];
    $line = CLEAN_LINE($line);
    $fcount = undef;
            if ($line)
            {
            @temp = split(/$dataseparator/,$line);
            
                $fcount = 0;
                foreach (@temp)
                {
                $templine = $_;
                $templine = CLEAN_LINE($templine);
                $database[$rcount+1][$fcount] = $templine;
#                print "READ_DATABASE: ROW=$rcount,FIELD=$fcount,DATA=$database[$rcount][$fcount]\n";
                $fcount++;
                };
            };
    $rcount++;    
    };

$totalrows = $rcount;

@RETURN = (\@database,\@ftype,\@fname,\@ftext,\@foption,\$totalrows,\$totalfields);
$DSWITCH = 0;
$TOTAL_ROWS = $totalrows;
$TOTAL_FIELDS = $totalfields;
#print "READ DATABASE: \$TOTAL_FIELDS = $TOTAL_FIELDS\n";
@FOPTION = @foption;
@FTYPE = @ftype;
@FNAME = @fname;
@FTEXT = @ftext;
@DATABASE = @database;

return @RETURN;
};
###########################################################################################
###########################################################################################
###########################################################################################
###########################################################################################
sub CLEAN_LINE
{
my($line) = $_[0];
$line =~ s/\n//g;
$line =~ s/^\s+//g;
$line =~ s/\s+$//g;
return $line;
};
#####################################################################
# ID:024                                                   
# TITLE:Function - READ_FROM_FILE - Reads data from file and returns as an array.                                                   
# SUBMITTED BY: SERGY STOUK                                         
# DATE: Monday, December 11, 2000                                                       
#####################################################################
sub READ_FILE 
{ 
my($filename) = $_[0]; 
my($count) = 0; 
my(@result) = undef; 
open (INPUT, "$filename") || die "Could not open file $filename : $!\n"; 
while (<INPUT>) 
{ 
($result[$count]) =$_; 
$count++; 
}; 
close (INPUT); 
return @result; 
};
#####################################################################
# END OF:024                                               
#####################################################################
  
#####################################################################
# ID:022                                                   
# TITLE:Function - Save Array Parameter to file (SAVE_TO_FILE)                                                   
# SUBMITTED BY: SERGY STOUK                                         
# DATE: Monday, December 11, 2000                                                       
#####################################################################
sub SAVE_FILE
{
my($filename) = $_[0];
my(@send) = @_[1..@_-1];
my($count) = 0;

open (FILE, ">$filename") || die "Can’t write to $filename: error $!\n";
while ($count < @_)
{
print FILE $send[$count];
$count++
};
close FILE;
return $count;
};
#####################################################################
# END OF:022                                               
#####################################################################

sub TODB
{
my($RESULT) = $_[0];
$RESULT    =~ s/$DSEPARATOR/$_D_S_/g;
return $RESULT;
};

sub FROMDB
{
my($RESULT) = $_[0];
$RESULT    =~ s/$_D_S_/$DSEPARATOR/g;
return $RESULT;
};

########################### GET_SCRIPT_PATH_TRANSLATED #####################################
sub GET_SCRIPT_PATH_TRANSLATED
{
my($temp) = undef;
my($PATH_TRANSLATED) = undef;

$PATH_TRANSLATED= $ENV{"PATH_TRANSLATED"};
$_ = $PATH_TRANSLATED; 
if ($PATH_TRANSLATED =~ /\//) 
{
($PATH_TRANSLATED,$temp) = /(.*)\/(.*)$/;
$PATH_TRANSLATED = "$PATH_TRANSLATED"."/";
} else {
($PATH_TRANSLATED,$temp) = /(.*)\\(.*)$/;
$PATH_TRANSLATED = "$PATH_TRANSLATED"."\\";
};
$PATH_TRANSLATED =~ s/\\/\//g;
if ($PATH_TRANSLATED eq "/") {$PATH_TRANSLATED = "./";};
return $PATH_TRANSLATED;
};
##############################################################################################
##############################################################################################
sub GET_SCRIPT_PATH
{
my($temp) = undef;
my($LOCAL_ADDR) = undef;
my($SCRIPT_NAME) = undef;
my($SCRIPT_PATH) = undef;

$LOCAL_ADDR= $ENV{"SERVER_NAME"};
$SCRIPT_NAME= $ENV{"SCRIPT_NAME"};
$_ = $SCRIPT_NAME;
($SCRIPT_PATH,$right) = /(.*)\/(.*)$/; 
$SCRIPT_PATH = "http://$LOCAL_ADDR"."$SCRIPT_PATH"."/";
return $SCRIPT_PATH;
};
##############################################################################################
#####################################################################
# ID:010                                                   
# TITLE:Function - Get Current Date and/or Time (GET_DATE)                                                   
# AUTHOR: SERGY STOUK                                               
# SUBMITTED: Sunday, December 10, 2000                                                  
#####################################################################
sub CONVERT_DATE
{
my($partime) = $_[0];
my($date_format) = $_[1];
my($SECONDS) = 0;
my($MINUTES) = 0;
my($HOUR) = 0;
my($MONTHDAY)= 0;
my($WEEKDAY) = 0;
my($YEARDAY) = 0;
my($YEAR) = 0;
my($MONTH) = 0;
my($DAY) = 0;
my($result) = "";

($SECONDS,$MINUTES,$HOUR,$MONTHDAY,$MONTH,$YEAR,$WEEKDAY,$YEARDAY,$DST_FLAG)=localtime($partime);
$YEAR = $YEAR + 1900;
$MONTH = $MONTH + 1;

if ($HOUR > 11 ){$HOUR_ID = "PM"} else {$HOUR_ID = "AM"};
if ($MONTHDAY < 10 ) {$MONTHDAY = "0"."$MONTHDAY"};
if ($MONTH < 10 ) {$MONTH = "0"."$MONTH"};
if ($HOUR < 10 ) {$HOUR = "0"."$HOUR"};
if ($MINUTES < 10 ) {$MINUTES = "0"."$MINUTES"};
if ($SECONDS < 10 ) {$SECONDS = "0"."$SECONDS"};
if ($WEEKDAY < 10 ) {$WEEKDAY = "0"."$WEEKDAY"};

# Unformatted. Example - Sun Nov 19 16:26:38 2000
if ($date_format == 0) {$result = localtime($partime)};

# General. Example - 11/19/2000 4:26:38 PM
if ($date_format == 1) {
        $HOUR = GET_12_HOUR_TIME($HOUR);
        $result = "$MONTH"."/"."$MONTHDAY"."/"."$YEAR"." "."$HOUR".":"."$MINUTES".":"."$SECONDS"." $HOUR_ID" 
         };

# Long date. Example - Sunday, November 19, 2000
if ($date_format == 2) {
        $WEEKDAY = GET_WEEKDAY_LONG_NAME($WEEKDAY);
        $MONTH = GET_MONTH_LONG_NAME($MONTH);
        $result = "$WEEKDAY".", "."$MONTH"." "."$MONTHDAY".", "."$YEAR"};
        
# Medium Date. Example - 19-Nov-2000
if ($date_format == 3) {
        $MONTH = GET_MONTH_SHORT_NAME($MONTH);
        $result = "$MONTHDAY"."-"."$MONTH"."-"."$YEAR"};
        
# Short date. Example - 11/19/2000
if ($date_format == 4) {
        $result = "$MONTH"."/"."$MONTHDAY"."/"."$YEAR"};

# Long Time. Example - 16:45:09
if ($date_format == 5) {
        $result = "$HOUR".":"."$MINUTES".":"."$SECONDS"};

# Medium Time. Example - 4:45 PM
if ($date_format == 6) {
        $HOUR = GET_12_HOUR_TIME($HOUR);
        $result = "$HOUR".":"."$MINUTES"." $HOUR_ID"};
# Short Time. Example - 16:45
if ($date_format == 7) {
        $result = "$HOUR".":"."$MINUTES"};

return $result;

# BELOW IS A BUNCH OF SUBROUTINES TO SERVE THE DATE FORMAT CHANGE
sub GET_12_HOUR_TIME
{
my($HOUR) = $_[0];
if ($HOUR == 0) {$HOUR = 12};
if ($HOUR > 12) {$HOUR = $HOUR - 12};
return $HOUR;
};

sub GET_WEEKDAY_LONG_NAME
{
my($WEEKDAY) = $_[0];
if ($WEEKDAY == 0) {$WEEKDAY = "Sunday"};
if ($WEEKDAY == 1) {$WEEKDAY = "Monday"};
if ($WEEKDAY == 2) {$WEEKDAY = "Tuesday"};
if ($WEEKDAY == 3) {$WEEKDAY = "Wednsday"};
if ($WEEKDAY == 4) {$WEEKDAY = "Thursday"};
if ($WEEKDAY == 5) {$WEEKDAY = "Friday"};
if ($WEEKDAY == 6) {$WEEKDAY = "Saturday"};
return $WEEKDAY;
};

sub GET_WEEKDAY_SHORT_NAME
{
my($WEEKDAY) = $_[0];
if ($WEEKDAY == 0) {$WEEKDAY = "Sun"};
if ($WEEKDAY == 1) {$WEEKDAY = "Mon"};
if ($WEEKDAY == 2) {$WEEKDAY = "Tue"};
if ($WEEKDAY == 3) {$WEEKDAY = "Wed"};
if ($WEEKDAY == 4) {$WEEKDAY = "Thu"};
if ($WEEKDAY == 5) {$WEEKDAY = "Fri"};
if ($WEEKDAY == 6) {$WEEKDAY = "Sat"};
return $WEEKDAY;
};

sub GET_MONTH_LONG_NAME
{
my($MONTH) = $_[0];
if ($MONTH == 1) {$MONTH = "January"};
if ($MONTH == 2) {$MONTH = "February"};
if ($MONTH == 3) {$MONTH = "March"};
if ($MONTH == 4) {$MONTH = "April"};
if ($MONTH == 5) {$MONTH = "May"};
if ($MONTH == 6) {$MONTH = "June"};
if ($MONTH == 7) {$MONTH = "July"};
if ($MONTH == 8) {$MONTH = "August"};
if ($MONTH == 9) {$MONTH = "September"};
if ($MONTH == 10) {$MONTH = "October"};
if ($MONTH == 11) {$MONTH = "November"};
if ($MONTH == 12) {$MONTH = "December"};
return $MONTH;
};

sub GET_MONTH_SHORT_NAME
{
my($MONTH) = $_[0];
if ($MONTH == 1) {$MONTH = "Jan"};
if ($MONTH == 2) {$MONTH = "Feb"};
if ($MONTH == 3) {$MONTH = "Mar"};
if ($MONTH == 4) {$MONTH = "Apr"};
if ($MONTH == 5) {$MONTH = "May"};
if ($MONTH == 6) {$MONTH = "Jun"};
if ($MONTH == 7) {$MONTH = "Jul"};
if ($MONTH == 8) {$MONTH = "Aug"};
if ($MONTH == 9) {$MONTH = "Sep"};
if ($MONTH == 10) {$MONTH = "Oct"};
if ($MONTH == 11) {$MONTH = "Nov"};
if ($MONTH == 12) {$MONTH = "Dec"};
return $MONTH;
};

# END OF FUNCTION GET_DATE
};
#####################################################################
# END OF:010                                               
#####################################################################
#####################################################################
# ID:022                                                   
# TITLE:Function - Save Array Parameter to file (SAVE_TO_FILE)                                                   
# SUBMITTED BY: SERGY STOUK                                         
# DATE: Monday, December 11, 2000                                                       
#####################################################################
sub SAVE_FILE
{
my($filename) = $_[0];
my(@send) = @_[1..@_-1];
my($count) = 0;

open (FILE, ">$filename") || die "Can’t write to $filename: error $!\n";
while ($count < @_)
{
print FILE $send[$count];
$count++
};
close FILE;
return $count;
};
#####################################################################
# END OF:022                                               
#####################################################################
  
   


#####################################################################
# ID:024                                                   
# TITLE:Function - READ_FROM_FILE - Reads data from file and returns as an array.                                                   
# SUBMITTED BY: SERGY STOUK                                         
# DATE: Monday, December 11, 2000                                                       
#####################################################################
sub READ_FILE 
{ 
my($filename) = $_[0]; 
my($count) = 0; 
my(@result) = undef; 
open (INPUT, "$filename") || die "Could not open file $filename : $!\n"; 
while (<INPUT>) 
{ 
($result[$count]) =$_; 
$count++; 
}; 
close (INPUT); 
return @result; 
};
#####################################################################
# END OF:024                                               
#####################################################################  

#####################################################################
# ID:081                                                   
# TITLE:Function - SAVE_TO_REPORT                                                   
# SUBMITTED BY: SERGY STOUK                                         
# DATE: Thursday, June 21, 2001                                                       
#####################################################################
sub SAVE_REPORT 
{ 
my($filename) = $_[0]; 
my(@send) = @_[1..@_-1]; 
my($count) = 0; 
my($totallines) = 0; 
if ($filename)
{
    open (FILE, ">>$filename") || die "Can’t write to $filename: error $!\n"; 
    while ($count < @_) 
    { 
    print FILE $send[$count]; 
    $count++ 
    }; 
    close FILE; 
};
return $count;
};
#####################################################################
# END OF:081                                               
#####################################################################
  
     
return 1;