clash-vhdl-0.5.7: primitives/CLaSH.Sized.Vector.json

[ { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.eq#"
    , "type"      : "eq# :: Eq a => Vec n a -> Vec n a -> Bool"
    , "templateE" : "~ARG[1] = ~ARG[2]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.neq#"
    , "type"      : "neq# :: Eq a => Vec n a -> Vec n a -> Bool"
    , "templateE" : "~ARG[1] /= ~ARG[2]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.head"
    , "type"      : "head :: Vec (n + 1) a -> a"
    , "templateD" :
"-- head begin
head_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](0);
end block;
-- head end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.tail"
    , "type"      : "tail :: Vec (n + 1) a -> Vec n a"
    , "templateD" :
"-- tail begin
tail_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](1 to ~SYM[1]'high);
end block;
-- tail end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.last"
    , "type"      : "Vec (n + 1) a -> a"
    , "templateD" :
"-- last begin
last_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](~SYM[1]'high);
end block;
-- last end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.init"
    , "type"      : "Vec (n + 1) a -> Vec n a"
    , "templateD" :
"-- init begin
init_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];
  ~RESULT <= ~SYM[1](0 to ~SYM[1]'high - 1);
end block;
-- init end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.select"
    , "type" :
"select :: (CmpNat (i + s) (s * n) ~ GT) -- ARG[0]
        => SNat f                        -- ARG[1]
        -> SNat s                        -- ARG[2]
        -> SNat n                        -- ARG[3]
        -> Vec i a                       -- ARG[4]
        -> Vec n a"
    , "templateD" :
"-- select begin
select_~SYM[0] : block
  signal ~SYM[1] : ~TYP[4];
begin
  ~SYM[1] <= ~ARG[4];

  selectZ_~SYM[2] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  selectSN_~SYM[3] : if ~RESULT'length /= 0 generate
    selectIter_~SYM[4] : for ~SYM[5] in ~RESULT'range generate
    begin
      ~RESULT(~SYM[5]) <= ~SYM[1](~LIT[1]+(~LIT[2]*~SYM[5]));
    end generate;
  end generate;
end block;
-- select end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.++"
    , "type"      : "(++) :: Vec n a -> Vec m a -> Vec (n + m) a"
    , "templateE" : "~TYPM[0]'(~ARG[0]) & ~TYPM[1]'(~ARG[1])"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.concat"
    , "type"      : "concat :: Vec n (Vec m a) -> Vec (n * m) a"
    , "templateD" :
"-- concat begin
concat_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];

  concatZ_~SYM[2] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  concatSN_~SYM[3] : if ~RESULT'length /= 0 generate
    concatIter_~SYM[4] : for ~SYM[5] in ~SYM[1]'range generate
    begin
      ~RESULT((~SYM[5] * ~SYM[1](0)'length) to ((~SYM[5] * ~SYM[1](0)'length) + ~SYM[1](0)'high)) <= ~SYM[1](~SYM[5]);
    end generate;
  end generate;
end block;
-- concat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.splitAt"
    , "type"      : "splitAt :: SNat m -> Vec (m + n) a -> (Vec m a, Vec n a)"
    , "templateD" :
"-- sliptAt begin
splitAt_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];
  ~RESULT <= (~SYM[1](~RESULT.~TYPMO_sel0'left to ~RESULT.~TYPMO_sel0'right)
             ,~SYM[1](~RESULT.~TYPMO_sel1'left + ~RESULT.~TYPMO_sel0'length to ~RESULT.~TYPMO_sel1'right + ~RESULT.~TYPMO_sel0'length));
end block;
-- splitAt end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcat"
    , "type" :
"unconcat :: KnownNat n     -- ARG[0]
          => SNat m         -- ARG[1]
          -> Vec (n * m) a  -- ARG[2]
          -> Vec n (Vec m a)"
    , "templateD" :
"-- unconcat begin
unconcat_~SYM[0] : block
  signal ~SYM[1] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[2];

  unconcatZ_~SYM[2] : if ~SYM[1]'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  unconcatSN_~SYM[3] : if ~SYM[1]'length /= 0 generate
    unconcatIter_~SYM[4] : for ~SYM[5] in ~RESULT'range generate
    begin
      ~RESULT(~SYM[5]) <= ~SYM[1]((~SYM[5] * ~LIT[1]) to ((~SYM[5] * ~LIT[1]) + ~LIT[1] - 1));
    end generate;
  end generate;
end block;
-- unconcat end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.merge"
    , "type"      : "merge :: Vec n a -> Vec n a -> Vec (n + n) a"
    , "templateD" :
"-- merge begin
merge_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
  signal ~SYM[2] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[0];
  ~SYM[2] <= ~ARG[1];

  mergeZ_~SYM[3] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  mergeSN_~SYM[4] : if ~RESULT'length /= 0 generate
    mergeIter_~SYM[5] : for ~SYM[6] in ~SYM[1]'range generate
    begin
      ~RESULT(2*~SYM[6])   <= ~SYM[1](~SYM[6]);
      ~RESULT(2*~SYM[6]+1) <= ~SYM[2](~SYM[6]);
    end generate;
  end generate;
end block;
-- merge end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.map"
    , "type"      : "map :: (a -> b) -> Vec n a -> Vec n b"
    , "templateD" :
"-- map begin
map_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];

  mapZ_~SYM[2] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  mapSN_~SYM[3] : if ~RESULT'length /= 0 generate
    mapIter_~SYM[4] : for ~SYM[5] in ~RESULT'range generate
    begin
      ~INST 0
        ~OUTPUT <= ~RESULT(~SYM[5])~ ~TYPEL[~TYPO]~
        ~INPUT  <= ~SYM[1](~SYM[5])~ ~TYPEL[~TYP[1]]~
      ~INST
    end generate;
  end generate;
end block;
-- map end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.zipWith"
    , "type"      : "zipWith :: (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c"
    , "templateD" :
"-- zipWith begin
zipWith_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
  signal ~SYM[2] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[1];
  ~SYM[2] <= ~ARG[2];

  zipWithZ_~SYM[3] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  zipWithSN_~SYM[4] : if ~RESULT'length /= 0 generate
    zipWithIter_~SYM[5] : for ~SYM[6] in ~RESULT'range generate
    begin
      ~INST 0
        ~OUTPUT <= ~RESULT(~SYM[6])~ ~TYPEL[~TYPO]~
        ~INPUT  <= ~SYM[1](~SYM[6])~ ~TYPEL[~TYP[1]]~
        ~INPUT  <= ~SYM[2](~SYM[6])~ ~TYPEL[~TYP[2]]~
      ~INST
    end generate;
  end generate;
end block;
-- zipWith end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.index_int"
    , "type"      : "index_int :: KnownNat n => Vec n a -> Int -> a"
    , "templateD" :
"-- index begin
indexVec_~SYM[0] : block
  signal vec       : ~TYP[1];
  signal vec_index : integer range 0 to ~LIT[0]-1;
begin
  vec <= ~ARG[1];

  vec_index <= ~ARG[2]
  -- pragma translate_off
               mod ~LIT[0]
  -- pragma translate_on
               ;

  ~RESULT <= vec(vec_index);
end block;
-- index end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replace_int"
    , "type"      : "replace_int :: KnownNat n => Vec n a -> Int -> a -> Vec n a"
    , "templateD" :
"-- replace begin
replaceVec_~SYM[0] : block
  signal vec       : ~TYP[1];
  signal vec_index : integer range 0 to ~LIT[0]-1;
  signal din       : ~TYP[3];
begin
  vec <= ~ARG[1];
  vec_index <= ~ARG[2]
  -- pragma translate_off
               mod ~LIT[0]
  -- pragma translate_on
               ;
  din <= ~ARG[3];

  process(vec,vec_index,din)
    variable ivec : ~TYP[1];
  begin
    ivec := vec;
    ivec(vec_index) := din;
    ~RESULT <= ivec;
  end process;
end block;
-- replace end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.maxIndex"
    , "type"      : "maxIndex :: KnownNat n => Vec n a -> Integer"
    , "templateE" : "~LIT[0] - 1"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.length"
    , "type"      : "length :: KnownNat n => Vec n a -> Integer"
    , "templateE" : "~LIT[0]"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.replicate"
    , "type"      : "replicate :: SNat n -> a -> Vec n a"
    , "templateE" : "~TYPMO'(0 to ~LIT[0]-1 => ~ARG[1])"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.reverse"
    , "type"      : "reverse :: Vec n a -> Vec n a"
    , "templateD" :
"-- reverse begin
reverse_~SYM[0] : block
  signal ~SYM[1] : ~TYP[0];
begin
  ~SYM[1] <= ~ARG[0];

  reverseZ_~SYM[2] : if ~RESULT'length = 0 generate
    ~RESULT <= ~SYM[1];
  end generate;

  reverseSN_~SYM[3] : if ~RESULT'length /= 0 generate
    reverseIter_~SYM[4] : for ~SYM[5] in ~SYM[1]'range generate
      ~RESULT(~SYM[1]'high - ~SYM[5]) <= ~SYM[1](~SYM[5]);
    end generate;
  end generate;
end block;
-- reverse end"
    }
  }
, { "BlackBox" :
    { "name"      : "CLaSH.Sized.Vector.lazyV"
    , "type"      : "lazyV :: KnownNat n => Vec n a -> Vec n a"
    , "templateE" : "~ARG[1]"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.concatBitVector#"
    , "type" :
"concatBitVector# :: KnownNat m           -- ARG[0]
                  => Vec n (BitVector m)  -- ARG[1]
                  -> BitVector (n * m)"
    , "templateD" :
"-- concatBitVector begin
concatBitVector_~SYM[0] : block
  signal ~SYM[1] : ~TYP[1];
begin
  ~SYM[1] <= ~ARG[1];

  concatBitVectorZ_~SYM[2] : if ~RESULT'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  concatBitVectorSN_~SYM[3] : if ~RESULT'length /= 0 generate
    concatBitVectorIter_~SYM[4] : for ~SYM[5] in ~SYM[1]'range generate
      ~RESULT(((~SYM[5] * ~LIT[0]) + ~LIT[0] - 1) downto (~SYM[5] * ~LIT[0])) <= ~TYPMO(~SYM[1](~SYM[1]'high - ~SYM[5]));
    end generate;
  end generate;
end block;
-- concatBitVector end"
    }
  }
, { "BlackBox" :
    { "name" : "CLaSH.Sized.Vector.unconcatBitVector#"
    , "type" :
"unconcatBitVector# :: (KnownNat n, KnownNat m) -- (ARG[0],ARG[1])
                    => BitVector (n * m)        -- ARG[2]
                    -> Vec n (BitVector m)"
    , "templateD" :
"-- unconcatBitVector begin
unconcatBitVector_~SYM[0] : block
  signal ~SYM[1] : ~TYP[2];
begin
  ~SYM[1] <= ~ARG[2];

  unconcatBitVectorZ_~SYM[2] : if ~SYM[1]'length = 0 generate
    ~RESULT <= ~ERRORO;
  end generate;

  unconcatBitVectorSN_~SYM[3] : if ~SYM[1]'length /= 0 generate
    unconcatBitVectorIter_~SYM[4] : for ~SYM[5] in ~RESULT'range generate
      ~RESULT(~RESULT'high - ~SYM[5]) <= ~SYM[1](((~SYM[5] * ~LIT[1]) + ~LIT[1] - 1) downto (~SYM[5] * ~LIT[1]));
    end generate;
  end generate;
end block;
-- unconcatBitVector end"
    }
  }
]