/*
 * read stoichiometric matrix file and searches exchange reactions
 * exchange reactions are defined as those reactions that have only positive
 * or only negative values
 */
void defineExchangeReactions(int *cols, char** exchange_reaction, double
        threshold, char* filename)
{
    double n_thres = -1 * threshold;
    FILE *rx_file = fopen(filename, "r");
    if (!rx_file)
    {
        quitError("Error in opening file\n", ERROR_FILE);
    }
    int rx_count = getRxCount(rx_file);
    fclose(rx_file);
    char* line = NULL;
    size_t len = 0;
    unsigned long bitarray_size = getBitsize(rx_count);
    char* m_exchange_reaction = calloc(1, bitarray_size);
    char* m_pos = calloc(1, bitarray_size);
    char* m_neg = calloc(1, bitarray_size);
    FILE *file = fopen(filename, "r");
    if (!file)
    {
        quitError("Error in opening file\n", ERROR_FILE);
    }
    while ( getline(&line, &len, file) != -1)
    {
        char *ptr;
        ptr = strtok(line, "\n\t ");
        int i = 0;
        while(ptr != NULL) 
        {
            double val = atof(ptr);
            // positive value
            if (val > threshold)
            {
                BITSET(m_pos, i);
            }
            // negative value
            else if (val < n_thres)
            {
                BITSET(m_neg,i);
            }
            i++;
            ptr = strtok(NULL, "\n\t ");
        }
    }
    free(line);
    line = NULL;
    fclose(file);
    int i;
    for (i = 0; i < rx_count; i++) {
        // check if reaction have positive and negative values
        if ( (BITTEST(m_pos,i) && !BITTEST(m_neg,i)) || (!BITTEST(m_pos,i) && BITTEST(m_neg,i)) )
        {
            BITSET(m_exchange_reaction, i);
        }
    }
    free(m_pos);
    free(m_neg);
    *cols = rx_count;
    *exchange_reaction = m_exchange_reaction;
}

/**************************************************************************
DOES:    Determines source of reset.
RETURNS: 0=power-up, 1=external, 2=brown-out, 3=watchdog, 4=J-Tag, 5=jump
**************************************************************************/
static UNSIGNED8 MAIN_Get_Start_Code(void)
{
  UNSIGNED8 return_val;

  if (BITSET(MCUSR,JTRF))
  { 
     return_val = 4;
  }
  else if (BITSET(MCUSR,WDRF))
  { 
     return_val = 3;
  }
  else if (BITSET(MCUSR,BORF))
  { 
    return_val = 2;
  }
  else if (BITSET(MCUSR,EXTRF))
  { 
     return_val = 1;
  }
  else if (BITSET(MCUSR,PORF))
  { 
     return_val = 0;
  }
  else
  { 
    return_val = 5;
  }

  // Reset MCU Status Register
  MCUSR = 0x00;

  return (return_val);
}

static void
tcc88xx_osmr0_set_mode(enum clock_event_mode mode, struct clock_event_device *c)
{
	unsigned long flags;

#if defined(TICKLESS_DEBUG_TCC)
	printk("%s: mode %s... %d\n", __func__,
	       mode == CLOCK_EVT_MODE_ONESHOT  ? "ONESHOT"   :
	       mode == CLOCK_EVT_MODE_UNUSED   ? "UNUSED"    :
	       mode == CLOCK_EVT_MODE_SHUTDOWN ? "SHUTDOWN"  :
	       mode == CLOCK_EVT_MODE_RESUME   ? "RESUME"    :
	       mode == CLOCK_EVT_MODE_PERIODIC ? "PERIODIC"  : "non",
	       gTimer_cnt++);
#endif

	switch (mode) {
	case CLOCK_EVT_MODE_ONESHOT:
	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
		raw_local_irq_save(flags);
		BITCLR(pTIMER->TC32IRQ, Hw16);			/* Disable interrupt when the counter value matched with CMP0 */
		BITSET(pPIC->CLR0, TCC_ENABLE_BIT(INT_TC32));	/* PIC Interrupt clear */
		if(pTIMER->TC32IRQ & Hw31)			/* IRQ clear */
			BITSET(pTIMER->TC32IRQ, Hw31);
		raw_local_irq_restore(flags);
		break;

	case CLOCK_EVT_MODE_RESUME:
	case CLOCK_EVT_MODE_PERIODIC:
		break;
	}
}

void apply_mark_flagstates(struct apply_handle *h) {
    int i;
    struct fsm_state *fsm;

    /* Create bitarray with those states that have a flag symbol on an arc */
    /* This is needed to decide whether we can perform a binary search.    */

    if (!h->has_flags || h->flag_lookup == NULL) {
	return;
    }
    if (h->flagstates) {
	xxfree(h->flagstates);
    }
    h->flagstates = xxcalloc(BITNSLOTS(h->last_net->statecount), sizeof(uint8_t));
    fsm = h->last_net->states;
    for (i=0; (fsm+i)->state_no != -1; i++) {
	if ((fsm+i)->target == -1) { 
	    continue;
	}
	if ((h->flag_lookup+(fsm+i)->in)->type) {
	    BITSET(h->flagstates,(fsm+i)->state_no);
	}
	if ((h->flag_lookup+(fsm+i)->out)->type) {
	    BITSET(h->flagstates,(fsm+i)->state_no);
	}
    }
}

BOOL
CHyperLink:: ModifyLinkStyle( DWORD dwRemove, DWORD dwAdd,
                             BOOL bApply /* =TRUE */ )
{
   // Check if we are adding and removing the same style.
   if ( (dwRemove & dwAdd) != 0 )
      return( FALSE );

   // Remove old styles and set the new ones
   CLEARBITS( m_dwStyle, dwRemove );
   SETBITS( m_dwStyle, dwAdd );

   if ( bApply && mIs_hWnd( GetSafeHwnd( ) ) )
   {
      // If possible, APPLY the new styles on the fly.
      if ( BITSET( dwAdd, StyleUnderline ) ||
           BITSET( dwRemove, StyleUnderline ) )
      {
         SwitchUnderline( );
      }

      if ( BITSET( dwAdd, StyleAutoSize ) )
         AdjustWindow( );

      if ( BITSET( dwRemove, StyleUseHover ) )
         Invalidate( );
   }

   return( TRUE );
}

void BloomFilter::add(string item){
  int * keys = this->keys(item);
	BITSET(bitarray, ABS(keys[0]));
	BITSET(bitarray, ABS(keys[1]));
	BITSET(bitarray, ABS(keys[2]));
  delete [] keys;
};

/*****************************************************************************
* Function Name : tca_i2c_setgpio(int ch)
* Description: I2C port configuration
* input parameter:
* 		int core; 	// I2C Core
*       int ch;   	// I2C master channel
******************************************************************************/
void tca_i2c_setgpio(int core, int ch)
{
	PGPIO gpio = (PGPIO)tcc_p2v(HwGPIO_BASE);

	switch (core) {
		case 0:
		{
			if (ch == 0) {
				BITCSET(gpio->GPAFN0, (Hw8-Hw0), Hw4|Hw0);			/* GPIO_A[1:0] */
				BITSET(gpio->GPAEN, Hw1|Hw0);
				BITCLR(gpio->GPADAT, Hw1|Hw0);
			} else if (ch == 1) {
				BITCSET(gpio->GPAFN0, (Hw32-Hw28), Hw28);			/* GPIO_A[7] */
				BITCSET(gpio->GPAFN1, (Hw4-Hw0), Hw0);			    /* GPIO_A[8] */
				BITSET(gpio->GPAEN, Hw8|Hw7);
				BITCLR(gpio->GPADAT, Hw8|Hw7);
			}
			break;
		}
		case 1:
		{
			if (ch == 0) {
                /* Not used */
			} else if (ch == 1) {
                /* Not used */
			}
			break;
		}
	}
}

void CHyperLink::OnLButtonDown(UINT /*nFlags*/, CPoint /*point*/) 
{
	if (BITSET(m_dwStyle,StyleGetFocusOnClick))
		SetFocus();                // Set the focus and make the link active
	if (BITSET(m_dwStyle,StyleDownClick))
		FollowLink();
	m_bLinkActive = TRUE;
}

// Move and resize the window so that its client area has the same size
// as the hyperlink text. This prevents the hyperlink cursor being active
// when it is not over the text.
void
CHyperLink::AdjustWindow( )
{
   ASSERT( mIs_hWnd( GetSafeHwnd( ) ) );

   if ( !BITSET( m_dwStyle, StyleAutoSize ) )
        return;

    // Get the current window rect
    CRect rcWnd;
    GetWindowRect( rcWnd );

   // For a child CWnd object, window rect is relative to the
   // upper-left corner of the parent window’s client area.
    CWnd *pParent = GetParent( );
    if ( pParent )
        pParent->ScreenToClient( rcWnd );

   // Get the current client rect
   CRect rcClient;
   GetClientRect( rcClient );

   // Calc border size based on window and client rects.
   int borderWidth = rcWnd.Width( ) - rcClient.Width( );
   int borderHeight = rcWnd.Height( ) - rcClient.Height( );

   // Get the extent of window text
   CString csWndText;
   GetWindowText( csWndText );

   CDC *pDC = GetDC( );
   CFont *pOldFont = pDC->SelectObject( &m_Font );
   CSize Extent = pDC->GetTextExtent( csWndText );
   pDC->SelectObject( pOldFont );
   ReleaseDC( pDC );

   // Get the text justification style.
   DWORD dwStyle = GetStyle( );

   // Recalc window size and position based on text justification.
   if ( BITSET( dwStyle, SS_CENTERIMAGE ) )
      rcWnd.DeflateRect( 0, (rcWnd.Height( ) - Extent.cy) / 2 );
   else
      rcWnd.bottom = rcWnd.top + Extent.cy;

   if ( BITSET( dwStyle, SS_CENTER ) )
      rcWnd.DeflateRect( (rcWnd.Width( ) - Extent.cx) / 2, 0 );
   else
   if ( BITSET( dwStyle, SS_RIGHT ) )
      rcWnd.left  = rcWnd.right - Extent.cx;
   else // SS_LEFT
      rcWnd.right = rcWnd.left + Extent.cx;

   // Move and resize the window.
   MoveWindow( rcWnd.left, rcWnd.top, rcWnd.Width( ) + borderWidth,
               rcWnd.Height( ) + borderHeight );
}

static irqreturn_t tcc88xx_timer_interrupt(int irq, void *dev_id)
{
#ifndef CONFIG_GENERIC_CLOCKEVENTS
	timer_tick();
#endif

	BITSET(pPIC->CLR0, TCC_ENABLE_BIT(irq));
	if(pTIMER->TC32IRQ & Hw31)
		BITSET(pTIMER->TC32IRQ, Hw31);

	return IRQ_HANDLED;
}

static int eth16i_probe_port(int ioaddr)
{
	int i;
	int retcode;
	unsigned char dummy_packet[64];

	/* Powerup the chip */
	outb(0xc0 | POWERUP, ioaddr + CONFIG_REG_1);

	BITSET(ioaddr + CONFIG_REG_0, DLC_EN);

	eth16i_select_regbank(NODE_ID_RB, ioaddr);

	for(i = 0; i < 6; i++) {
		dummy_packet[i] = inb(ioaddr + NODE_ID_0 + i);
		dummy_packet[i+6] = inb(ioaddr + NODE_ID_0 + i);
	}

	dummy_packet[12] = 0x00;
	dummy_packet[13] = 0x04;
	memset(dummy_packet + 14, 0, sizeof(dummy_packet) - 14);

	eth16i_select_regbank(2, ioaddr);

	for(i = 0; i < 3; i++) {
		BITSET(ioaddr + CONFIG_REG_0, DLC_EN);
		BITCLR(ioaddr + CONFIG_REG_0, DLC_EN);
		eth16i_set_port(ioaddr, i);

		if(eth16i_debug > 1)
			printk(KERN_DEBUG "Set port number %d\n", i);

		retcode = eth16i_send_probe_packet(ioaddr, dummy_packet, 64);
		if(retcode == 0) {
			retcode = eth16i_receive_probe_packet(ioaddr);
			if(retcode != -1) {
				if(eth16i_debug > 1)
					printk(KERN_DEBUG "Eth16i interface port found at %d\n", i);
				return i;
			}
		}
		else {
			if(eth16i_debug > 1)
				printk(KERN_DEBUG "TRANSMIT_DONE timeout when probing interface port\n");
		}
	}

	if( eth16i_debug > 1)
		printk(KERN_DEBUG "Using default port\n");

	return E_PORT_BNC;
}

/*
 * stores an EFM into a bitset if it is not an internal loop
 * every reaction is mapped to two bits
 * first bit is if reaction has a positive flux
 * second bit is set if reaction has a negative flux
 * none is set if reaction has no flux
 */
int loadEfm (char* matrix, char* line, char* reversible_reactions, char*
        rxs_fwd, char* rxs_rev, int rx_count, char* exchange_reaction, int
        checkLoops, double threshold)
{
    double n_thres = -1 * threshold;
    char *ptr;
    ptr = strtok(line, "\n\t ");
    int i = 0;
    int j = 0;
    while(ptr != NULL) 
    {
        double x = atof(ptr);
        if (checkLoops > 0 && BITTEST(exchange_reaction, i))
        {
            // check if EFM is an internal loop
            if (x >= threshold || x <= n_thres)
            {
                checkLoops = 0;
            }
        }
        if (BITTEST(reversible_reactions,i))
        {
            // positive flux
            if (x >= threshold)
            {
                BITSET(matrix, 2*j);
                BITSET(rxs_fwd,j);
            }
            // negative flux
            else if (x <= n_thres)
            {
                BITSET(matrix, (2*j)+1);
                BITSET(rxs_rev, j);
            }
            j++;
        }
        i++;
        ptr = strtok(NULL, "\n\t ");
    }
    if (checkLoops > 0)
    {
        // EFM is a loop - free memory
        free(matrix);
        matrix=NULL;
        return(0);
    }
    else
    {
        return(1);
    }
}

/*
 * gcc-specific pragmas.
 */
int
pragmas_gcc(char *t)
{
	char u;
	int ign, warn, err, i;
	extern bittype warnary[], werrary[];
	extern char *flagstr[], *pragstore;

	if (strcmp((t = pragtok(NULL)), "diagnostic") == 0) {
		ign = warn = err = 0;
		if (strcmp((t = pragtok(NULL)), "ignored") == 0)
			ign = 1;
		else if (strcmp(t, "warning") == 0)
			warn = 1;
		else if (strcmp(t, "error") == 0)
			err = 1;
		else
			return 1;
		if (eat('\"') || eat('-'))
			return 1;
		for (t = pragstore; *t && *t != '\"'; t++)
			;
		u = *t;
		*t = 0;
		for (i = 0; i < NUMW; i++) {
			if (strcmp(flagstr[i], pragstore+1) != 0)
				continue;
			if (err) {
				BITSET(warnary, i);
				BITSET(werrary, i);
			} else if (warn) {
				BITSET(warnary, i);
				BITCLEAR(werrary, i);
			} else {
				BITCLEAR(warnary, i);
				BITCLEAR(werrary, i);
			}
			return 0;
		}
		*t = u;
	} else if (strcmp(t, "poison") == 0) {
		/* currently ignore */;
	} else if (strcmp(t, "visibility") == 0) {
		/* currently ignore */;
	} else if (strcmp(t, "system_header") == 0) {
		/* currently ignore */;
	} else
		werror("gcc pragma unsupported");
	return 0;
}

void
CHyperLink::PreSubclassWindow( )
{
   // If the URL string is empty try to set it to the window text.
   if ( m_csURL.IsEmpty( ) )
      GetWindowText( m_csURL );

   // Check that the window text isn't empty.  If so, set it as URL string.
   CString csWndText;
   GetWindowText( csWndText );
   if ( csWndText.IsEmpty( ) )
   {
      // Set the URL string as the window text
      ASSERT( m_csURL.IsEmpty( ) == FALSE ); // window text and URL both empty!
      CStatic::SetWindowText( m_csURL );
   }

   // Get the current window font
   CFont *pFont = GetFont( );

   if ( pFont )
   {
      LOGFONT lf;
      pFont->GetLogFont( &lf );
      lf.lfUnderline = BITSET( m_dwStyle, StyleUnderline );
      if ( m_Font.CreateFontIndirect( &lf ) )
         CStatic::SetFont( &m_Font );

      // Adjust window size to fit URL if necessary.
      AdjustWindow( );
   }
   else
   {
      // If GetFont returns 0 then the static control is probably not of a
      // text type: it's better to set auto-resizing off.
      CLEARBITS( m_dwStyle, StyleAutoSize );
   }

   if ( !BITSET( m_dwStyle, StyleNoHandCursor ) )
      SetDefaultCursor( );      // try to load a "hand" cursor

    // Create the tooltip.
    CRect rect;
    GetClientRect( rect );
    m_ToolTip.Create( this );
    m_ToolTip.AddTool( this, m_csURL, rect, TOOLTIP_ID );

    CStatic::PreSubclassWindow( );
}

/** Change stepper ic controller direction. 1 is CW, 0 is CCW seen from top
*/
void stepper_set_direction( int8_t dir )
{
	if(dir >= 1)
		BITSET(PORTL,PL3);	//Rotation direcion CW
	else
		BITCLR(PORTL,PL3);	//Rotation direcion to CCW
}

static void eth16i_set_port(int ioaddr, int porttype)
{ 
	unsigned short temp = 0;

	eth16i_select_regbank(TRANSCEIVER_MODE_RB, ioaddr);
	outb(LOOPBACK_CONTROL, ioaddr + TRANSMIT_MODE_REG);

	temp |= DIS_AUTO_PORT_SEL;

	switch(porttype) {

	case E_PORT_BNC :
		temp |= AUI_SELECT;
		break;

	case E_PORT_TP :
		break;

	case E_PORT_DIX :
		temp |= AUI_SELECT;
		BITSET(ioaddr + TRANSMIT_MODE_REG, CONTROL_OUTPUT);
		break;
	}  

	outb(temp, ioaddr + TRANSCEIVER_MODE_REG);

	if(eth16i_debug > 1) {
		printk(KERN_DEBUG "TRANSMIT_MODE_REG = %x\n", inb(ioaddr + TRANSMIT_MODE_REG));
		printk(KERN_DEBUG "TRANSCEIVER_MODE_REG = %x\n", 
		       inb(ioaddr+TRANSCEIVER_MODE_REG));
	}
}

struct node* Node_addchild(struct node* parent, unsigned char label, unsigned short idx) {

    assert(parent);

    struct node* nc;

    if ((nc = Node_getchild(parent, label)))		//child already present
        return nc;

    nc = Node_new(label, idx);

    assert(nc);

    int numChildren = Node_childno(parent);
    int x = Bit_count_set_bits_up_to(parent -> bitarray, sizeof(parent -> bitarray), label);

    int i;

    parent -> child = realloc(parent -> child, (numChildren + 1) * sizeof(struct node*));		//make space for new child ponter
    assert(parent -> child);

    memset(parent -> child + numChildren, 0, sizeof(struct node*)); //initialize just-added space to 0

    for (i = numChildren; i > x; i--)
        parent -> child[i] = parent -> child[i - 1];	//shift child pointer to the right to make room for new child

    parent -> child[x] = nc;

    BITSET(parent -> bitarray, label);

    return nc;
}

void tchal_power_on_device(void)
{
#ifdef __USE_TC_CPU__
	tcbd_debug(DEBUG_TCHAL, "\n");
	BITCLR(RGPIO->GPEFN0, Hw16 - Hw12);/* DXB1_PD Set GPIO mode*/

	BITSET(RGPIO->GPEEN,  Hw3);/* DXB1_PD Set GPIO Output mode*/
	BITCLR(RGPIO->GPEDAT, Hw3);/* DXB1_PD Clear*/
	tcpal_msleep(10);
	BITSET(RGPIO->GPEDAT, Hw3);/* DXB1_PD Set*/
	tcpal_msleep(10);

	tchal_reset_device();
	tchal_irq_setup();
#endif
}

FUNCTION Msgh *sysbuf ()
{
	register Msgh  *m;
	register int   count = 0;

  Debug

	/* first try to allocate space */
	m = (Msgh *) l_create (msgdefsize);

	if (m == NULLMSGH)
	{  /* no space--get desperate */
		while (BITTST (emergbuf->flags, LOCKED))
		{
			if (count++ == 10000)
			{                   /* Wait for the MI to free the buffer..  */
				_pprintf ("Waiting for emergbuf to be unlocked... %x\n",
						emergbuf);
				send_e_from_q();        /* clear emergbuf */
				count = 0;
			}
		}
		m = emergbuf;   /* grab emergbuf */
	}

	clear ( m, sizeof (Msgh) ); /* clear it */

	if ( m == emergbuf )
		BITSET (m->flags, LOCKED); /* Tell rest of system not to use */

	return m;
}

static irqreturn_t tcc88xx_ost0_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *c = dev_id;

	BITCLR(pTIMER->TC32IRQ, Hw16);			/* Disable interrupt when the counter value matched with CMP0 */
	BITSET(pPIC->CLR0, TCC_ENABLE_BIT(irq));	/* Interrupt clear */
	if(pTIMER->TC32IRQ & Hw31)			/* IRQ clear */
		BITSET(pTIMER->TC32IRQ, Hw31);
	c->event_handler(c);

#if defined(TICKLESS_DEBUG_TCC)
	gInt_cnt++;
#endif

	return IRQ_HANDLED;
}