//
// Copyright (c) 2009-2010, ERICSSON AB All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the ERICSSON AB nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
// BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
#include "feldspar_tic64x.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
/*--------------------------------------------------------------------------*
* pow(), abs(), signum() *
*--------------------------------------------------------------------------*/
char pow_fun_char( char a, char b )
{
char r = 1;
int i;
if (b < 0) {
fprintf(stderr, "Negative exponent in function pow_fun_(): %d `pow` %d", a, b);
exit(1);
}
for(i = 0; i < b; ++i)
r *= a;
return r;
}
short pow_fun_short( short a, short b )
{
short r = 1;
int i;
if (b < 0) {
fprintf(stderr, "Negative exponent in function pow_fun_(): %d `pow` %d", a, b);
exit(1);
}
for(i = 0; i < b; ++i)
r *= a;
return r;
}
int pow_fun_int( int a, int b )
{
int r = 1;
int i;
if (b < 0) {
fprintf(stderr, "Negative exponent in function pow_fun_(): %d `pow` %d", a, b);
exit(1);
}
for(i = 0; i < b; ++i)
r *= a;
return r;
}
long pow_fun_long( long a, long b )
{
long r = 1;
int i;
if (b < 0) {
fprintf(stderr, "Negative exponent in function pow_fun_(): %ld `pow` %ld", a, b);
exit(1);
}
for(i = 0; i < b; ++i)
r *= a;
return r;
}
long long pow_fun_llong( long long a, long long b )
{
long long r = 1;
int i;
if (b < 0) {
fprintf(stderr, "Negative exponent in function pow_fun_(): %lld `pow` %lld", a, b);
exit(1);
}
for(i = 0; i < b; ++i)
r *= a;
return r;
}
unsigned char pow_fun_uchar( unsigned char a, unsigned char b )
{
unsigned char r = 1;
int i;
for(i = 0; i < b; ++i)
r *= a;
return r;
}
unsigned short pow_fun_ushort( unsigned short a, unsigned short b )
{
unsigned short r = 1;
int i;
for(i = 0; i < b; ++i)
r *= a;
return r;
}
unsigned pow_fun_uint( unsigned a, unsigned b )
{
unsigned r = 1;
int i;
for(i = 0; i < b; ++i)
r *= a;
return r;
}
unsigned long pow_fun_ulong( unsigned long a, unsigned long b )
{
unsigned long r = 1;
int i;
for(i = 0; i < b; ++i)
r *= a;
return r;
}
unsigned long long pow_fun_ullong( unsigned long long a, unsigned long long b )
{
unsigned long long r = 1;
int i;
for(i = 0; i < b; ++i)
r *= a;
return r;
}
char abs_fun_char( char a )
{
// From Bit Twiddling Hacks:
// "Compute the integer absolute value (abs) without branching"
char mask = a >> 7;
return (a + mask) ^ mask;
}
short abs_fun_short( short a )
{
// From Bit Twiddling Hacks:
// "Compute the integer absolute value (abs) without branching"
short mask = a >> 15;
return (a + mask) ^ mask;
}
long abs_fun_long( long a )
{
// From Bit Twiddling Hacks:
// "Compute the integer absolute value (abs) without branching"
long mask = a >> 39;
return (a + mask) ^ mask;
}
long long abs_fun_llong( long long a )
{
// From Bit Twiddling Hacks:
// "Compute the integer absolute value (abs) without branching"
long long mask = a >> 63;
return (a + mask) ^ mask;
}
char signum_fun_char( char a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a != 0) | (a >> 7);
}
short signum_fun_short( short a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a != 0) | (a >> 15);
}
int signum_fun_int( int a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a != 0) | (a >> 31);
}
long signum_fun_long( long a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a != 0) | (a >> 39);
}
long long signum_fun_llong( long long a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a != 0) | (a >> 63);
}
unsigned char signum_fun_uchar( unsigned char a )
{
return (a > 0);
}
unsigned short signum_fun_ushort( unsigned short a )
{
return (a > 0);
}
unsigned signum_fun_uint( unsigned a )
{
return (a > 0);
}
unsigned long signum_fun_ulong( unsigned long a )
{
return (a > 0);
}
unsigned long long signum_fun_ullong( unsigned long long a )
{
return (a > 0);
}
float signum_fun_float( float a )
{
// From Bit Twiddling Hacks: "Compute the sign of an integer"
return (a > 0) - (a < 0);
}
/*--------------------------------------------------------------------------*
* Bit operations *
*--------------------------------------------------------------------------*/
char setBit_fun_char( char x, int i )
{
return x | 1 << i;
}
short setBit_fun_short( short x, int i )
{
return x | 1 << i;
}
int setBit_fun_int( int x, int i )
{
return x | 1 << i;
}
long setBit_fun_long( long x, int i )
{
return x | 1 << i;
}
long long setBit_fun_llong( long long x, int i )
{
return x | 1 << i;
}
unsigned char setBit_fun_uchar( unsigned char x, int i )
{
return x | 1 << i;
}
unsigned short setBit_fun_ushort( unsigned short x, int i )
{
return x | 1 << i;
}
unsigned setBit_fun_uint( unsigned x, int i )
{
return x | 1 << i;
}
unsigned long setBit_fun_ulong( unsigned long x, int i )
{
return x | 1 << i;
}
unsigned long long setBit_fun_ullong( unsigned long long x, int i )
{
return x | 1 << i;
}
char clearBit_fun_char( char x, int i )
{
return x & ~(1 << i);
}
short clearBit_fun_short( short x, int i )
{
return x & ~(1 << i);
}
int clearBit_fun_int( int x, int i )
{
return x & ~(1 << i);
}
long clearBit_fun_long( long x, int i )
{
return x & ~(1 << i);
}
long long clearBit_fun_llong( long long x, int i )
{
return x & ~(1 << i);
}
unsigned char clearBit_fun_uchar( unsigned char x, int i )
{
return x & ~(1 << i);
}
unsigned short clearBit_fun_ushort( unsigned short x, int i )
{
return x & ~(1 << i);
}
unsigned clearBit_fun_uint( unsigned x, int i )
{
return x & ~(1 << i);
}
unsigned long clearBit_fun_ulong( unsigned long x, int i )
{
return x & ~(1 << i);
}
unsigned long long clearBit_fun_ullong( unsigned long long x, int i )
{
return x & ~(1 << i);
}
char complementBit_fun_char( char x, int i )
{
return x ^ 1 << i;
}
short complementBit_fun_short( short x, int i )
{
return x ^ 1 << i;
}
int complementBit_fun_int( int x, int i )
{
return x ^ 1 << i;
}
long complementBit_fun_long( long x, int i )
{
return x ^ 1 << i;
}
long long complementBit_fun_llong( long long x, int i )
{
return x ^ 1 << i;
}
unsigned char complementBit_fun_uchar( unsigned char x, int i )
{
return x ^ 1 << i;
}
unsigned short complementBit_fun_ushort( unsigned short x, int i )
{
return x ^ 1 << i;
}
unsigned complementBit_fun_uint( unsigned x, int i )
{
return x ^ 1 << i;
}
unsigned long complementBit_fun_ulong( unsigned long x, int i )
{
return x ^ 1 << i;
}
unsigned long long complementBit_fun_ullong( unsigned long long x, int i )
{
return x ^ 1 << i;
}
int testBit_fun_char( char x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_short( short x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_int( int x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_long( long x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_llong( long long x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_uchar( unsigned char x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_ushort( unsigned short x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_uint( unsigned x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_ulong( unsigned long x, int i )
{
return (x & 1 << i) != 0;
}
int testBit_fun_ullong( unsigned long long x, int i )
{
return (x & 1 << i) != 0;
}
char rotateL_fun_char( char x, int i )
{
if ((i %= 8) == 0) return x;
return (x << i) | ((0x7f >> (7 - i)) & (x >> (8 - i)));
}
short rotateL_fun_short( short x, int i )
{
if ((i %= 16) == 0) return x;
return (x << i) | ((0x7fff >> (15 - i)) & (x >> (16 - i)));
}
int rotateL_fun_int( int x, int i )
{
return (int)_rotl((unsigned)x, (unsigned)i);
/* if ((i %= 32) == 0) return x;
return (x << i) | ((0x7fffffff >> (31 - i)) & (x >> (32 - i)));*/
}
long rotateL_fun_long( long x, int i )
{
if ((i %= 40) == 0) return x;
return (x << i) | ((0x7fffffffffl >> (39 - i)) & (x >> (40 - i)));
}
long long rotateL_fun_llong( long long x, int i )
{
if ((i %= 64) == 0) return x;
return (x << i) | ((0x7fffffffffffffffll >> (63 - i)) & (x >> (64 - i)));
}
unsigned char rotateL_fun_uchar( unsigned char x, int i )
{
if ((i %= 8) == 0) return x;
return (x << i) | (x >> (8 - i));
}
unsigned short rotateL_fun_ushort( unsigned short x, int i )
{
if ((i %= 16) == 0) return x;
return (x << i) | (x >> (16 - i));
}
unsigned long rotateL_fun_ulong( unsigned long x, int i )
{
if ((i %= 40) == 0) return x;
return (x << i) | (x >> (40 - i));
}
unsigned long long rotateL_fun_ullong( unsigned long long x, int i )
{
if ((i %= 64) == 0) return x;
return (x << i) | (x >> (64 - i));
}
char rotateR_fun_char( char x, int i )
{
if ((i %= 8) == 0) return x;
return (x << (8 - i)) | ((0x7f >> (i - 1)) & (x >> i));
}
short rotateR_fun_short( short x, int i )
{
if ((i %= 16) == 0) return x;
return (x << (16 - i)) | ((0x7fff >> (i - 1)) & (x >> i));
}
int rotateR_fun_int( int x, int i )
{
if ((i %= 32) == 0) return x;
return (x << (32 - i)) | ((0x7fffffff >> (i - 1)) & (x >> i));
}
long rotateR_fun_long( long x, int i )
{
if ((i %= 40) == 0) return x;
return (x << (40 - i)) | ((0x7fffffffffl >> (i - 1)) & (x >> i));
}
long long rotateR_fun_llong( long long x, int i )
{
if ((i %= 64) == 0) return x;
return (x << (64 - i)) | ((0x7fffffffffffffffll >> (i - 1)) & (x >> i));
}
unsigned char rotateR_fun_uchar( unsigned char x, int i )
{
if ((i %= 8) == 0) return x;
return (x << (8 - i)) | (x >> i);
}
unsigned short rotateR_fun_ushort( unsigned short x, int i )
{
if ((i %= 16) == 0) return x;
return (x << (16 - i)) | (x >> i);
}
unsigned rotateR_fun_uint( unsigned x, int i )
{
if ((i %= 32) == 0) return x;
return (x << (32 - i)) | (x >> i);
}
unsigned long rotateR_fun_ulong( unsigned long x, int i )
{
if ((i %= 40) == 0) return x;
return (x << (40 - i)) | (x >> i);
}
unsigned long long rotateR_fun_ullong( unsigned long long x, int i )
{
if ((i %= 64) == 0) return x;
return (x << (64 - i)) | (x >> i);
}
char reverseBits_fun_char( char x )
{
char r = x;
int i = 7;
for (x = x >> 1 & 0x7f; x; x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
short reverseBits_fun_short( short x )
{
short r = x;
int i = 15;
for (x = x >> 1 & 0x7fff; x; x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
int reverseBits_fun_int( int x )
{
int r = x;
int i = 31;
for (x = x >> 1 & 0x7fffffff; x; x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
long reverseBits_fun_long( long x )
{
long r = x;
int i = 39;
for (x = x >> 1 & 0x7fffffffffl; x; x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
long long reverseBits_fun_llong( long long x )
{
long long r = x;
int i = 63;
for (x = x >> 1 & 0x7fffffffffffffffll; x; x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
unsigned char reverseBits_fun_uchar( unsigned char x )
{
unsigned char r = x;
int i = 7;
while (x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return x << i;
}
unsigned short reverseBits_fun_ushort( unsigned short x )
{
unsigned short r = x;
int i = 15;
while (x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
unsigned long reverseBits_fun_ulong( unsigned long x )
{
unsigned long r = x;
int i = 39;
while (x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
unsigned long long reverseBits_fun_ullong( unsigned long long x )
{
unsigned long long r = x;
int i = 63;
while (x >>= 1)
{
r = (r << 1) | (x & 1);
--i;
}
return r << i;
}
int bitScan_fun_char( char x )
{
int r = 0;
char s = (x & 0x80);
if (x == 0) return 7;
while (((x <<= 1) & 0x80) == s)
++r;
return r;
}
int bitScan_fun_short( short x )
{
int r = 0;
short s = (x & 0x8000);
if (x == 0) return 15;
while (((x <<= 1) & 0x8000) == s)
++r;
return r;
}
int bitScan_fun_int( int x )
{
int r = 0;
int s = (x & 0x80000000);
if (x == 0) return 31;
while (((x <<= 1) & 0x80000000) == s)
++r;
return r;
}
int bitScan_fun_long( long x )
{
int r = 0;
long s = (x & 0x8000000000l);
if (x == 0) return 39;
while (((x <<= 1) & 0x8000000000l) == s)
++r;
return r;
}
int bitScan_fun_llong( long long x )
{
int r = 0;
long long s = (x & 0x8000000000000000ll);
if (x == 0) return 63;
while (((x <<= 1) & 0x8000000000000000ll) == s)
++r;
return r;
}
int bitScan_fun_uchar( unsigned char x )
{
int r = 8;
while (x)
{
--r;
x >>= 1;
}
return r;
}
int bitScan_fun_ushort( unsigned short x )
{
int r = 16;
while (x)
{
--r;
x >>= 1;
}
return r;
}
int bitScan_fun_uint( unsigned x )
{
int r = 32;
while (x)
{
--r;
x >>= 1;
}
return r;
}
int bitScan_fun_ulong( unsigned long x )
{
int r = 40;
while (x)
{
--r;
x >>= 1;
}
return r;
}
int bitScan_fun_ullong( unsigned long long x )
{
int r = 64;
while (x)
{
--r;
x >>= 1;
}
return r;
}
int bitCount_fun_char( char x )
{
int r = x & 1;
for (x = x >> 1 & 0x7f; x; x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_short( short x )
{
int r = x & 1;
for (x = x >> 1 & 0x7fff; x; x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_int( int x )
{
int r = x & 1;
for (x = x >> 1 & 0x7fffffff; x; x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_long( long x )
{
int r = x & 1;
for (x = x >> 1 & 0x7fffffffffl; x; x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_llong( long long x )
{
int r = x & 1;
for (x = x >> 1 & 0x7fffffffffffffffll; x; x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_uchar( unsigned char x )
{
int r = x & 1;
while (x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_ushort( unsigned short x )
{
int r = x & 1;
while (x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_ulong( unsigned long x )
{
int r = x & 1;
while (x >>= 1)
r += x & 1;
return r;
}
int bitCount_fun_ullong( unsigned long long x )
{
int r = x & 1;
while (x >>= 1)
r += x & 1;
return r;
}
/*--------------------------------------------------------------------------*
* copy_arrayOf() *
*--------------------------------------------------------------------------*/
void copy_arrayOf_char( char* a, int a1, char* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_short( short* a, int a1, short* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_int( int* a, int a1, int* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_long( long* a, int a1, long* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_llong( long long* a, int a1, long long* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_uchar( unsigned char* a, int a1, unsigned char* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_ushort( unsigned short* a, int a1, unsigned short* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_uint( unsigned* a, int a1, unsigned* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_ulong( unsigned long* a, int a1, unsigned long* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_ullong( unsigned long long* a, int a1, unsigned long long* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
void copy_arrayOf_float( float* a, signed int a1, float* b )
{
int i;
for(i = 0; i < a1; ++i)
b[i] = a[i];
}
/*--------------------------------------------------------------------------*
* Trace functions *
*--------------------------------------------------------------------------*/
static FILE *trace_log_file;
static time_t trace_start_time;
void traceStart()
{
char timestr [80];
char str [256];
struct tm * timeinfo;
trace_start_time = time(NULL);
timeinfo = localtime(&(trace_start_time));
strftime(timestr, 80, "%Y%m%d-%H%M%S", timeinfo);
sprintf(str, "trace-%s.log", timestr);
trace_log_file = fopen(str, "a");
if (trace_log_file == NULL) {
fprintf(stderr,"Can not open trace file.\n");
exit (8);
}
strftime(timestr, 80, "%d-%b-%Y %H:%M:%S", timeinfo);
fprintf(trace_log_file, "The logging started at %s.\n", timestr);
fflush(trace_log_file);
trace_start_time = time(NULL);
}
inline void elapsedTimeString( char* str )
{
sprintf(str, "%ld.000", time(NULL) - trace_start_time);
}
void traceEnd()
{
fprintf(trace_log_file, "The logging finished.\n");
fclose(trace_log_file);
}
void trace_char( char val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%d\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_short( short val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%d\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_int( int val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%d\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_long( long val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%ld\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_llong( long long val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%lld\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_uchar( unsigned char val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%u\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_ushort( unsigned short val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%u\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_uint( unsigned val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%u\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_ulong( unsigned long val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%lu\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_ullong( unsigned long long val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%llu\n", id, timestr, val);
fflush(trace_log_file);
}
void trace_float( float val, int id )
{
char timestr [80];
elapsedTimeString(timestr);
fprintf(trace_log_file, "id=%d, time=%s, value=%f\n", id, timestr, val);
fflush(trace_log_file);
}