vector.h

Go to the documentation of this file.

#ifndef __VECTOR_H__
#define __VECTOR_H__

/*
 Copyright (c) 2006-2010 Trevor Williams

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by the Free Software
 Foundation; either version 2 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with this program;
 if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <stdio.h>

#include "defines.h"


void vector_init_ulong(
  /*@out@*/ vector* vec,
            ulong** value,
            ulong   data_l,
            ulong   data_h,
            bool    owns_value,
            int     width,
            int     type
);

void vector_init_r64(
  /*@out@*/ vector* vec,
            rv64*   value,
            double  data,
            char*   str,
            bool    owns_value,
            int     type
);

void vector_init_r32(
  /*@out@*/ vector* vec,
            rv32*   value,
            float   data,
            char*   str,
            bool    owns_value,
            int     type
);

vector* vector_create(
  int  width,
  int  type,
  int  data_type,
  bool data
);

void vector_copy(
  const vector* from_vec,
  vector*       to_vec
);

void vector_copy_range(
  vector*       to_vec,
  const vector* from_vec,
  int           lsb
);

void vector_clone(
            const vector* from_vec,
  /*@out@*/ vector**      to_vec
);

void vector_db_write(
  vector* vec,
  FILE*   file,
  bool    write_data,
  bool    net
);

void vector_db_read(
  /*@out@*/ vector** vec,
            char**   line
);

void vector_db_merge(
  vector* base,
  char**  line,
  bool    same
);

void vector_merge(
  vector* base,
  vector* other
);

int vector_get_eval_a(
  vector* vec,
  int     index
);

int vector_get_eval_b(
  vector* vec,
  int     index
);

int vector_get_eval_c(
  vector* vec,
  int     index
);

int vector_get_eval_d(
  vector* vec,
  int     index
);

int vector_get_eval_ab_count(
  vector* vec
);

int vector_get_eval_abc_count(
  vector* vec
);

int vector_get_eval_abcd_count(
  vector* vec
);

char* vector_get_toggle01_ulong(
  ulong** value,
  int     width
);

char* vector_get_toggle10_ulong(
  ulong** value,
  int     width
);

void vector_display_toggle01_ulong(
  ulong** value,
  int     width,
  FILE*   ofile
);

void vector_display_toggle10_ulong(
  ulong** value,
  int     width,
  FILE*   ofile
);

void vector_display_value_ulong(
  ulong** value,
  int     width
);

/*@-exportlocal@*/
void vector_display_ulong(
  ulong**      value,
  unsigned int width,
  unsigned int type
);
/*@=exportlocal@*/

void vector_display(
  const vector* vec
);

bool vector_set_value_ulong(
  vector*      vec,
  ulong**      value,
  unsigned int width
);

bool vector_part_select_pull(
  vector* tgt,
  vector* src,
  int     lsb,
  int     msb,
  bool    set_mem_rd
);

bool vector_part_select_push(
  vector*       tgt,
  int           tgt_lsb,
  int           tgt_msb,
  const vector* src,
  int           src_lsb,
  int           src_msb,
  bool          sign_extend
);

void vector_set_unary_evals(
  vector* vec
);

void vector_set_and_comb_evals( 
  vector* tgt, 
  vector* left, 
  vector* right 
);

void vector_set_or_comb_evals( 
  vector* tgt, 
  vector* left, 
  vector* right 
);

void vector_set_other_comb_evals(
  vector* tgt,
  vector* left,
  vector* right
);

bool vector_sign_extend(
  vector* vec,
  int     last
);

bool vector_is_unknown(
  const vector* vec
);

bool vector_is_not_zero(
  const vector* vec
);

bool vector_set_to_x(
  vector* vec
);

int vector_to_int(
  const vector* vec
);

uint64 vector_to_uint64(
  const vector* vec
);

real64 vector_to_real64(
  const vector* vec
);

void vector_to_sim_time(
            const vector* vec,
            uint64        scale,
  /*@out@*/ sim_time*     time
);

bool vector_from_int(
  vector* vec,
  int     value
);

bool vector_from_uint64(
  vector* vec,
  uint64  value
);

bool vector_from_real64(
  vector* vec,
  real64  value
);

char* vector_to_string(
  vector*      vec, 
  int          base,
  bool         show_all,
  unsigned int width
);

void vector_from_string_fixed(
  vector*     vec,
  const char* str
);

void vector_from_string(
            char**   str,
            bool     quoted,
  /*@out@*/ vector** vec,
  /*@out@*/ int*     base
);

bool vector_vcd_assign(
  vector*     vec,
  const char* value,
  int         msb,
  int         lsb
);

void vector_toggle_count(
            vector*       vec,
  /*@out@*/ unsigned int* tog01_cnt,
  /*@out@*/ unsigned int* tog10_cnt
);

void vector_mem_rw_count(
            vector*       vec,
            int           lsb,
            int           msb,
  /*@out@*/ unsigned int* wr_cnt,
  /*@out@*/ unsigned int* rd_cnt
);

bool vector_set_assigned(
  vector* vec,
  int     msb,
  int     lsb
);

bool vector_set_coverage_and_assign_ulong(
  vector*      vec,
  const ulong* scratchl,
  const ulong* scratchh,
  int          lsb,
  int          msb
);

bool vector_bitwise_and_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_bitwise_nand_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_bitwise_or_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_bitwise_nor_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_bitwise_xor_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_bitwise_nxor_op(
  vector* tgt,
  vector* src1,
  vector* src2
);

bool vector_op_lt(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_le(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_gt(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_ge(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_eq(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_ceq_ulong(
  const vector* left,
  const vector* right
);

bool vector_op_ceq(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_cxeq(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_czeq(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_ne(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_cne(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_lor(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_land(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_lshift(
  vector*       tgt,
  const vector* left,
  const vector* right
);
 
bool vector_op_rshift(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_arshift(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_add(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_negate(
  vector*       tgt,
  const vector* src
);

bool vector_op_subtract(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_multiply(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_divide(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_modulus(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_inc(
  vector* tgt,
  vecblk* tvb
);

bool vector_op_dec(
  vector* tgt,
  vecblk* tvb
);

bool vector_unary_inv(
  vector*       tgt,
  const vector* src
);

bool vector_unary_and(
  vector*       tgt,
  const vector* src
);

bool vector_unary_nand(
  vector*       tgt,
  const vector* src
);

bool vector_unary_or(
  vector*       tgt,
  const vector* src
);

bool vector_unary_nor(
  vector*       tgt,
  const vector* src
);

bool vector_unary_xor(
  vector*       tgt,
  const vector* src
);

bool vector_unary_nxor(
  vector*       tgt,
  const vector* src
);

bool vector_unary_not(
  vector*       tgt,
  const vector* src
);

bool vector_op_expand(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_list(
  vector*       tgt,
  const vector* left,
  const vector* right
);

bool vector_op_clog2(
  vector*       tgt,
  const vector* src
);

void vector_dealloc_value(
  vector* vec
);

void vector_dealloc(
  vector* vec
);

#endif