/*
 * Sample Program for microVIEW-G(x)
 * <<< samp2.c >>>
 * 1995 @ advice Yokogawa Digital Computer Corp.
 */

/*
 * Include Files
 */

#include        "samp0.h"
#include        "samp1.h"
#include        "samp2.h"

/*	#include		<string.h>	*/					/* 98.08.04	*/

/*
 * Counter function
 */

#define         ADV0    0x0
#define         ADV1    0x1
#define         ADV2    0x2
#define         ADV3    0x3
#define         ADV4    0x4
#define         ADV5    0x5
#define         ADV6    0x6
#define         ADV7    0x7
#define         ADV8    0x8
#define         ADV9    0x9
#define         ADVa    0xa
#define         ADVb    0xb
#define         ADVc    0xc
#define         ADVd    0xd
#define         ADVe    0xe
#define         ADVf    0xf
#define         REAL_DEBUG      98765.4321
#define         REAL_ZERO       0.0
#define         ADVICE          "advice"

void Counter(void)
{
    struct LBITFLD {		/* LOCAL VARIABLE'S STRUCTER in FUNCTION */ 
	int             q1:5;
	int             q2:4;
	int             x3:3;
    } lbitfld;

//	union UBITFLD{			/* LOCAL VARIABLE'S UNION in FUNCTION */
//	int			x1:3;
//	int			x2:4;
//	int			q3:5;
//	} ubitfld;

    unsigned short      cnt;
    int                 dummy;

    STRcpy(MasterStr,ADVICE);

    lbitfld.q2 = 0xA;
    bitfld.m2 = lbitfld.q2;
    
//    ubitfld.q3 = 0xb;
//    bitfld.m3 = ubitfld.q3;
    
    for (cnt = 0; cnt < COUNT_MAX; cnt++) {
	dummy = ADV0;
	dummy = ADV1;
	dummy = ADV2;
	dummy = ADV3;
	dummy = ADV4;
	dummy = ADV5;
	dummy = ADV6;
	dummy = ADV7;
	dummy = ADV8;
	dummy = ADV9;
	dummy = ADVa;
	dummy = ADVb;
	dummy = ADVc;
	dummy = ADVd;
	dummy = ADVe;
	dummy = ADVf;
    }
    SystemCounter = SystemCounter + 0.1;
    if (SystemCounter > REAL_DEBUG) {
	SystemCounter = REAL_ZERO;
    }
    if ((GlobalCounter--) == 0) {
	GlobalCounter = MAXSHORT;
    }
    if (++InterCounter > MAXLONG) {
	InterCounter = 0;
    }
    return;
}

/*
 * String copy
 */

int     STRcpy( char d[], char s[])
{
    int         i,j;

    for (i=0,j=0;;i++) {
	d[j++] = s[i];
	if (s[i] == '\0') break;
	else if (s[i] < ' ') return(-1);
    }
    return(j);
}

/*
 * Sort data
 */

int Sortbybig(struct SAMP_DATA data[], int n)
{
	int i, j, k;
	int rcd;

    for(i = 0; i < n; i++) {
	k = i;
	for(j = i + 1; j < n; j++) {
	    rcd = BiggerThan( data[j].big, data[k].big );
	    if ( rcd < 0) {
		k = j;
	    }
	}
	if(i != k) {
	    SwapStr(data[i].big,   data[k].big);
	    SwapStr(data[i].small, data[k].small);
	}
    }
    return(0);
}

int Sortbysmall(struct SAMP_DATA data[], int n)
{
	int i, j, k;
	int rcd;

    for(i = 0; i < n; i++) {
	k = i;
	for(j = i + 1; j < n; j++) {
	    rcd = BiggerThan( data[j].small, data[k].small );
	    if (rcd < 0) {
		k = j;
	    }
	}
	if(i != k) {
	    SwapStr(data[i].big,   data[k].big);
	    SwapStr(data[i].small, data[k].small);
	}
    }
    return(0);
}

/*
 * Swap String Data
 */

int SwapStr(char *d1, char *d2)
{
	char tmp[CHAR_SIZE];

    strcpy(tmp,d1);
    strcpy(d1,d2);
    strcpy(d2,tmp);
    return(0);
}

/*
 * Compare Strings
 */

#define         NULL    '\0'

int     BiggerThan( char s1[], char s2[])
{
    int         i;
    int         rcd;
    
    for (i=0; ;i++) {
	if (s1[i] == NULL) {
	    if (s2[i] == NULL) {
		rcd = 0;
		goto RET_FUNC;
	    } else {
		rcd = -1;
		goto RET_FUNC;
	    }
	}
	else {
	    if (s2[i] == NULL) {
		rcd = 1;
		goto RET_FUNC;
	    }
	}
    }

RET_FUNC:
    return(rcd);
}


/*
 * Change Lower to Upper strings
 */

#define         ASCa    'a'
#define         ASCz    'z'
#define         ASC_SP  0x20

int  StrToUp( char s[])
{
    int     i;

    for (i=0;;i++) {
	if ( ASCa <= s[i] && s[i] <= ASCz ) {
	    s[i] = (char)(s[i] + ASC_SP);
	}
	else if (s[i] == NULL) {
	    break;
	}
	else {
	    ;
	}
    }
    return(i);
}

/*
 * Change Upper to Lower strings
 */

#define         aASC    'A'
#define         zASC    'Z'

int  StrToLow( char s[])
{
    int     i;

    for (i=0; ; i++) {
	if (aASC <= s[i] && s[i] <= zASC) {
	    s[i] = (char)(s[i] - ASC_SP);
	}
	else if (s[i] == NULL) {
	    break;
	}
	else {
	    ;
	}
    }
    return(i);
}

/*
 * Compare Strings
 *    if s1 bigger than s2, return positive.
 */

int CmpStr( char s1[], char s2[])
{
    int     i, rcd;

    for (i=0;;i++) {
	if (s1[i] == s2[i]) {
	    rcd = 0;
	}
	else if (s1[i] < s2[i]) {
	    rcd = -1;
	    break;
	}
	else {
	    rcd = 1;
	    break;
	}
    }
    return(rcd);
}

/*
 * Small Data Processing
 */

int SmallExec( struct SAMP_DATA *data)
{
    int i;

    for (i=0; i<SAMP_DATA_MAX; i++) {
	StrToUp( data->small );
    }
    return(i);
}

/*
 * Big Data Processing
 */
/*	double BigExec ( struct SAMP_DATA *data, double cnt, char c0, char c1, char c2, char c3)	*/

double BigExec ( struct SAMP_DATA *data, double cnt, char c0, char c1, char c2, char c3 )
{                                       
    int i;

    for (i=0; i<SAMP_DATA_MAX; i++) {
	if (cnt < (double)(32767.0)) {
	    if (c0 != '?' && c1 != '?' && c2 != '?' && c3 != NULL) {
		StrToLow( data->big );
	    }
	}
	else {
	    StrToLow ( data -> big ) ;
	}
    }
    return(cnt);
}

float Divide ( int s )
{
    double      dret, seed ;
    float       fret;

    seed = 2.0;

    dret = (double)( s ) / seed;
    fret = (float)dret;

    return(fret);

}

float  Multiplication( int s )
{
    float       fret;
    double      dret, seed;

    seed = 2.0;

    dret = (double)( s ) * seed;
    fret = (float)dret;

    return (fret);
}

float Square( int s )
{
    float       fret;
    double      dret;

    dret = (double)( s * s );
    fret = (float)dret;

    return(fret);
}
/* EOF */