Belle II Software  release-06-02-00
JSignal.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 //-----------------------------------------------------------------------------
10 // Description : A class for Signals in CDC Trigger for 3D tracker.
11 //-----------------------------------------------------------------------------
12 
13 #define TRG_SHORT_NAMES
14 #define TRGCDC_SHORT_NAMES
15 
16 #ifndef __EXTERNAL__
17 #include "trg/cdc/JSignal.h"
18 #include "trg/cdc/FpgaUtility.h"
19 #include "trg/cdc/JSignalData.h"
20 #else
21 #include "JSignal.h"
22 #include "FpgaUtility.h"
23 #include "JSignalData.h"
24 #endif
25 #include <iostream>
26 #include <sstream>
27 #include <fstream>
28 #include <cstdlib>
29 #include <cmath>
30 //#include <algorithm>
31 
32 using std::cout;
33 using std::endl;
34 using std::pair;
35 using std::make_pair;
36 using std::tuple;
37 using std::vector;
38 using std::map;
39 using std::string;
40 using std::stringstream;
41 using std::to_string;
42 using std::get;
43 using std::max;
44 using std::min;
45 using std::ofstream;
46 using std::ios;
47 
48 namespace Belle2 {
55  TRGCDCJSignal::TRGCDCJSignal()
56  {
57  (*this) = TRGCDCJSignal(0);
58  }
59 
60  TRGCDCJSignal::TRGCDCJSignal(TRGCDCJSignalData* commonData)
61  : m_name(""),
62  m_vhdlCode("")
63  {
64  m_type = 1;
65  m_bitsize = -1;
66  m_int = 0;
67  m_minInt = 0;
68  m_maxInt = 0;
69  m_actual = 0;
70  m_minActual = 0;
71  m_maxActual = 0;
72  m_toReal = 0;
73  m_debug = 0;
74  m_finishClock = -2;
75  m_commonData = commonData;
76  }
77 
78  TRGCDCJSignal::TRGCDCJSignal(int const& bitwidth, double const& value, double const& minValue, double const& maxValue,
79  int const& clock, TRGCDCJSignalData* commonData)
80  {
81  m_bitsize = bitwidth;
82  m_type = calType(minValue);
83  if (m_type == -1) {
84  m_toReal = 1 / ((pow(2, bitwidth - 1) - 0.5) / max(maxValue, fabs(minValue)));
85  } else if (m_type == 1) {
86  m_toReal = 1 / ((pow(2, bitwidth) - 0.5) / maxValue);
87  }
88  m_int = FpgaUtility::roundInt(value / m_toReal);
89  m_minInt = FpgaUtility::roundInt(minValue / m_toReal);
90  m_maxInt = FpgaUtility::roundInt(maxValue / m_toReal);
91  m_actual = value;
92  m_minActual = minValue;
93  m_maxActual = maxValue;
94  m_debug = 0;
95  m_name = "";
96  m_vhdlCode = "";
97  m_finishClock = clock;
98  m_commonData = commonData;
99  // Check if there is overflow or underflow.
100  checkInt("TRGCDCJSignal(int, int, double, double)");
101  }
102 
103  TRGCDCJSignal::TRGCDCJSignal(int const& bitwidth, double const& value, double const& minValue, double const& maxValue,
104  TRGCDCJSignalData* commonData)
105  {
106  (*this) = TRGCDCJSignal(bitwidth, value, minValue, maxValue, 0, commonData);
107  }
108 
109  TRGCDCJSignal::TRGCDCJSignal(signed long long const& intValue, double const& toReal, signed long long const& minInt,
110  signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock,
111  TRGCDCJSignalData* commonData, bool b_slv)
112  {
113  m_int = intValue;
114  m_minInt = minInt;
115  m_maxInt = maxInt;
116  m_actual = actual;
117  m_minActual = minActual;
118  m_maxActual = maxActual;
119  m_toReal = toReal;
120  if (b_slv == 0) m_type = calType();
121  else m_type = 2;
122  m_bitsize = calBitwidth();
123  m_finishClock = finishClock;
124  m_debug = 0;
125  m_name = "";
126  m_vhdlCode = "";
127  m_commonData = commonData;
128  // Check if there is overflow or underflow.
129  checkInt("TRGCDCJSignal(int, double, signed long long, signed long long, double, double, double)");
130  }
131 
132  TRGCDCJSignal::TRGCDCJSignal(double const& value, double const& toReal, TRGCDCJSignalData* commonData)
133  {
134  m_type = calType(value);
135  m_toReal = toReal;
136  m_int = FpgaUtility::roundInt(value / m_toReal);
137  m_minInt = m_int;
138  m_maxInt = m_int;
139  m_actual = value;
140  m_minActual = value;
141  m_maxActual = value;
142  m_bitsize = calBitwidth();
143  m_debug = 0;
144  m_name = "";
145  m_vhdlCode = "";
146  m_finishClock = -1;
147  m_commonData = commonData;
148  // Check if there is overflow or underflow.
149  checkInt("TRGCDCJSignal(double, double)");
150  }
151 
152  TRGCDCJSignal::TRGCDCJSignal(std::vector<bool> const& slvValue, int const& finishClock, TRGCDCJSignalData* commonData)
153  : m_name("")
154  {
155  m_type = 2;
156  m_bitsize = slvValue.size();
157  m_slv = slvValue;
158  m_int = 0;
159  m_minInt = 0;
160  m_maxInt = 0;
161  m_actual = 0;
162  m_minActual = 0;
163  m_maxActual = 0;
164  m_toReal = 0;
165  m_debug = 0;
166  m_vhdlCode = "";
167  m_finishClock = finishClock;
168  m_commonData = commonData;
169  }
170 
171 
172  TRGCDCJSignal& TRGCDCJSignal::assignTo(TRGCDCJSignal const& rhs, int targetClock, string& finalCode)
173  {
174 
175  TRGCDCJSignal t_rhs(rhs);
176  // Calculate result final clock.
177  int t_calFinishClock = t_rhs.calFinishClock();
178  // If t_rhs finish clock is blank or constant, skip.
179  if (!(t_calFinishClock == -2 || t_calFinishClock == -1)) {
180  // If target clock is not set, add 1 to t_rhs finish clock.
181  if (targetClock == -3) t_rhs.m_finishClock = t_calFinishClock + 1;
182  else {
183  if (targetClock < t_calFinishClock) cout << "[Error] TRGCDCJSignal::assign() => targetClock is too small." << endl;
184  else t_rhs.m_finishClock = targetClock;
185  }
186  }
187  //if(m_name!="") cout<<"Signal name: "<<m_name<<" Clock: "<<t_rhs.m_finishClock<<endl;
188 
190  if ((*this).m_bitsize != -1 || (*this).m_name != "")
191  //if((*this).m_bitsize != -1)
192  {
193 
194  if ((*this).m_bitsize == 1) {
195  // Check if rhs and lhs bitsize is the same.
196  if ((*this).m_bitsize != t_rhs.m_bitsize) {
197  cout << "[Warning] TRGCDCJSignal::operator<=() => rhs and lhs do not have same bitsize." << endl;
198  }
199  // Check if rhs and lhs is same type.
200  if ((*this).m_type != t_rhs.m_type) {
201  cout << "[Warning] TRGCDCJSignal::operator<=() => rhs and lhs do not have same type." << endl;
202  }
203  // Check if rhs and lhs clock is the same.
204  if (m_finishClock != t_rhs.m_finishClock) {
205  cout << "[Warning] TRGCDCJSignal::operator<=() => rhs and lhs do not have same clock." << endl;
206  cout << m_name << " lhs clock: " << m_finishClock << " rhs clock: " << t_rhs.m_finishClock << endl;
207  }
208  }
209 
210  //int t_type;
211  //if(t_rhs.m_minInt<0) t_type = -1;
212  //else t_type = 1;
213  //int t_bitsize = ceil(log(max(t_rhs.m_maxInt, abs(t_rhs.m_minInt))+1)/log(2));
214  //if(t_type != 1) t_bitsize++;
216  //if(t_rhs.m_bitsize != t_bitsize){
217  // cout<<"Bitsize and calcualted bitwidth don't match"<<endl;
218  // cout<<"Bitsize: "<<t_rhs.m_bitsize<<" calBitsize: "<<t_bitsize<<endl;
219  // cout<<"LHS"<<endl;
220  // dump();
221  // cout<<"RHS"<<endl;
222  // t_rhs.dump();
223  // cout<<"Bitsize and calcualted bitwidth don't match"<<endl;
224  //}
226  //if(t_rhs.m_type != t_type){
227  // cout<<"Type and calcualted type don't match"<<endl;
228  // cout<<"Type: "<<t_rhs.m_type<<" calType: "<<t_type<<endl;
229  // cout<<"LHS"<<endl;
230  // dump();
231  // cout<<"RHS"<<endl;
232  // t_rhs.dump();
233  // cout<<"Type and calcualted type don't match"<<endl;
234  //}
235 
236  // Set arguments if needed.
237  if (t_rhs.m_argumentSignals.size() == 0) t_rhs.initArgumentSignals();
238 
239  // Print m_vhdlCode.
240  string t_finalCode(finalCode);
241 
242  if (getPrintVhdl() == 1) {
243  finalCode = assignVhdlCode(*this, t_rhs);
244  if (t_finalCode == "printAssignVhdlCode") {
245  //printVhdl(finalCode);
246  m_commonData->m_vhdlInProcess += finalCode + "\n";
247  }
248  }
249 
250  } // End of not blank constructor.
251 
252  swap(*this, t_rhs);
253  // Operations due to swap.
254  // Keep original name
255  m_name = t_rhs.m_name;
256  // Clear code.
257  m_vhdlCode = "";
258  m_argumentSignals.clear();
259 
260  // Don't propagate debug
261  m_debug = 0;
262 
263  return *this;
264  }
265 
266  TRGCDCJSignal& TRGCDCJSignal::assignTo(TRGCDCJSignal const& rhs, int targetClock)
267  {
268  string finalCode = "printAssignVhdlCode";
269  return assignTo(rhs, targetClock, finalCode);
270  }
271 
272  TRGCDCJSignal& TRGCDCJSignal::operator<= (TRGCDCJSignal const& rhs)
273  {
274  string finalCode = "printAssignVhdlCode";
275  return assignTo(rhs, -3, finalCode);
276  }
277 
279  TRGCDCJSignal const TRGCDCJSignal::operator- () const
280  {
281 
282  TRGCDCJSignal t_signal(*this);
283 
284  //if(t_signal.m_type==2) {
285  // cout<<"[Error] TRGCDCJSignal::operator-(void) => should not be used with slv type."<<endl;
286  //}
287 
288  if (t_signal.m_argumentSignals.size() == 0) t_signal.initArgumentSignals();
289 
290  t_signal.m_int *= -1;
291  t_signal.m_minInt = -(*this).m_maxInt;
292  t_signal.m_maxInt = -(*this).m_minInt;
293  t_signal.m_actual *= -1;
294  t_signal.m_minActual = -m_maxActual;
295  t_signal.m_maxActual = -m_minActual;
296  if (m_type == 1) {
297  t_signal.m_type = -1;
298  t_signal.m_bitsize += 1;
299  }
300 
301  //t_signal.m_vhdlCode = vhdlCode("-", *this, t_signal);
302  if (getPrintVhdl() == 1) {
303  vhdlCode("-", *this, t_signal, t_signal.m_vhdlCode);
304  }
305 
306  return t_signal;
307  }
308 
310  TRGCDCJSignal const TRGCDCJSignal::operator+ (TRGCDCJSignal const& rhs) const
311  {
312  TRGCDCJSignal t_lhs(*this);
313  TRGCDCJSignal t_rhs(rhs);
314 
315  //if(t_lhs.m_type==2 || t_rhs.m_type==2) {
316  // cout<<"[Error] TRGCDCJSignal::operator+() => should not be used with slv type."<<endl;
317  //}
318 
319  if (t_lhs.m_argumentSignals.size() == 0) t_lhs.initArgumentSignals();
320  if (t_rhs.m_argumentSignals.size() == 0) t_rhs.initArgumentSignals();
321 
322  if (m_debug == 1) {
323  cout << "TRGCDCJSignal::operator+=()" << endl;
324  cout << "<<<Input lhs>>>" << endl;
325  t_lhs.dump();
326  cout << "<<<Input lhs>>>" << endl;
327  cout << "<<<Input rhs>>>" << endl;
328  t_rhs.dump();
329  cout << "<<<Input rhs>>>" << endl;
330  }
331  // Match m_toReal(unit) by shifting bits.
332  matchUnit(t_lhs, t_rhs);
333 
334  // To save toReal, debug
335  TRGCDCJSignal t_result(t_lhs);
336  combineArguments(t_lhs, t_rhs, t_result);
337 
338  // Set name
339  t_result.m_name = t_lhs.m_name + "+" + t_rhs.m_name;
340  // Add values.
341  t_result.m_int = t_lhs.m_int + t_rhs.m_int;
342  t_result.m_minInt = t_lhs.m_minInt + t_rhs.m_minInt;
343  t_result.m_maxInt = t_lhs.m_maxInt + t_rhs.m_maxInt;
344  t_result.m_actual = t_lhs.m_actual + t_rhs.m_actual;
345  t_result.m_minActual = t_lhs.m_minActual + t_rhs.m_minActual;
346  t_result.m_maxActual = t_lhs.m_maxActual + t_rhs.m_maxActual;
347  // Calculate bitsize.
348  //int outputBitsize;
349  //int outputType;
350  //calTypeBitwidth(t_lhs, "+", t_rhs, outputType, outputBitsize);
351  //Set output bitsize and type.
352  //t_result.m_type = outputType;
353  //t_result.m_bitsize = outputBitsize;
354  t_result.m_type = t_result.calType();
355  t_result.m_bitsize = t_result.calBitwidth();
356  // Check for overflow underflow.
357  t_result.checkInt("TRGCDCJSignal::operator+");
358  if (m_debug == 1) {
359  cout << "<<<Output>>>" << endl;
360  t_result.dump();
361  cout << "<<<Output>>>" << endl;
362  cout << "TRGCDCJSignal::operator+=()" << endl;
363  }
364 
365  //t_result.m_vhdlCode = vhdlCode(t_lhs, "+", t_rhs, t_result);
366  if (getPrintVhdl() == 1) vhdlCode(t_lhs, "+", t_rhs, t_result, t_result.m_vhdlCode);
367 
368  return t_result;
369  }
370 
371  TRGCDCJSignal const TRGCDCJSignal::operator- (TRGCDCJSignal const& rhs) const
372  {
373 
374  TRGCDCJSignal t_lhs(*this);
375  TRGCDCJSignal t_rhs(rhs);
376 
377  //if(t_lhs.m_type==2 || t_rhs.m_type==2) {
378  // cout<<"[Error] TRGCDCJSignal::operator-() => should not be used with slv type."<<endl;
379  //}
380 
381  if (t_lhs.m_argumentSignals.size() == 0) t_lhs.initArgumentSignals();
382  if (t_rhs.m_argumentSignals.size() == 0) t_rhs.initArgumentSignals();
383 
384  if (m_debug == 1) {
385  cout << "TRGCDCJSignal::operator-=()" << endl;
386  cout << "<<<Input lhs>>>" << endl;
387  t_lhs.dump();
388  cout << "<<<Input lhs>>>" << endl;
389  cout << "<<<Input rhs>>>" << endl;
390  t_rhs.dump();
391  cout << "<<<Input rhs>>>" << endl;
392  }
393  // Match m_toReal(unit) by shifting bits.
394  matchUnit(t_lhs, t_rhs);
395 
396  // To save toReal, debug
397  TRGCDCJSignal t_result(t_lhs);
398  combineArguments(t_lhs, t_rhs, t_result);
399  // Set name
400  t_result.m_name = t_lhs.m_name + "-" + t_rhs.m_name;
401  // Subtract values.
402  t_result.m_int = t_lhs.m_int - t_rhs.m_int;
403  if (isSameSignal(t_lhs, t_rhs)) {
404  t_result.m_minInt = 0;
405  t_result.m_maxInt = 0;
406  t_result.m_minActual = 0;
407  t_result.m_maxActual = 0;
408  } else {
409  t_result.m_minInt = t_lhs.m_minInt - t_rhs.m_maxInt;
410  t_result.m_maxInt = t_lhs.m_maxInt - t_rhs.m_minInt;
411  t_result.m_minActual = t_lhs.m_minActual - t_rhs.m_maxActual;
412  t_result.m_maxActual = t_lhs.m_maxActual - t_rhs.m_minActual;
413  }
414  t_result.m_actual = t_lhs.m_actual - t_rhs.m_actual;
415  // Calculate bitsize.
416  t_result.m_type = t_result.calType();
417  t_result.m_bitsize = t_result.calBitwidth();
418  // Check for overflow underflow.
419  t_result.checkInt("TRGCDCJSignal::operator-");
420  if (m_debug == 1) {
421  cout << "<<<Output>>>" << endl;
422  t_result.dump();
423  cout << "<<<Output>>>" << endl;
424  cout << "TRGCDCJSignal::operator-=()" << endl;
425  }
426  //t_result.m_vhdlCode = vhdlCode(t_lhs, "-", t_rhs, t_result);
427  if (getPrintVhdl() == 1) vhdlCode(t_lhs, "-", t_rhs, t_result, t_result.m_vhdlCode);
428 
429  return t_result;
430  }
431 
432  TRGCDCJSignal const TRGCDCJSignal::operator* (TRGCDCJSignal const& rhs) const
433  {
434 
435  // Shift values if input bit size is larger then signed 25 bits * signed 18 bits (unsigned 24 bits * unsigned 17 bits)
436  // Find largest and second bitsize.
437  TRGCDCJSignal t_large(*this);
438  TRGCDCJSignal t_small(rhs);
439 
440  //if(t_large.m_type==2 || t_small.m_type==2) {
441  // cout<<"[Error] TRGCDCJSignal::operator*() => should not be used with slv type."<<endl;
442  //}
443 
444  if (t_large.m_argumentSignals.size() == 0) t_large.initArgumentSignals();
445  if (t_small.m_argumentSignals.size() == 0) t_small.initArgumentSignals();
446 
447  if (m_debug == 1) {
448  cout << "TRGCDCJSignal::operator*=()" << endl;
449  cout << "<<<Input lhs>>>" << endl;
450  t_large.dump();
451  cout << "<<<Input lhs>>>" << endl;
452  cout << "<<<Input rhs>>>" << endl;
453  t_small.dump();
454  cout << "<<<Input rhs>>>" << endl;
455  }
456  bool orderSwap = orderLargestBitsize(t_large, t_small);
457  int nBitsLargeShift = 0;
458  int nBitsSmallShift = 0;
459  // Shift if needed.
460  if (t_large.m_type == 1) {
461  if (t_large.m_bitsize > 24) {
462  nBitsLargeShift = t_large.m_bitsize - 24;
463  t_large = t_large.shift(nBitsLargeShift, 0);
464  }
465  } else {
466  if (t_large.m_bitsize > 25) {
467  nBitsLargeShift = t_large.m_bitsize - 25;
468  t_large = t_large.shift(nBitsLargeShift, 0);
469  }
470  }
471  if (t_small.m_type == 1) {
472  if (t_small.m_bitsize > 17) {
473  nBitsSmallShift = t_small.m_bitsize - 17;
474  t_small = t_small.shift(nBitsSmallShift, 0);
475  }
476  } else {
477  if (t_small.m_bitsize > 18) {
478  nBitsSmallShift = t_small.m_bitsize - 18;
479  t_small = t_small.shift(nBitsSmallShift, 0);
480  }
481  }
482  if (m_debug == 1) {
483  cout << "<<<";
484  if (orderSwap) cout << nBitsSmallShift << " bit right shifted input lhs>>>" << endl;
485  else cout << nBitsLargeShift << " bit right shifted input lhs>>>" << endl;
486  if (orderSwap) t_small.dump();
487  else t_large.dump();
488  cout << "<<<Shifted input lhs>>>" << endl;
489  cout << "<<<";
490  if (orderSwap) cout << nBitsLargeShift << " bit right shifted input rhs>>>" << endl;
491  else cout << nBitsSmallShift << " bit right shifted input rhs>>>" << endl;
492  if (orderSwap) t_large.dump();
493  else t_small.dump();
494  cout << "<<<Shifted input rhs>>>" << endl;
495  }
496 
497  // To save debug
498  TRGCDCJSignal t_result(t_large);
499  combineArguments(t_large, t_small, t_result);
500  // Set name
501  t_result.m_name = t_large.m_name + "*" + t_small.m_name;
502  // Multiply values.
503  t_result.m_int = t_large.m_int * t_small.m_int;
504  t_result.m_actual = t_large.m_actual * t_small.m_actual;
505 
506  if (isSameSignal(*this, rhs)) {
507  if (t_large.m_minInt >= 0 && t_small.m_minInt >= 0) t_result.m_minInt = t_large.m_minInt * t_small.m_minInt;
508  else t_result.m_minInt = 0;
509  if (t_large.m_minActual >= 0 && t_small.m_minActual >= 0) t_result.m_minActual = t_large.m_minActual * t_small.m_minActual;
510  else t_result.m_minActual = 0;
511  } else {
512  if (t_large.m_minInt >= 0 && t_small.m_minInt >= 0) t_result.m_minInt = t_large.m_minInt * t_small.m_minInt;
513  else t_result.m_minInt = min(t_large.m_minInt * t_small.m_maxInt, t_large.m_maxInt * t_small.m_minInt);
514  if (t_large.m_minActual >= 0 && t_small.m_minActual >= 0) t_result.m_minActual = t_large.m_minActual * t_small.m_minActual;
515  else t_result.m_minActual = min(t_large.m_minActual * t_small.m_maxActual, t_large.m_maxActual * t_small.m_minActual);
516  }
517  t_result.m_maxInt = max(t_large.m_maxInt * t_small.m_maxInt, t_large.m_minInt * t_small.m_minInt);
518  t_result.m_maxActual = max(t_large.m_maxActual * t_small.m_maxActual, t_large.m_minActual * t_small.m_minActual);
519 
520  // Set unit
521  t_result.m_toReal = t_large.m_toReal * t_small.m_toReal;
522  // Calculate bitsize and type.
523  t_result.m_type = t_result.calType();
524  t_result.m_bitsize = t_result.calBitwidth();
525  // Check for overflow underflow.
526  t_result.checkInt("TRGCDCJSignal::operator*");
527  if (m_debug == 1) {
528  cout << "<<<Output>>>" << endl;
529  t_result.dump();
530  cout << "<<<Output>>>" << endl;
531  cout << "TRGCDCJSignal::operator*=()" << endl;
532  }
533 
534  if (getPrintVhdl() == 1) vhdlCode(t_large, "*", t_small, t_result, t_result.m_vhdlCode);
535 
536  return t_result;
537  }
538 
539  void TRGCDCJSignal::dump() const
540  {
541  cout << "-----------------------------------" << endl;
542  cout << "name: " << m_name << endl;
543  cout << "type: " << m_type << endl;
544  cout << "bitsize: " << m_bitsize << endl;
545  int t_org = cout.precision();
546  cout.precision(15);
547  cout << "actual: " << m_actual << endl;
548  cout.precision(t_org);
549  cout << "int: " << m_int << endl;
550  cout << "minInt: " << m_minInt << endl;
551  cout << "maxInt: " << m_maxInt << endl;
552  cout << "minActual: " << m_minActual << endl;
553  cout << "maxActual: " << m_maxActual << endl;
554  cout << "realInt: " << m_int* m_toReal << endl;
555  cout << "toReal: " << m_toReal << endl;
556  cout << "clock: " << m_finishClock << endl;
557  cout << "debug|printVhdl: " << m_debug << "|" << getPrintVhdl() << endl;
558  cout << "-----------------------------------" << endl;
559  }
560 
561  TRGCDCJSignal const TRGCDCJSignal::shift(int nBits, int operate) const
562  {
563  TRGCDCJSignal t_signal(*this);
564 
565  if (t_signal.m_argumentSignals.size() == 0) t_signal.initArgumentSignals();
566 
567  t_signal.m_bitsize -= nBits;
568  t_signal.m_int = floor(this->m_int / pow(2, nBits));
569  t_signal.m_minInt = floor(this->m_minInt / pow(2, nBits));
570  t_signal.m_maxInt = floor(this->m_maxInt / pow(2, nBits));
571  if (operate == 0) {
572  t_signal.m_toReal = this->m_toReal * pow(2, nBits);
573  } else {
574  t_signal.m_actual = this->m_actual / pow(2, nBits);
575  t_signal.m_minActual = this->m_minActual / pow(2, nBits);
576  t_signal.m_maxActual = this->m_maxActual / pow(2, nBits);
577  }
578 
579  t_signal.checkInt("TRGCDCJSignal::shift()");
580 
581  if (getPrintVhdl() == 1) {
582  if (nBits < 0) {
583  vhdlCode("shift_left", *this, t_signal, t_signal.m_vhdlCode);
584  } else if (nBits != 0) {
585  vhdlCode("shift_right", *this, t_signal, t_signal.m_vhdlCode);
586  }
587  }
588 
589  return t_signal;
590  }
591 
592  TRGCDCJSignal const TRGCDCJSignal::offset(TRGCDCJSignal const& valueMin) const
593  {
594  TRGCDCJSignal t_offset = *this - valueMin;
595  // Need to find minimum bitsize
596  t_offset.m_bitsize = t_offset.calBitwidth();
597  if (t_offset.calType() != 1) cout << "[Error] TRGCDCJSignal::offset() => t_offset min value below 0. " << endl;
598  t_offset.m_type = 1;
599  // Check if there is overflow or underflow
600  t_offset.checkInt("TRGCDCJSignal::offset()");
601  // Reset vhdlCode.
602  if (getPrintVhdl() == 1) vhdlCode(*this, "-", valueMin, t_offset, t_offset.m_vhdlCode);
603  return t_offset;
604  }
605 
606  TRGCDCJSignal const TRGCDCJSignal::invOffset(TRGCDCJSignal const& valueMin) const
607  {
608  TRGCDCJSignal t_result = *this + valueMin;
609  // Set bitsize and type.
610  t_result.m_type = t_result.calType();
611  t_result.m_bitsize = t_result.calBitwidth();
612 
613  // Check if there is overflow or underflow
614  t_result.checkInt("TRGCDCJSignal::invOffset()");
615  // Reset vhdlCode.
616  if (getPrintVhdl() == 1) vhdlCode(*this, "+", valueMin, t_result, t_result.m_vhdlCode);
617  return t_result;
618  }
619 
620 
621  void TRGCDCJSignal::choose(TRGCDCJSignal& target, TRGCDCJSignal const& targetMin, TRGCDCJSignal const& targetMax,
622  TRGCDCJSignal const& reference, std::vector<std::vector<TRGCDCJSignal> > data, int targetClock)
623  {
624 
625  TRGCDCJSignal t_reference(reference);
626  if (t_reference.m_argumentSignals.size() == 0) t_reference.initArgumentSignals();
627 
628  // Handle input errors.
629  if (data.size() == 0 || data.size() == 1) {
630  cout << "[Error] TRGCDCJSignal::choose() => There is not enough data." << endl;
631  return;
632  }
633  if ((*(data.end() - 1)).size() != 1) {
634  cout << "[Error] TRGCDCJSignal::choose() => Last data doesn't contain 1 TRGCDCJSignal." << endl;
635  return;
636  }
637 
638  // Calculate result final clock.
639  int t_maxClock = t_reference.m_finishClock;
640  for (unsigned iCondition = 0; iCondition < data.size(); iCondition++) {
641  const TRGCDCJSignal* assign = &(data[iCondition][0]);
642  if (t_maxClock < assign->m_finishClock) t_maxClock = assign->m_finishClock;
643  }
644  // Save final clock.
645  if (targetClock == -3) target.m_finishClock = t_maxClock + 1;
646  else {
647  if (targetClock < t_maxClock) cout << "[Error] TRGCDCJSignal::choose() => targetClock is too small." << endl;
648  else target.m_finishClock = targetClock;
649  }
650 
651  // Change assignment black signal constructors to min and max.
652  // Change assignment min, max (int, actual).
653  signed long long t_minInt = targetMin.m_minInt;
654  signed long long t_maxInt = targetMax.m_maxInt;
655  double t_minActual = targetMin.m_minActual;
656  double t_maxActual = targetMax.m_maxActual;
657  for (unsigned iCondition = 0; iCondition < data.size(); iCondition++) {
658  TRGCDCJSignal* from = 0;
659  TRGCDCJSignal* to = 0;
660  TRGCDCJSignal* assign = &(data[iCondition][0]);
661 
662  // To keep properties.
663  TRGCDCJSignal t_assign(*assign);
664 
665  // To prevent target clock to become constant.
666  //if(assign->m_minInt==assign->m_maxInt) assign->m_finishClock= target.m_finishClock-1;
667  //else assign->m_finishClock= target.m_finishClock;
668  // Change finish clock to target clock.
669  // Init arguments.
670  if (assign->m_argumentSignals.size() == 0) assign->initArgumentSignals();
671  assign->m_finishClock = target.m_finishClock;
672 
673  // Change min, max (int, actual), type values.
674  assign->m_minInt = t_minInt;
675  assign->m_maxInt = t_maxInt;
676  assign->m_minActual = t_minActual;
677  assign->m_maxActual = t_maxActual;
678  assign->m_type = assign->calType();
679  assign->m_bitsize = assign->calBitwidth();
680  // Calculated vhdlCode due to above changes.
681  if (reference.getPrintVhdl() == 1) vhdlCode("none", t_assign, *assign, assign->m_vhdlCode);
682 
683  // For non-default
684  if (data[iCondition].size() != 1) {
685  // Change blank signal constructors to min and max.
686  from = &(data[iCondition][1]);
687  to = &(data[iCondition][2]);
688  if (from->m_bitsize == -1) {
689  (*from) = TRGCDCJSignal(t_reference.m_minInt, t_reference.m_toReal, t_reference.m_minInt, t_reference.m_minInt,
690  t_reference.m_minActual, t_reference.m_minActual, t_reference.m_minActual, -1, t_reference.m_commonData);
691  }
692  if (to->m_bitsize == -1) {
693  (*to) = TRGCDCJSignal(t_reference.m_maxInt, t_reference.m_toReal, t_reference.m_maxInt, t_reference.m_maxInt,
694  t_reference.m_maxActual, t_reference.m_maxActual, t_reference.m_maxActual, -1, t_reference.m_commonData);
695  }
696  }
697 
698  if (from) {
699  if (from->m_argumentSignals.size() == 0) from->initArgumentSignals();
700  }
701  if (to) {
702  if (to->m_argumentSignals.size() == 0) to->initArgumentSignals();
703  }
704  }
705  // For integer case.
706  for (unsigned iCondition = 0; iCondition < data.size(); iCondition++) {
707  TRGCDCJSignal const* assign = &(data[iCondition][0]);
708  // For default case.
709  if (data[iCondition].size() == 1) {
710  string t_string = "";
711  target.assignTo(*assign, target.m_finishClock, t_string);
712  // For non-default cases.
713  } else {
714  TRGCDCJSignal const* from = &(data[iCondition][1]);
715  TRGCDCJSignal const* to = &(data[iCondition][2]);
716  if (t_reference.m_int >= from->m_int && t_reference.m_int <= to->m_int) {
717  string t_string = "";
718  target.assignTo(*assign, target.m_finishClock, t_string);
719  break;
720  }
721  }
722  }
723  // For actual case.
724  for (unsigned iCondition = 0; iCondition < data.size(); iCondition++) {
725  TRGCDCJSignal const* assign = &(data[iCondition][0]);
726  // For default case.
727  if (data[iCondition].size() == 1) {
728  target.m_actual = (*assign).m_actual;
729  // For non-default case.
730  } else {
731  TRGCDCJSignal const* from = &(data[iCondition][1]);
732  TRGCDCJSignal const* to = &(data[iCondition][2]);
733  assign = &(data[iCondition][0]);
734  if (t_reference.m_actual >= from->m_actual && t_reference.m_actual <= to->m_actual) {
735  target.m_actual = (*assign).m_actual;
736  break;
737  }
738  }
739  }
740 
741  target.checkInt("TRGCDCJSignal::choose()");
742 
743  // Print Vhdl code.
744  if (reference.getPrintVhdl() == 1) {
745  string t_finalCode = chooseVhdlCode(target, t_reference, data);
746  target.m_commonData->m_vhdlInProcess += t_finalCode + "\n";
747  //target.printVhdl(t_finalCode);
748  }
749 
750  }
751 
752  void TRGCDCJSignal::choose(TRGCDCJSignal& target, TRGCDCJSignal const& targetMin, TRGCDCJSignal const& targetMax,
753  TRGCDCJSignal const& reference, const std::vector<std::vector<TRGCDCJSignal> >& data)
754  {
755  choose(target, targetMin, targetMax, reference, data, -3);
756  }
757 
758  void TRGCDCJSignal::choose(TRGCDCJSignal& target, TRGCDCJSignal const& reference,
759  const std::vector<std::vector<TRGCDCJSignal> >& data,
760  int targetClock)
761  {
762 
763  signed long long t_minInt;
764  signed long long t_maxInt;
765  double t_minActual;
766  double t_maxActual;
767  double t_toReal;
768  // Find targetMin and targetMax between assignments.
769  for (unsigned iCondition = 0; iCondition < data.size(); iCondition++) {
770  const TRGCDCJSignal* assign = &(data[iCondition][0]);
771  if (iCondition == 0) {
772  t_minInt = assign->getMinInt();
773  t_maxInt = assign->getMaxInt();
774  t_minActual = assign->getMinActual();
775  t_maxActual = assign->getMaxActual();
776  t_toReal = assign->getToReal();
777  } else {
778  if (t_minInt > assign->getMinInt()) t_minInt = assign->getMinInt();
779  if (t_maxInt < assign->getMaxInt()) t_maxInt = assign->getMaxInt();
780  if (t_minActual > assign->getMinActual()) t_minActual = assign->getMinActual();
781  if (t_maxActual < assign->getMaxActual()) t_maxActual = assign->getMaxActual();
782  if (t_toReal != assign->getToReal()) cout << "[Error] TRGCDCJSignal::choose() => toReal are not same between assignments in data."
783  << endl;
784  }
785  }
786 
787  TRGCDCJSignal t_targetMax(t_maxInt, t_toReal, t_maxInt, t_maxInt, t_maxActual, t_maxActual, t_maxActual, -1, target.m_commonData);
788  TRGCDCJSignal t_targetMin(t_minInt, t_toReal, t_minInt, t_minInt, t_minActual, t_minActual, t_minActual, -1, target.m_commonData);
789 
790  choose(target, t_targetMin, t_targetMax, reference, data, targetClock);
791  }
792 
793  void TRGCDCJSignal::choose(TRGCDCJSignal& target, TRGCDCJSignal const& reference,
794  const std::vector<std::vector<TRGCDCJSignal> >& data)
795  {
796  choose(target, reference, data, -3);
797  }
798 
799 
800  void TRGCDCJSignal::ifElse(std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > >& data,
801  int targetClock)
802  {
803  // Handle input errors.
804  if (data.size() == 0) {
805  cout << "[Error] TRGCDCJSignal::ifElse() => There is not enough data." << endl;
806  return;
807  }
808 
809  // Init arguments of data.
810  // These errors prevent else case being in between data.
811  // Loop over all cases.
812  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
813  TRGCDCJSignal const& comp = data[iCase].first;
814  if (iCase != (data.size() - 1)) {
815  if (comp.m_argumentSignals.size() == 0) cout << "[Error] TRGCDCJSignal::ifElse() => comp signal has no m_vhdl." << endl;
816  if (comp.m_minInt != 0
817  || comp.m_maxInt != 1) cout << "[Error] TRGCDCJSignal::ifElse() => comp signal m_minInt or m_maxInt is not correct." << endl;
818  }
819  // Loop over all assignments.
820  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
821  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
822  //if(rhs.m_type==2) cout<<"[Error] TRGCDCJSignal::ifElse() => Cannot handle slv in assignments currently. Should be fixed later."<<endl;
823  if (rhs.m_argumentSignals.size() == 0) rhs.initArgumentSignals();
824  }
825  }
826 
827  // Calculate final clock.
828  // Loop over all cases.
829  int t_maxClock = data[0].first.calFinishClock();
830  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
831  int t_clock = data[iCase].first.calFinishClock();
832  if (t_maxClock < t_clock) t_maxClock = t_clock;
833  // Loop over all assignments.
834  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
835  TRGCDCJSignal const& rhs = data[iCase].second[iAssignment].second;
836  t_clock = rhs.calFinishClock();
837  if (t_maxClock < t_clock) t_maxClock = t_clock;
838  }
839  }
840  int t_finishClock = 0;
841  if (targetClock == -3) {
842  if (t_maxClock < 0) cout << "[Error] TRGCDCJSignal::ifElse() => t_maxClock is negative. Did not consider this case." << endl;
843  t_finishClock = t_maxClock + 1;
844  } else {
845  if (targetClock < t_maxClock) cout << "[Error] TRGCDCJSignal::ifElse() => targetClock is too small." << endl;
846  else t_finishClock = targetClock;
847  }
848 
849  // Change rhs, comp clock to finish clock.
850  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
851  TRGCDCJSignal& comp = data[iCase].first;
852  comp.m_finishClock = t_finishClock;
853  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
854  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
855  rhs.m_finishClock = t_finishClock;
856  }
857  }
858 
859  // Find min and max ranges between all rhs.
860  // <minInt, maxInt, minActual, maxActual>
861  map<TRGCDCJSignal*, pair<vector<long long int>, vector<double> > > t_signalsRange;
862  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
863  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
864  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
865  TRGCDCJSignal& lhs = *(data[iCase].second[iAssignment].first);
866  if (t_signalsRange.find(&lhs) == t_signalsRange.end()) {
867  vector<long long int> t_intRange = {rhs.m_minInt, rhs.m_maxInt};
868  vector<double> t_actualRange = {rhs.m_minActual, rhs.m_maxActual};
869  t_signalsRange[&lhs] = make_pair(t_intRange, t_actualRange);
870  } else {
871  long long int& t_minInt = t_signalsRange[&lhs].first[0];
872  long long int& t_maxInt = t_signalsRange[&lhs].first[1];
873  double& t_minActual = t_signalsRange[&lhs].second[0];
874  double& t_maxActual = t_signalsRange[&lhs].second[1];
875  if (t_minInt > rhs.m_minInt) t_minInt = rhs.m_minInt;
876  if (t_maxInt < rhs.m_maxInt) t_maxInt = rhs.m_maxInt;
877  if (t_minActual > rhs.m_minActual) t_minActual = rhs.m_minActual;
878  if (t_maxActual < rhs.m_maxActual) t_maxActual = rhs.m_maxActual;
879  }
880  }
881  }
882  // Change min, max ranges and type, bitwidth for all rhs.
883  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
884  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
885  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
886  TRGCDCJSignal& lhs = *(data[iCase].second[iAssignment].first);
887  TRGCDCJSignal orgRhs(rhs);
888  long long int& t_minInt = t_signalsRange[&lhs].first[0];
889  long long int& t_maxInt = t_signalsRange[&lhs].first[1];
890  double& t_minActual = t_signalsRange[&lhs].second[0];
891  double& t_maxActual = t_signalsRange[&lhs].second[1];
892  rhs.m_minInt = t_minInt;
893  rhs.m_maxInt = t_maxInt;
894  rhs.m_minActual = t_minActual;
895  rhs.m_maxActual = t_maxActual;
896  rhs.m_type = rhs.calType();
897  rhs.m_bitsize = rhs.calBitwidth();
898  if (rhs.getPrintVhdl() == 1) vhdlCode("none", orgRhs, rhs, rhs.m_vhdlCode);
899  }
900  }
901 
902  // For integer case.
903  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
904  TRGCDCJSignal const& comp = data[iCase].first;
905  // If comp is 1 or else.
906  if (comp.m_int == 1 || comp.m_bitsize == -1) {
907  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
908  TRGCDCJSignal& lhs = *(data[iCase].second[iAssignment].first);
909  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
910  string t_string = "";
911  lhs.assignTo(rhs, t_finishClock, t_string);
912  // Check ranges.
913  lhs.checkInt("TRGCDCJSignal::ifElse()");
914  }
915  break;
916  }
917  }
918 
919  // For actual case.
920  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
921  TRGCDCJSignal const& comp = data[iCase].first;
922  // If comp is 1 or else.
923  if (comp.m_actual == 1 || comp.m_bitsize == -1) {
924  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
925  TRGCDCJSignal& lhs = *(data[iCase].second[iAssignment].first);
926  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
927  lhs.m_actual = rhs.m_actual;
928  }
929  break;
930  }
931  }
932 
933  // Print vhdl code.
934  if (data[0].first.getPrintVhdl() == 1) {
935  // Set m_commonData for all lhs signals.
936  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
937  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
938  TRGCDCJSignal& lhs = *(data[iCase].second[iAssignment].first);
939  /* cppcheck-suppress variableScope */
940  TRGCDCJSignal& rhs = data[iCase].second[iAssignment].second;
941  if (lhs.m_commonData == 0) lhs.m_commonData = rhs.m_commonData;
942  }
943  }
944  string t_finalCode = ifElseVhdlCode(data);
945  data[0].first.m_commonData->m_vhdlInProcess += t_finalCode + "\n";
946  }
947 
948 
949  }
950 
951  void TRGCDCJSignal::ifElse(std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > >& data)
952  {
953  ifElse(data, -3);
954  }
955 
956 
957  TRGCDCJSignal const TRGCDCJSignal::limit(signed long long minInt, signed long long maxInt, double minActual,
958  double maxActual) const
959  {
960  TRGCDCJSignal t_result(*this);
961 
962  //if(t_result.m_type==2) {
963  // cout<<"[Error] TRGCDCJSignal::limit() => should not be used with slv type."<<endl;
964  //}
965 
966 
967  if (t_result.m_argumentSignals.size() == 0) t_result.initArgumentSignals();
968 
969  t_result.m_minInt = minInt;
970  t_result.m_maxInt = maxInt;
971  t_result.m_minActual = minActual;
972  t_result.m_maxActual = maxActual;
973  t_result.m_type = t_result.calType();
974  t_result.m_bitsize = t_result.calBitwidth();
976  //t_result.checkInt("TRGCDCJSignal::limit()");
977 
978 
979  if (getPrintVhdl() == 1) vhdlCode("none", *this, t_result, t_result.m_vhdlCode);
980  //t_result.m_vhdlCode = "resize("+t_result.m_vhdlCode+","+to_string(t_result.m_bitsize)+")";
981  return t_result;
982  }
983 
984  TRGCDCJSignal const TRGCDCJSignal::limit(TRGCDCJSignal const& min, TRGCDCJSignal const& max) const
985  {
986  return limit(min.m_int, max.m_int, min.m_actual, max.m_actual);
987  }
988 
989  TRGCDCJSignal const TRGCDCJSignal::resize(int bitwidth) const
990  {
991  if (this->m_bitsize == bitwidth) return (*this);
992 
993  TRGCDCJSignal t_result(*this);
994  if (t_result.m_argumentSignals.size() == 0) t_result.initArgumentSignals();
995 
996  t_result.m_bitsize = bitwidth;
997  // Check if there is overflow or underflow.
998  t_result.checkInt("TRGCDCJSignal::resize()");
999 
1000 
1001  if (getPrintVhdl() == 1) vhdlCode("resize", *this, t_result, t_result.m_vhdlCode);
1002  //t_result.m_vhdlCode = "resize("+t_result.m_vhdlCode+","+to_string(t_result.m_bitsize)+")";
1003  return t_result;
1004  }
1005 
1006  //TRGCDCJSignal const TRGCDCJSignal::toSigned() const {
1007  // if(m_type==-1) return (*this);
1008 
1009  // TRGCDCJSignal t_result(*this);
1010  // if(t_result.m_argumentSignals.size() ==0) t_result.initArgumentSignals();
1011 
1012  // t_result.m_type = -1;
1013  // t_result.m_bitsize = m_bitsize+1;
1014  // // Check if there is overflow or underflow.
1015  // t_result.checkInt("TRGCDCJSignal::toSigned()");
1016  //
1017 
1018  // if(getPrintVhdl()==1) vhdlCode("signed", *this, t_result, t_result.m_vhdlCode);
1019  // //t_result.m_vhdlCode = "resize("+t_result.m_vhdlCode+","+to_string(t_result.m_bitsize)+")";
1020  // return t_result;
1021  //}
1022 
1023  //TRGCDCJSignal const TRGCDCJSignal::toUnsigned() const {
1024  // if(m_type==1) return (*this);
1025  // TRGCDCJSignal t_result(*this);
1026  // if(t_result.m_argumentSignals.size() ==0) t_result.initArgumentSignals();
1027 
1028  // t_result.m_type = 1;
1029  // t_result.m_bitsize = m_bitsize-1;
1030  // // Check if there is overflow or underflow.
1031  // t_result.checkInt("TRGCDCJSignal::toUnsigned()");
1032  //
1033 
1034  // if(getPrintVhdl()==1) vhdlCode("unsigned", *this, t_result, t_result.m_vhdlCode);
1035  // //t_result.m_vhdlCode = "resize("+t_result.m_vhdlCode+","+to_string(t_result.m_bitsize)+")";
1036  // return t_result;
1037  //}
1038 
1039 
1040  TRGCDCJSignal const TRGCDCJSignal::slvToSigned(TRGCDCJSignal const& in, double const& toReal, signed long long const& minInt,
1041  signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock)
1042  {
1043 
1044  vector<bool> const& slv = in.m_slv;
1045 
1046  // Check input
1047  if (in.m_type != 2) cout << "[Error] TRGCDCJSignal::slvToSigned() => type is not slv." << endl;
1048  if (slv.size() > 63) cout << "[Error] TRGCDCJSignal::slvToSigned() => bitwidth is too large." << endl;
1049 
1050  TRGCDCJSignal result(in);
1051 
1052  // Calculate value. [Index 0 is lsb]
1053  result.m_int = 0;
1054  for (unsigned iBit = 0; iBit < slv.size() - 1; iBit++) {
1055  result.m_int += slv[iBit] * pow(2, iBit);
1056  }
1057  result.m_int -= slv[slv.size() - 1] * pow(2, slv.size() - 1);
1058  // Set values.
1059  result.m_minInt = minInt;
1060  result.m_maxInt = maxInt;
1061  result.m_actual = actual;
1062  result.m_minActual = minActual;
1063  result.m_maxActual = maxActual;
1064  result.m_toReal = toReal;
1065  result.m_type = 0;
1066  result.m_type = result.calType();
1067  result.m_bitsize = result.calBitwidth();
1068  result.m_finishClock = finishClock;
1069  // Check if there is overflow or underflow.
1070  result.checkInt("slvToSigned");
1071  result.m_commonData = in.m_commonData;
1072 
1073  return result;
1074  }
1075 
1076  TRGCDCJSignal const TRGCDCJSignal::slvToSigned(TRGCDCJSignal const& in)
1077  {
1078  return slvToSigned(in, in.m_toReal, in.m_minInt, in.m_maxInt, in.m_actual, in.m_minActual, in.m_maxActual, in.m_finishClock);
1079  }
1080 
1081  TRGCDCJSignal const TRGCDCJSignal::slvToUnsigned(TRGCDCJSignal const& in, double const& toReal, signed long long const& minInt,
1082  signed long long const& maxInt, double const& actual, double const& minActual, double const& maxActual, int const& finishClock)
1083  {
1084 
1085  vector<bool> const& slv = in.m_slv;
1086 
1087  // Check input
1088  if (in.m_type != 2) cout << "[Error] TRGCDCJSignal::slvToUnsigned() => type is not slv." << endl;
1089  if (slv.size() > 63) cout << "[Error] TRGCDCJSignal::slvToUnsigned() => bitwidth is too large." << endl;
1090 
1091  TRGCDCJSignal result(in);
1092 
1093  // Calculate value. [Index 0 is lsb]
1094  result.m_int = 0;
1095  for (unsigned iBit = 0; iBit < slv.size(); iBit++) {
1096  result.m_int += slv[iBit] * pow(2, iBit);
1097  }
1098  // Set values.
1099  result.m_minInt = minInt;
1100  result.m_maxInt = maxInt;
1101  result.m_actual = actual;
1102  result.m_minActual = minActual;
1103  result.m_maxActual = maxActual;
1104  result.m_toReal = toReal;
1105  result.m_type = 0;
1106  result.m_type = result.calType();
1107  result.m_bitsize = result.calBitwidth();
1108  result.m_finishClock = finishClock;
1109  // Check if there is overflow or underflow.
1110  result.checkInt("slvToSigned");
1111  result.m_commonData = in.m_commonData;
1112 
1113  return result;
1114  }
1115 
1116  TRGCDCJSignal const TRGCDCJSignal::slvToUnsigned(TRGCDCJSignal const& in)
1117  {
1118  return slvToUnsigned(in, in.m_toReal, in.m_minInt, in.m_maxInt, in.m_actual, in.m_minActual, in.m_maxActual, in.m_finishClock);
1119  }
1120 
1121  TRGCDCJSignal const TRGCDCJSignal::toSlv(TRGCDCJSignal const& in, int /*test*/)
1122  {
1123 
1124  TRGCDCJSignal result(in);
1125 
1126  // Temporary signal.
1127  //test += 0; //TODO why?
1128  signed long long t_int = in.m_int;
1129  if (in.m_type == -1) {
1130  // Change signed m_int to vector<bool>
1131  t_int = ~t_int;
1132  t_int += 1;
1133  result.m_slv.clear();
1134  result.m_slv.resize(in.m_bitsize);
1135  for (int iBit = 0; iBit < in.m_bitsize; iBit++) {
1136  result.m_slv[iBit] = (bool)(t_int >> iBit) & 1;
1137  }
1138  } else if (in.m_type == 1) {
1139  // Change unsigned m_int to vector<bool>
1140  result.m_slv.clear();
1141  result.m_slv.resize(in.m_bitsize);
1142  for (int iBit = 0; iBit < in.m_bitsize; iBit++) {
1143  result.m_slv[iBit] = (bool)(t_int >> iBit) & 1;
1144  }
1145  } else {
1146  cout << "[Error] TRGCDCJSignal::toSlv() => m_type is not 1 or -1." << endl;
1147  }
1148 
1149  return result;
1150  }
1151 
1152  TRGCDCJSignal const TRGCDCJSignal::toSlv(TRGCDCJSignal const& in)
1153  {
1154  if (in.m_type == 2) return (in);
1155  // Don't think I need below but will keep it for now.
1156  if (in.m_type == -1) {
1157  cout << "[Error] TRGCDCJSignal::toSlv() => Slv is not same as unsigned anymore." << endl;
1158  }
1159  TRGCDCJSignal t_result(in);
1160  t_result.m_type = 2;
1161 
1162  if (in.getPrintVhdl() == 1) vhdlCode("std_logic_vector", in, t_result, t_result.m_vhdlCode);
1163 
1164  return t_result;
1165  }
1166 
1167 
1168 
1169  TRGCDCJSignal TRGCDCJSignal::comp(TRGCDCJSignal const& lhs, const std::string& operate, TRGCDCJSignal const& rhs)
1170  {
1171  // Make copies for method.
1172  TRGCDCJSignal t_lhs(lhs);
1173  TRGCDCJSignal t_rhs(rhs);
1174  TRGCDCJSignal t_result(t_lhs);
1175  // Make arguments.
1176  if (t_lhs.m_argumentSignals.size() == 0) t_lhs.initArgumentSignals();
1177  if (t_rhs.m_argumentSignals.size() == 0) t_rhs.initArgumentSignals();
1178  combineArguments(t_lhs, t_rhs, t_result);
1179  // Int Operation.
1180  bool t_bool = false;
1181  if (operate == "=") {
1182  t_bool = (t_lhs.m_int == t_rhs.m_int ? 1 : 0);
1183  } else if (operate == "/=") {
1184  t_bool = (t_lhs.m_int != t_rhs.m_int ? 1 : 0);
1185  } else if (operate == "<") {
1186  t_bool = (t_lhs.m_int < t_rhs.m_int ? 1 : 0);
1187  } else if (operate == "<=") {
1188  t_bool = (t_lhs.m_int <= t_rhs.m_int ? 1 : 0);
1189  } else if (operate == ">") {
1190  t_bool = (t_lhs.m_int > t_rhs.m_int ? 1 : 0);
1191  } else if (operate == ">=") {
1192  t_bool = (t_lhs.m_int >= t_rhs.m_int ? 1 : 0);
1193  } else if (operate == "and") {
1194  t_bool = (t_lhs.m_int && t_rhs.m_int ? 1 : 0);
1195  } else if (operate == "or") {
1196  t_bool = (t_lhs.m_int || t_rhs.m_int ? 1 : 0);
1197  } else {
1198  cout << "[Error] TRGCDCJSignal::comp() => No operator named " << operate << "." << endl;
1199  }
1200  // Actual Operation.
1201  if (operate == "=") {
1202  t_result.m_actual = (t_lhs.m_actual == t_rhs.m_actual ? 1 : 0);
1203  } else if (operate == "/=") {
1204  t_result.m_actual = (t_lhs.m_actual != t_rhs.m_actual ? 1 : 0);
1205  } else if (operate == "<") {
1206  t_result.m_actual = (t_lhs.m_actual < t_rhs.m_actual ? 1 : 0);
1207  } else if (operate == "<=") {
1208  t_result.m_actual = (t_lhs.m_actual <= t_rhs.m_actual ? 1 : 0);
1209  } else if (operate == ">") {
1210  t_result.m_actual = (t_lhs.m_actual > t_rhs.m_actual ? 1 : 0);
1211  } else if (operate == ">=") {
1212  t_result.m_actual = (t_lhs.m_actual >= t_rhs.m_actual ? 1 : 0);
1213  } else if (operate == "and") {
1214  t_result.m_actual = (t_lhs.m_actual && t_rhs.m_actual ? 1 : 0);
1215  } else if (operate == "or") {
1216  t_result.m_actual = (t_lhs.m_actual || t_rhs.m_actual ? 1 : 0);
1217  } else {
1218  cout << "[Error] TRGCDCJSignal::comp() => No operator named " << operate << "." << endl;
1219  }
1220  // Change values.
1221  t_result.m_name = t_lhs.m_name + operate + t_rhs.m_name;
1222  t_result.m_type = 1;
1223  t_result.m_bitsize = 1;
1224  t_result.m_minInt = 0;
1225  t_result.m_maxInt = 1;
1226  t_result.m_minActual = 0;
1227  t_result.m_maxActual = 1;
1228  t_result.m_toReal = 1;
1229  if (t_bool == 1) {
1230  t_result.m_int = 1;
1231  } else {
1232  t_result.m_int = 0;
1233  }
1234 
1235  if (t_result.getPrintVhdl() == 1) vhdlCode(t_lhs, operate, t_rhs, t_result, t_result.m_vhdlCode);
1236 
1237  return t_result;
1238 
1239  }
1240 
1241  void TRGCDCJSignal::swap(TRGCDCJSignal& first, TRGCDCJSignal& second) const
1242  {
1243  std::swap(first.m_name, second.m_name);
1244  std::swap(first.m_type, second.m_type);
1245  std::swap(first.m_bitsize, second.m_bitsize);
1246  std::swap(first.m_int, second.m_int);
1247  std::swap(first.m_minInt, second.m_minInt);
1248  std::swap(first.m_maxInt, second.m_maxInt);
1249  std::swap(first.m_actual, second.m_actual);
1250  std::swap(first.m_minActual, second.m_minActual);
1251  std::swap(first.m_maxActual, second.m_maxActual);
1252  std::swap(first.m_toReal, second.m_toReal);
1253  std::swap(first.m_debug, second.m_debug);
1254  std::swap(first.m_vhdlCode, second.m_vhdlCode);
1255  std::swap(first.m_argumentSignals, second.m_argumentSignals);
1256  std::swap(first.m_finishClock, second.m_finishClock);
1257  std::swap(first.m_commonData, second.m_commonData);
1258  }
1259 
1260  void TRGCDCJSignal::matchUnit(TRGCDCJSignal& first, TRGCDCJSignal& second) const
1261  {
1262  if (first.m_toReal != second.m_toReal) {
1263  // Find number of bits to shift to match unit.
1264  double t_nBits = log(first.m_toReal / second.m_toReal) / log(2);
1265  // Round to integer
1266  if (t_nBits > 0) {
1267  t_nBits = int(t_nBits + 0.5);
1268  } else {
1269  t_nBits = int(t_nBits - 0.5);
1270  }
1271  // Shift bits to match unit
1272  if (t_nBits > 0) {
1273  first = first.shift(-t_nBits, 0);
1274  //cout<<"mu::shift_left(resize(" + first.m_name + "," + to_string(int(first.m_bitsize+t_nBits)) + ")," + to_string(int(t_nBits)) + ")"<<endl;
1275  //cout<<first.m_vhdlCode<<endl;
1276  } else if (t_nBits < 0) {
1277  second = second.shift(t_nBits, 0);
1278  //cout<<"mu::shift_left(resize(" + second.m_name + "," + to_string(int(second.m_bitsize-t_nBits)) + ")," + to_string(int(-t_nBits)) + ")"<<endl;
1279  //cout<<second.m_vhdlCode<<endl;
1280  }
1281 
1282  if (fabs(first.m_toReal - second.m_toReal) > 0.00001 * first.m_toReal) {
1283  cout << "[Warning] TRGCDCJSignal::matchUnit() => in1 and in2 units are still different." << endl;
1284  cout << first.m_toReal << " " << second.m_toReal << endl;
1285  }
1286 
1287  if (m_debug == 1) {
1288  cout << "TRGCDCJSignal::matchUnit()" << endl;
1289  if (t_nBits > 0) cout << "lhs was shifted to left by " << t_nBits << endl;
1290  else if (t_nBits < 0) cout << "rhs was shifted to left by " << -t_nBits << endl;
1291  cout << "TRGCDCJSignal::matchUnit()" << endl;
1292  }
1293  } // End of if units are different.
1294  first.checkInt("TRGCDCJSignal::matchUnit()::first");
1295  second.checkInt("TRGCDCJSignal::matchUnit()::second");
1296  }
1297 
1298  void TRGCDCJSignal::setName(const string& name)
1299  {
1300  m_name = name;
1301  }
1302 
1303  void TRGCDCJSignal::setInt(signed long long value)
1304  {
1305  m_int = value;
1306  }
1307 
1308  void TRGCDCJSignal::setActual(double value)
1309  {
1310  m_actual = value;
1311  }
1312 
1313  void TRGCDCJSignal::setToReal(double value)
1314  {
1315  m_toReal = value;
1316  }
1317 
1318  void TRGCDCJSignal::setType(int type)
1319  {
1320  m_type = type;
1321  }
1322 
1323  void TRGCDCJSignal::setBitsize(int bitsize)
1324  {
1325  m_bitsize = bitsize;
1326 
1327  // Check if there is overflow or underflow.
1328  checkInt("TRGCDCJSignal::setBitsize()");
1329  }
1330 
1331  void TRGCDCJSignal::setFinishClock(int finishClock)
1332  {
1333  m_finishClock = finishClock;
1334  }
1335 
1336  void TRGCDCJSignal::setDebug(bool debug)
1337  {
1338  m_debug = debug;
1339  }
1340 
1341  void TRGCDCJSignal::setPrintVhdl(bool printVhdl)
1342  {
1343  if (m_commonData) m_commonData->m_printVhdl = printVhdl;
1344  else {
1345  cout << "[Error] TRGCDCJSignal::setPrintVhdl() => m_commonData does not exist." << endl;
1346  }
1347  }
1348 
1349  void TRGCDCJSignal::setVhdlOutputFile(const string& filename)
1350  {
1351  if (m_commonData) m_commonData->m_vhdlOutputFile = filename;
1352  else {
1353  cout << "[Error] TRGCDCJSignal::setVhdlOutputFile() => m_commonData does not exist." << endl;
1354  }
1355  }
1356 
1357  void TRGCDCJSignal::setCommonData(TRGCDCJSignalData* commonData)
1358  {
1359  m_commonData = commonData;
1360  }
1361 
1362  string TRGCDCJSignal::getName() const
1363  {
1364  return m_name;
1365  }
1366 
1367  int TRGCDCJSignal::getType() const
1368  {
1369  return m_type;
1370  }
1371 
1372  double TRGCDCJSignal::getBitsize() const
1373  {
1374  return m_bitsize;
1375  }
1376 
1377  signed long long TRGCDCJSignal::getInt() const
1378  {
1379  return m_int;
1380  }
1381 
1382  signed long long TRGCDCJSignal::getMinInt() const
1383  {
1384  return m_minInt;
1385  }
1386 
1387  signed long long TRGCDCJSignal::getMaxInt() const
1388  {
1389  return m_maxInt;
1390  }
1391 
1392  double TRGCDCJSignal::getActual() const
1393  {
1394  return m_actual;
1395  }
1396 
1397  double TRGCDCJSignal::getMinActual() const
1398  {
1399  return m_minActual;
1400  }
1401 
1402  double TRGCDCJSignal::getMaxActual() const
1403  {
1404  return m_maxActual;
1405  }
1406 
1407  double TRGCDCJSignal::getRealInt() const
1408  {
1409  return m_int * m_toReal;
1410  }
1411 
1412  double TRGCDCJSignal::getRealMinInt() const
1413  {
1414  return m_minInt * m_toReal;
1415  }
1416 
1417  double TRGCDCJSignal::getRealMaxInt() const
1418  {
1419  return m_maxInt * m_toReal;
1420  }
1421 
1422  double TRGCDCJSignal::getToReal() const
1423  {
1424  return m_toReal;
1425  }
1426 
1427  int TRGCDCJSignal::getFinishClock() const
1428  {
1429  return m_finishClock;
1430  }
1431 
1432  std::vector<std::pair<std::string, vector<int> > > const TRGCDCJSignal::getArgumentSignals() const
1433  {
1434  return m_argumentSignals;
1435  }
1436 
1437  TRGCDCJSignalData* TRGCDCJSignal::getCommonData() const
1438  {
1439  if (m_commonData) return m_commonData;
1440  else {
1441  cout << "[Error] TRGCDCJSignal::getCommonData() => m_commonData does not exist." << endl;
1442  return 0;
1443  }
1444  }
1445 
1446 
1447  int TRGCDCJSignal::calType() const
1448  {
1449  //if(m_type==2) cout<<"[Error] TRGCDCJSignal::calType() => m_type should not be slv."<<endl;
1450  if (m_minInt < 0) return -1;
1451  else return 1;
1452  }
1453 
1454  int TRGCDCJSignal::calType(double minValue) const
1455  {
1456  //if(m_type==2) cout<<"[Error] TRGCDCJSignal::calType() => m_type should not be slv."<<endl;
1457  if (minValue < 0) return -1;
1458  else return 1;
1459  }
1460 
1461  int TRGCDCJSignal::calBitwidth() const
1462  {
1463  //int t_bitwidth = ceil(log(max(m_maxInt, llabs(m_minInt))+1)/log(2));
1464  int t_bitwidth = ceil(log1p(max(m_maxInt, llabs(m_minInt))) / log(2));
1465  if (calType() != 1) t_bitwidth++;
1466  return t_bitwidth;
1467  }
1468 
1469  int TRGCDCJSignal::calBitwidth(int type, signed long long minInt, signed long long maxInt)
1470  {
1471  //int t_bitwidth = ceil(log(max(maxInt, llabs(minInt))+1)/log(2));
1472  int t_bitwidth = ceil(log1p(max(maxInt, llabs(minInt))) / log(2));
1473  if (type != 1) t_bitwidth++;
1474  return t_bitwidth;
1475  }
1476 
1477  int TRGCDCJSignal::calFinishClock() const
1478  {
1479  // Combined signal?
1480  if (m_argumentSignals.size() != 0) {
1481  int maxClock = -1;
1482  // Find max clock between signals.
1483  for (unsigned iSignals = 0; iSignals < m_argumentSignals.size(); iSignals++) {
1484  if (maxClock < m_argumentSignals[iSignals].second[2]) maxClock = m_argumentSignals[iSignals].second[2];
1485  }
1486  return maxClock;
1487  } else {
1488  return m_finishClock;
1489  }
1490  }
1491 
1492  string TRGCDCJSignal::getVhdlCode() const
1493  {
1494  return m_vhdlCode;
1495  }
1496 
1497  bool TRGCDCJSignal::getPrintVhdl() const
1498  {
1499  if (m_commonData) return m_commonData->m_printVhdl;
1500  else {
1501  cout << "[Error] TRGCDCJSignal::getPrintVhdl() => m_commonData does not exist." << endl;
1502  return 0;
1503  }
1504  }
1505 
1506  string TRGCDCJSignal::getVhdlOutputFile() const
1507  {
1508  if (m_commonData) return m_commonData->m_vhdlOutputFile;
1509  else {
1510  cout << "[Error] TRGCDCJSignal::getVhdlOutputFile() => m_commonData does not exist." << endl;
1511  return "";
1512  }
1513  }
1514 
1515  bool TRGCDCJSignal::orderLargestBitsize(TRGCDCJSignal& large, TRGCDCJSignal& small) const
1516  {
1517  bool result = 0;
1518  if (large.m_bitsize < small.m_bitsize) {
1519  swap(large, small);
1520  result = 1;
1521  } else if (large.m_bitsize == small.m_bitsize) {
1522  if (large.m_type == 1) {;}
1523  else if (large.m_type == -1 && small.m_type == 1) {
1524  swap(large, small);
1525  result = 1;
1526  } else if (large.m_type == 0 && small.m_type != 0) {
1527  swap(large, small);
1528  result = 1;
1529  }
1530  }
1531 
1532  return result;
1533  }
1534 
1535  signed long long TRGCDCJSignal::calMaxInteger() const
1536  {
1537  signed long long t_maxValue;
1538  if (calType() == 1) {
1539  t_maxValue = pow(2, m_bitsize) - 1;
1540  } else if (calType() == -1) {
1541  t_maxValue = pow(2, m_bitsize - 1) - 1;
1542  } else {
1543  t_maxValue = 0;
1544  }
1545  return t_maxValue;
1546  }
1547 
1548  signed long long TRGCDCJSignal::calMinInteger() const
1549  {
1550  //if(m_type==2) cout<<"[Error] TRGCDCJSignal::calMinInteger() => m_type should not be slv"<<endl;
1551  signed long long t_minValue;
1552  if (m_type == 1) {
1553  t_minValue = 0;
1554  } else if (m_type == -1) {
1555  t_minValue = -pow(2, m_bitsize - 1) + 1;
1556  } else {
1557  t_minValue = -pow(2, m_bitsize - 1) + 1;
1558  }
1559  return t_minValue;
1560  }
1561 
1562  TRGCDCJSignal const TRGCDCJSignal::absolute(TRGCDCJSignal const& first)
1563  {
1564 
1565  TRGCDCJSignal result(first);
1566 
1567  //if(result.m_type==2) cout<<"[Error] TRGCDCJSignal::absolute() => m_type should not be slv"<<endl;
1568 
1569  if (result.m_argumentSignals.size() == 0) result.initArgumentSignals();
1570 
1571  if (result.m_type != 1) {
1572  result.m_type = 1;
1573  result.m_int = llabs(first.m_int);
1574  if (first.m_minInt < 0 && first.m_maxInt > 0) result.m_minInt = 0;
1575  else result.m_minInt = min(llabs(first.m_maxInt), llabs(first.m_minInt));
1576  result.m_maxInt = max(llabs(first.m_maxInt), llabs(first.m_minInt));
1577  result.m_actual = fabs(first.m_actual);
1578  if (first.m_minActual < 0 && first.m_maxActual > 0) result.m_minActual = 0;
1579  else result.m_minActual = min(fabs(first.m_maxActual), fabs(first.m_minActual));
1580  result.m_maxActual = max(fabs(first.m_maxActual), fabs(first.m_minActual));
1581  result.m_bitsize = first.m_bitsize - 1;
1582  }
1583 
1584  result.checkInt("TRGCDCJSignal::absolute()");
1585 
1586  // For vhdl code.
1587  if (first.getPrintVhdl() == 1) vhdlCode("abs", first, result, result.m_vhdlCode);
1588 
1589  return result;
1590 
1591  }
1592 
1593  //void TRGCDCJSignal::calTypeBitwidth(TRGCDCJSignal const & lhs, string operation, TRGCDCJSignal const & rhs, int & type, int & bitwidth) const{
1594  // int outputBitsize;
1595  // int outputType;
1596  // if(operation=="+"){
1597  // // Find largest and second bitsize.
1598  // TRGCDCJSignal t_large(lhs);
1599  // TRGCDCJSignal t_small(rhs);
1600  // orderLargestBitsize(t_large, t_small);
1601  // // Calculate.
1602  // if(t_large.m_type == 1) {
1603  // if(t_small.m_type == 1) {outputBitsize = t_large.m_bitsize + 1; outputType = 1;}
1604  // else if(t_small.m_type == -1) {outputBitsize = t_large.m_bitsize + 2; outputType = -1;}
1605  // else {outputBitsize = t_large.m_bitsize + 1; outputType = -1;}
1606  // } else if(t_large.m_type == -1) {
1607  // outputBitsize = t_large.m_bitsize + 1; outputType = -1;
1608  // } else {
1609  // if(t_small.m_type == 1) {outputBitsize = t_large.m_bitsize; outputType = -1;}
1610  // else if(t_small.m_type == -1) {outputBitsize = t_large.m_bitsize + 1; outputType = -1;}
1611  // else {outputBitsize = t_large.m_bitsize + 1; outputType = 0;}
1612  // }
1613  // } else if(operation=="-"){
1614  // // Find largest and second bitsize.
1615  // TRGCDCJSignal t_large(lhs);
1616  // TRGCDCJSignal t_small(rhs);
1617  // orderLargestBitsize(t_large, t_small);
1618  // // Calculate.
1619  // if(t_large.m_type == 1) {
1620  // if(t_small.m_type == 1) {outputBitsize = t_large.m_bitsize + 1; outputType = -1;}
1621  // else if(t_small.m_type == -1) {outputBitsize = t_large.m_bitsize + 2; outputType = -1;}
1622  // else {
1623  // if(t_large.m_type == lhs.m_type){
1624  // outputBitsize = t_large.m_bitsize + 1; outputType = 1;
1625  // } else {
1626  // outputBitsize = t_large.m_bitsize + 1; outputType = 0;
1627  // }
1628  // }
1629  // } else if(t_large.m_type == -1) {
1630  // outputBitsize = t_large.m_bitsize + 1; outputType = -1;
1631  // } else {
1632  // if(t_small.m_type == 1) {
1633  // if(t_large.m_type == lhs.m_type){
1634  // outputBitsize = t_large.m_bitsize + 1; outputType = 0;
1635  // } else {
1636  // outputBitsize = t_large.m_bitsize + 1; outputType = 1;
1637  // }
1638  // }
1639  // else if(t_small.m_type == -1) {outputBitsize = t_large.m_bitsize + 1; outputType = -1;}
1640  // else {outputBitsize = t_large.m_bitsize; outputType = -1;}
1641  // }
1642  // } else if(operation=="*"){
1643  // TRGCDCJSignal t_large(lhs);
1644  // TRGCDCJSignal t_small(rhs);
1645  // orderLargestBitsize(t_large, t_small);
1646  // if(t_large.m_type == 1 || t_small.m_type == 1) {
1647  // outputBitsize = t_large.m_bitsize + t_small.m_bitsize;
1648  // if(t_large.m_type == 1) outputType = t_small.m_type;
1649  // else outputType = t_large.m_type;
1650  // } else if(t_large.m_type == 0 && t_small.m_type == 0) {
1651  // outputBitsize = t_large.m_bitsize + t_small.m_bitsize - 2;
1652  // outputType = 1;
1653  // } else {
1654  // outputBitsize = t_large.m_bitsize + t_small.m_bitsize - 1;
1655  // outputType = -1;
1656  // }
1657  // }
1658  // type = outputType;
1659  // bitwidth = outputBitsize;
1660  //}
1661 
1662  signed long long TRGCDCJSignal::calInt(double value, TRGCDCJSignal const& mother)
1663  {
1664  return (signed long long) FpgaUtility::roundInt(value / mother.m_toReal);
1665  }
1666 
1667  void TRGCDCJSignal::calVhdlTypeBitwidth(TRGCDCJSignal const& first, const std::string& operation, TRGCDCJSignal const& second,
1668  int& type,
1669  int& bitwidth)
1670  {
1671  if (first.m_type != second.m_type) {
1672  cout << "[Error] TRGCDCJSignal::calVhdlTypeBitwidth() => first and second type are different." << endl;
1673  cout << first.m_name << " " << second.m_name << endl;
1674  cout << first.m_type << " " << second.m_type << endl;
1675  return;
1676  }
1677  int firstBitwidth = first.m_bitsize;
1678  int secondBitwidth = second.m_bitsize;
1679 
1680  if (operation == "+" || operation == "-") {
1681  if (first.m_type != 1 || second.m_type != 1) {
1682  type = -1;
1683  bitwidth = max(firstBitwidth, secondBitwidth);
1684  } else {
1685  type = 1;
1686  bitwidth = max(first.m_bitsize, second.m_bitsize);
1687  }
1688  } else if (operation == "*") {
1689  if (first.m_type != 1 || second.m_type != 1) {
1690  type = -1;
1691  bitwidth = firstBitwidth + secondBitwidth;
1692  } else {
1693  type = 1;
1694  bitwidth = first.m_bitsize + second.m_bitsize;
1695  }
1696  } else if (operation == "=" || operation == "/=" || operation == "<" || operation == "<=" ||
1697  operation == ">" || operation == ">=" || operation == "and" || operation == "or") {
1698  type = 1;
1699  bitwidth = 1;
1700  } else {
1701  cout << "[Error] TRGCDCJSignal::calVhdlTypeBitwidth() => No operation named " << operation << "." << endl;
1702  }
1703  }
1704 
1705  void TRGCDCJSignal::initArgumentSignals()
1706  {
1707  string t_name;
1708  if (m_argumentSignals.size() == 0) {
1709  if (m_minInt == m_maxInt && m_type != 2) {
1710  if (m_type == 1) {
1711  //t_name="to_unsigned("+to_string(m_int)+","+to_string(m_bitsize)+")";
1712  t_name = "decimal_string_to_unsigned(\"" + to_string(m_int) + "\"," + to_string(m_bitsize) + ")";
1713  } else {
1714  //t_name="to_signed("+to_string(m_int)+","+to_string(m_bitsize)+")";
1715  t_name = "decimal_string_to_signed(\"" + to_string(m_int) + "\"," + to_string(m_bitsize) + ")";
1716  }
1717  // For non-constant constructor signal.
1718  } else if (m_name == "") {
1719  t_name = "INPUT(" + to_string(m_int) + ")";
1720  // For normal signals.
1721  } else {
1722  t_name = m_name;
1723  }
1724  //m_argumentSignals.push_back(make_pair(t_name,m_finishClock));
1725  vector<int> t_argument = {m_type, m_bitsize, m_finishClock};
1726  m_argumentSignals.push_back(make_pair(t_name, t_argument));
1727  } else {
1728  cout << "[Error] TRGCDCJSignal::initArgumentSignals() => m_argumentSignals.size() is not 0." << endl;
1729  }
1730  }
1731 
1732  void TRGCDCJSignal::combineArguments(TRGCDCJSignal const& first, TRGCDCJSignal const& second, TRGCDCJSignal& result)
1733  {
1734  result.m_argumentSignals.clear();
1735  result.m_argumentSignals.insert(result.m_argumentSignals.end(), first.m_argumentSignals.begin(), first.m_argumentSignals.end());
1736  result.m_argumentSignals.insert(result.m_argumentSignals.end(), second.m_argumentSignals.begin(), second.m_argumentSignals.end());
1737  }
1738 
1739  void TRGCDCJSignal::initVhdlCode()
1740  {
1741  if (m_vhdlCode != "") {
1742  cout << "[Error] TRGCDCJSignal::initVhdlCode() => m_vhdlCode is not \"\"." << endl;
1743  } else {
1744  m_vhdlCode = " ";
1745  }
1746  }
1747 
1748  void TRGCDCJSignal::toSignedVhdlCode()
1749  {
1750  if (m_type == -1) return;
1751  // Find if bitwidth is optimized for signed or unsigned. t_bitwidth is optimized for signed.
1752  int t_bitwidth = calBitwidth();
1753  if (calType() == 1) t_bitwidth++;
1754 
1755  if (t_bitwidth <= m_bitsize) {
1756  m_vhdlCode = "signed(" + m_vhdlCode + ")";
1757  } else if (t_bitwidth - 1 == m_bitsize) {
1758  m_vhdlCode = "signed('0'&(" + m_vhdlCode + "))";
1759  m_bitsize += 1;
1760  } else {
1761  cout << "[Error] TRGCDCJSignal::toSignedVhdlCode() => m_bitsize is too small." << endl;
1762  }
1763  m_type = -1;
1764  }
1765 
1766  void TRGCDCJSignal::toUnsignedVhdlCode()
1767  {
1768  if (m_type == 1) return;
1769 
1770  if (calType() == -1) {
1771  cout << "[Warning] TRGCDCJSignal::toUnsignedVhdlCode() => signal can be minus." << endl;
1772  } else {
1773  m_vhdlCode = "unsigned(" + m_vhdlCode + ")";
1774  m_type = 1;
1775  }
1776 
1777  }
1778 
1779  void TRGCDCJSignal::vhdlCode(TRGCDCJSignal const& first, const std::string& operation, TRGCDCJSignal const& second,
1780  TRGCDCJSignal const& result, string& resultVhdlCode)
1781  {
1782  // Copy first and second for VHDL version.
1783  TRGCDCJSignal t_first(first);
1784  TRGCDCJSignal t_second(second);
1785  // Set m_vhdlCode if needed. (Will require clock implementation later)
1786  if (t_first.m_vhdlCode == "") {
1787  t_first.initVhdlCode();
1788  }
1789  if (t_second.m_vhdlCode == "") {
1790  t_second.initVhdlCode();
1791  }
1792 
1793  // Match types.
1794  // Changed to signed.
1795  if (t_first.m_type * t_second.m_type < 0 || (t_first.m_type != -1 && result.m_type == -1)) {
1796  if (t_first.m_type != -1) {
1797  t_first.toSignedVhdlCode();
1798  }
1799  if (t_second.m_type != -1) {
1800  t_second.toSignedVhdlCode();
1801  }
1802  }
1803  // Change to unsigned.
1804  if (t_first.m_type == 2) t_first.toUnsignedVhdlCode();
1805  if (t_second.m_type == 2) t_second.toUnsignedVhdlCode();
1806 
1807  // Calculate result type and bitwidth.
1808  int logicType, logicBitwidth, vhdlType, vhdlBitwidth;
1809  logicType = result.m_type;
1810  logicBitwidth = result.m_bitsize;
1811  calVhdlTypeBitwidth(t_first, operation, t_second, vhdlType, vhdlBitwidth);
1812 
1813  // Make code.
1814  string resultCode;
1815  // For compare operations.
1816  if (operation == "=" || operation == "/=" || operation == "<" || operation == "<=" ||
1817  operation == ">" || operation == ">=" || operation == "and" || operation == "or") {
1818  resultCode = "(" + t_first.m_vhdlCode + operation + t_second.m_vhdlCode + ")";
1819  } else {
1820  // For arithmetic operations.
1821  // If special case.
1822  if (logicType > 0 && vhdlType == -1) {
1823  if (logicBitwidth + 1 > vhdlBitwidth) t_first.m_vhdlCode = "resize(" + t_first.m_vhdlCode + "," + to_string(
1824  logicBitwidth + 1) + ")";
1825  resultCode = t_first.m_vhdlCode + operation + t_second.m_vhdlCode;
1826  resultCode = "resize(unsigned(" + resultCode + ")," + to_string(logicBitwidth) + ")";
1827  } else {
1828  // Normal case.
1829  if (logicBitwidth > vhdlBitwidth) {
1830  t_first.m_vhdlCode = "resize(" + t_first.m_vhdlCode + "," + to_string(logicBitwidth) + ")";
1831  }
1832  resultCode = t_first.m_vhdlCode + operation + t_second.m_vhdlCode;
1833  // Resize output to minimum bitwidth.
1834  if (logicBitwidth < vhdlBitwidth) {
1835  resultCode = "resize(" + resultCode + "," + to_string(logicBitwidth) + ")";
1836  }
1837  }
1838  }
1839  resultVhdlCode = resultCode;
1840  }
1841 
1842  void TRGCDCJSignal::vhdlCode(const std::string& operation, TRGCDCJSignal const& first, TRGCDCJSignal const& result,
1843  string& resultVhdlCode)
1844  {
1845  // Copy first for VHDL version.
1846  TRGCDCJSignal t_first(first);
1847  // Set m_vhdlCode if needed. (Will require clock implementation later)
1848  if (t_first.m_vhdlCode == "") {
1849  t_first.initVhdlCode();
1850  }
1851  // Match types
1852  // Change VHDL unsigned to VHDL signed if required.
1853  if (t_first.m_type != -1 && result.m_type == -1) {
1854  t_first.toSignedVhdlCode();
1855  }
1856  // Change to unsigned if slv.
1857  if (t_first.m_type == 2) t_first.toUnsignedVhdlCode();
1858 
1859  // Calculate result type and bitwidth.
1860  int logicType, logicBitwidth, vhdlType, vhdlBitwidth;
1861  logicType = result.m_type;
1862  logicBitwidth = result.m_bitsize;
1863  // Will always be same as first type and bitsize.
1864  vhdlType = t_first.m_type;
1865  vhdlBitwidth = t_first.m_bitsize;
1866 
1867  // Make code.
1868  string resultCode;
1869  // If logic(out) is unsigned and vhdl(in) is signed.
1870  if (logicType == 1 && vhdlType == -1) {
1871  if (logicBitwidth + 1 > vhdlBitwidth) t_first.m_vhdlCode = "resize(" + t_first.m_vhdlCode + "," + to_string(
1872  logicBitwidth + 1) + ")";
1873  if (operation == "shift_left"
1874  || operation == "shift_right") resultCode = operation + "(" + t_first.m_vhdlCode + "," + to_string(abs(
1875  first.m_bitsize - result.m_bitsize)) + ")";
1876  else if (operation == "unsigned" || operation == "none") resultCode = t_first.m_vhdlCode;
1877  else resultCode = operation + "(" + t_first.m_vhdlCode + ")";
1878  resultCode = "resize(unsigned(" + resultCode + ")," + to_string(logicBitwidth) + ")";
1879  } else {
1880  // Normal case.
1881  if (logicBitwidth > vhdlBitwidth) {
1882  t_first.m_vhdlCode = "resize(" + t_first.m_vhdlCode + "," + to_string(logicBitwidth) + ")";
1883  }
1884  if (operation == "shift_left"
1885  || operation == "shift_right") resultCode = operation + "(" + t_first.m_vhdlCode + "," + to_string(abs(
1886  first.m_bitsize - result.m_bitsize)) + ")";
1887  else if (operation == "resize" || operation == "signed" || operation == "none") resultCode = t_first.m_vhdlCode;
1888  else resultCode = operation + "(" + t_first.m_vhdlCode + ")";
1889  // Resize output to minimum bitwidth.
1890  if (logicBitwidth < vhdlBitwidth) {
1891  resultCode = "resize(" + resultCode + "," + to_string(logicBitwidth) + ")";
1892  }
1893  }
1894  resultVhdlCode = resultCode;
1895  }
1896 
1897  std::string TRGCDCJSignal::replaceWithSignalNames(std::string const& fromVhdlCode,
1898  std::vector<pair<std::string, vector<int> > > const& fromArgumentSignals, int const& finishClock,
1899  std::map<std::string, vector<int> >& buffers)
1900  {
1901  // Replace names with token(" ") in from.m_vhdlCode
1902  string t_vhdlCode = "";
1903  size_t start = 0;
1904  size_t end = fromVhdlCode.find(" ");
1905  int nIndex = (int)fromArgumentSignals.size();
1906  int index = 0;
1907  while (end != string::npos) {
1908  // Check if there are enough signal names.
1909  if (nIndex - 1 < index) {
1910  cout << "[Error] TRGCDCJSignal::replaceWithSignalNames() => Not enough signal names in m_argumentSignals." << endl;
1911  return "";
1912  }
1913  // Replace token(" ") with name.
1914  //cout<<"Name: "<<fromArgumentSignals[index].first<<" Clock: "<<fromArgumentSignals[index].second[2]<<endl;
1915  int t_buffer = (finishClock - 1) - fromArgumentSignals[index].second[2] - 1;
1916  // No buffer needed or instant assignment or constant.
1917  if (t_buffer == -1 || t_buffer == -2
1918  || fromArgumentSignals[index].second[2] == -1) t_vhdlCode += fromVhdlCode.substr(start,
1919  end - start) + fromArgumentSignals[index].first;
1920  else if (t_buffer > -1) {
1921  t_vhdlCode += fromVhdlCode.substr(start, end - start) + fromArgumentSignals[index].first + "_b(" + to_string(t_buffer) + ")";
1922  // Fill map for buffers.
1923  if (buffers.find(fromArgumentSignals[index].first) == buffers.end()) {
1924  buffers[fromArgumentSignals[index].first] = {fromArgumentSignals[index].second[0], fromArgumentSignals[index].second[1], t_buffer};
1925  } else {
1926  if (buffers[fromArgumentSignals[index].first][2] < t_buffer) buffers[fromArgumentSignals[index].first][2] = t_buffer;
1927  }
1928  } else {
1929  cout << "[Error] TRGCDCJSignal::replaceWithSignalNames() => finishClock is too small." << endl;
1930  t_vhdlCode += fromVhdlCode.substr(start, end - start) + fromArgumentSignals[index].first;
1931  }
1932 
1933  index++;
1934  start = end + 1;
1935  end = fromVhdlCode.find(" ", start);
1936  }
1937  t_vhdlCode += fromVhdlCode.substr(start, end - start);
1938  // Check if number of spaces and signal names are same.
1939  if (nIndex != index) {
1940  cout << "[Error] TRGCDCJSignal::replaceWithSignalNames() => Number of signal names and number of " " do not match." << endl;
1941  return "";
1942  }
1943  return t_vhdlCode;
1944  }
1945 
1946  std::string TRGCDCJSignal::assignVhdlCode(TRGCDCJSignal const& target, TRGCDCJSignal const& from)
1947  {
1948 
1949  // Check if target has m_commonData.
1950  if (target.m_commonData == 0) {
1951  cout << "[Error] TRGCDCJSignal::assignVhdlCode() => target.m_commonData is not set." << endl;
1952  return "";
1953  }
1954 
1955  TRGCDCJSignal t_from(from);
1956 
1957  // Set m_vhdlCode if needed.
1958  if (t_from.m_vhdlCode == "") {
1959  t_from.initVhdlCode();
1960  }
1961 
1962  // Fill signal map for definition.
1963  {
1964  if (target.m_name == "") cout << "[Error] TRGCDCJSignal::assignVhdlCode() => target.m_name is \"\" " << endl;
1965  map<string, vector<int> >& t_signals = target.m_commonData->m_signals;
1966  if (t_signals.find(target.m_name) == t_signals.end()) {
1967  //t_signals[target.m_name] = {target.m_type, target.m_bitsize};
1968  // From and target should be same.
1969  // cppcheck-suppress stlFindInsert
1970  t_signals[target.m_name] = {from.m_type, from.m_bitsize};
1971  }
1972  }
1973 
1974  // Replace names with spaces in from.m_vhdlCode
1975  string t_vhdlCode = replaceWithSignalNames(t_from.m_vhdlCode, t_from.m_argumentSignals, t_from.m_finishClock,
1976  t_from.m_commonData->m_buffers);
1977 
1978  return target.m_name + "<=" + t_vhdlCode + ";";
1980  //if(t_vhdlCode != "") {
1981  // return target.m_name + "<=" + t_vhdlCode + ";";
1983  //} else if (from.m_minInt == from.m_maxInt) {
1984  // if(from.m_type == 1) {
1985  // return target.m_name + "<=to_unsigned(" + to_string(from.m_int) + "," + to_string(from.m_bitsize) + ")";
1986  // } else {
1987  // return target.m_name + "<=to_signed(" + to_string(from.m_int) + "," + to_string(from.m_bitsize) + ")";
1988  // }
1990  //} else if (from.m_name=="") {
1991  // if(from.m_type == 1) {
1992  // return target.m_name + "<=to_unsigned(" + to_string(from.m_int) + "," + to_string(from.m_bitsize) + ")";
1993  // } else {
1994  // return target.m_name + "<=to_signed(" + to_string(from.m_int) + "," + to_string(from.m_bitsize) + ")";
1995  // }
1996  //} else {
1998  // return target.m_name + "<=" + from.m_name + ";";
1999  //}
2000  }
2001 
2002  std::string TRGCDCJSignal::chooseVhdlCode(TRGCDCJSignal const& target, TRGCDCJSignal const& reference,
2003  std::vector<std::vector<TRGCDCJSignal> > const& data)
2004  {
2005  // Check if target has m_name.
2006  if (target.m_name == "") {
2007  cout << "[Error] TRGCDCJSignal::chooseVhdlCode() => target has no name." << endl;
2008  return "";
2009  }
2010  // Check if reference has m_name or vhdlCode.
2011  if (reference.m_name == "" && reference.m_vhdlCode == "") {
2012  cout << "[Error] TRGCDCJSignal::cooseVhdlCode() => reference has no name or vhdlCode." << endl;
2013  return "";
2014  }
2015 
2016  TRGCDCJSignal t_reference(reference);
2017 
2018  // Set m_vhdlCode if needed.
2019  if (t_reference.m_vhdlCode == "") t_reference.initVhdlCode();
2020  // Replace names with spaces in reference.m_vhdlCode
2021  string t_referenceVhdlCode = replaceWithSignalNames(t_reference.m_vhdlCode, t_reference.m_argumentSignals, target.m_finishClock,
2022  t_reference.m_commonData->m_buffers);
2023 
2024  // Storage for used values.
2025  // map<signed long long, bool> t_used;
2026  // Create string for choice().
2027  stringstream t_vhdlCode;
2028  //t_vhdlCode<<"case to_integer("<<t_referenceVhdlCode<<") is"<<endl;
2029  //for(unsigned iCondition=0; iCondition<data.size()-1; iCondition++){
2030  // TRGCDCJSignal const & from = data[iCondition][1];
2031  // TRGCDCJSignal const & to = data[iCondition][2];
2032  // TRGCDCJSignal const & assign = data[iCondition][0];
2033  // signed long long fromInt = from.m_int;
2034  // signed long long toInt = to.m_int;
2035  // // Don't allow same int numbers for from and to.
2036  // if(t_used.count(fromInt)!=0) fromInt += 1;
2037  // else t_used[fromInt] = 1;
2038  // if(t_used.count(toInt)!=0) {
2039  // // Allow same from and to when in one line.
2040  // if(fromInt!=toInt) toInt -= 1;
2041  // } else t_used[toInt] = 1;
2042  // t_vhdlCode<<" when "<<fromInt<<" to "<<toInt<<"=>"<<assignVhdlCode(target,assign)<<endl;;
2043  //}
2044  //t_vhdlCode<<" when others=>"<<assignVhdlCode(target,(*(data.end()-1))[0])<<endl;
2045  //t_vhdlCode<<"end case;";
2046 
2047  // For if
2048  TRGCDCJSignal from = data[0][1];
2049  TRGCDCJSignal to = data[0][2];
2050  TRGCDCJSignal assign = data[0][0];
2051  if (from.m_vhdlCode == "") from.initVhdlCode();
2052  if (to.m_vhdlCode == "") to.initVhdlCode();
2053  string t_fromVhdlCode = replaceWithSignalNames(from.m_vhdlCode, from.m_argumentSignals, target.m_finishClock,
2054  target.m_commonData->m_buffers);
2055  string t_toVhdlCode = replaceWithSignalNames(to.m_vhdlCode, to.m_argumentSignals, target.m_finishClock,
2056  target.m_commonData->m_buffers);
2057  string t_fromPrefixSigned;
2058  string t_fromPostfixSigned;
2059  string t_toPrefixSigned;
2060  string t_toPostfixSigned;
2061  if (reference.m_type == -1 && from.m_type == 1) {
2062  t_fromPrefixSigned = "signed('0'&";
2063  t_fromPostfixSigned = ")";
2064  } else {
2065  t_fromPrefixSigned = "";
2066  t_fromPostfixSigned = "";
2067  }
2068  if (reference.m_type == -1 && to.m_type == 1) {
2069  t_toPrefixSigned = "signed('0'&";
2070  t_toPostfixSigned = ")";
2071  } else {
2072  t_toPrefixSigned = "";
2073  t_toPostfixSigned = "";
2074  }
2075  t_vhdlCode << "if (" << t_referenceVhdlCode << " >= " << t_fromPrefixSigned << t_fromVhdlCode << t_fromPostfixSigned << ") and (" <<
2076  t_referenceVhdlCode << " <= " << t_toPrefixSigned << t_toVhdlCode << t_toPostfixSigned << ") then" << endl;
2077  t_vhdlCode << " " << assignVhdlCode(target, assign) << endl;
2078 
2079  // For if else
2080  for (unsigned iCondition = 1; iCondition < data.size() - 1; iCondition++) {
2081  TRGCDCJSignal from1 = data[iCondition][1];
2082  TRGCDCJSignal to1 = data[iCondition][2];
2083  TRGCDCJSignal assign1 = data[iCondition][0];
2084  if (from1.m_vhdlCode == "") from1.initVhdlCode();
2085  if (to1.m_vhdlCode == "") to1.initVhdlCode();
2086  if (reference.m_type == -1 && from1.m_type == 1) {
2087  t_fromPrefixSigned = "signed('0'&";
2088  t_fromPostfixSigned = ")";
2089  } else {
2090  t_fromPrefixSigned = "";
2091  t_fromPostfixSigned = "";
2092  }
2093  if (reference.m_type == -1 && to1.m_type == 1) {
2094  t_toPrefixSigned = "signed('0'&";
2095  t_toPostfixSigned = ")";
2096  } else {
2097  t_toPrefixSigned = "";
2098  t_toPostfixSigned = "";
2099  }
2100  t_fromVhdlCode = replaceWithSignalNames(from1.m_vhdlCode, from1.m_argumentSignals, target.m_finishClock,
2101  target.m_commonData->m_buffers);
2102  t_toVhdlCode = replaceWithSignalNames(to1.m_vhdlCode, to1.m_argumentSignals, target.m_finishClock, target.m_commonData->m_buffers);
2103  t_vhdlCode << "elsif (" << t_referenceVhdlCode << " >= " << t_fromPrefixSigned << t_fromVhdlCode << t_fromPostfixSigned << ") and ("
2104  << t_referenceVhdlCode << " <= " << t_toPrefixSigned << t_toVhdlCode << t_toPostfixSigned << ") then" << endl;
2105  t_vhdlCode << " " << assignVhdlCode(target, assign1) << endl;
2106  }
2107  t_vhdlCode << "else" << endl;
2108  t_vhdlCode << " " << assignVhdlCode(target, (*(data.end() - 1))[0]) << endl;
2109  t_vhdlCode << "end if;";
2110  return t_vhdlCode.str();
2111  }
2112 
2113  std::string TRGCDCJSignal::ifElseVhdlCode(
2114  std::vector<std::pair<TRGCDCJSignal, std::vector<std::pair<TRGCDCJSignal*, TRGCDCJSignal> > > > const& data)
2115  {
2116  // Check if comp and lhs have name
2117  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
2118  TRGCDCJSignal const& comp = data[iCase].first;
2119  if (iCase != data.size() - 1) {
2120  if (comp.m_name == "") {
2121  cout << "[Error] TRGCDCJSignal::ifElseVhdlCode() => comp has no name." << endl;
2122  return "";
2123  }
2124  }
2125  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
2126  TRGCDCJSignal const& lhs = *(data[iCase].second[iAssignment].first);
2127  if (lhs.m_name == "") {
2128  cout << "[Error] TRGCDCJSignal::ifElseVhdlCode() => lhs has no name." << endl;
2129  return "";
2130  }
2131  }
2132  }
2133 
2134  // Write vhdl
2135  // Else will be last in data.
2136  stringstream t_vhdlCode;
2137  for (unsigned iCase = 0; iCase < data.size(); iCase++) {
2138  TRGCDCJSignal const& comp = data[iCase].first;
2139  string t_compVhdlCode = replaceWithSignalNames(comp.m_vhdlCode, comp.m_argumentSignals, comp.m_finishClock,
2140  comp.m_commonData->m_buffers);
2141  // Choose which if to use.
2142  if (iCase == 0) t_vhdlCode << "if " << t_compVhdlCode << " then" << endl;
2143  else if (comp.m_bitsize == -1) t_vhdlCode << "else" << endl;
2144  else t_vhdlCode << "elsif " << t_compVhdlCode << " then" << endl;
2145  for (unsigned iAssignment = 0; iAssignment < data[iCase].second.size(); iAssignment++) {
2146  TRGCDCJSignal const& lhs = *(data[iCase].second[iAssignment].first);
2147  TRGCDCJSignal const& rhs = data[iCase].second[iAssignment].second;
2148  t_vhdlCode << " " << assignVhdlCode(lhs, rhs) << endl;
2149  }
2150  }
2151  t_vhdlCode << "end if;";
2152 
2153  return t_vhdlCode.str();
2154 
2155  }
2156 
2157  void TRGCDCJSignal::printVhdl(const std::string& vhdlCode) const
2158  {
2159  if (m_commonData) {
2160  ofstream outFile;
2161  outFile.open(m_commonData->m_vhdlOutputFile, ios::app);
2162  if (outFile.is_open()) {
2163  outFile << vhdlCode << endl;
2164  outFile.close();
2165  }
2166  } else {
2167  cout << "[Error] TRGCDCJSignal::printVhdl() => m_commonData doesn't exist." << endl;
2168  }
2169  }
2170 
2171  void TRGCDCJSignal::checkInt(const std::string& name) const
2172  {
2173  if (m_int > calMaxInteger()) {
2174  cout << "[Error] " << name << " => m_int overflow" << endl;
2175  cout << " Start dumping" << endl;
2176  dump();
2177  cout << " End dumping" << endl;
2178  }
2179  if (m_int < calMinInteger()) {
2180  cout << "[Error] " << name << " => m_int underflow" << endl;
2181  cout << " Start dumping" << endl;
2182  dump();
2183  cout << " End dumping" << endl;
2184  }
2185  if (m_maxInt > calMaxInteger()) {
2186  cout << "[Error] " << name << " => m_maxInt overflow" << endl;
2187  cout << " Start dumping" << endl;
2188  dump();
2189  cout << " End dumping" << endl;
2190  }
2191  if (m_minInt < calMinInteger()) {
2192  cout << "[Error] " << name << " => m_minInt underflow" << endl;
2193  cout << " Start dumping" << endl;
2194  dump();
2195  cout << " End dumping" << endl;
2196  }
2197  }
2198 
2199  bool TRGCDCJSignal::isSameSignal(TRGCDCJSignal const& lhs, TRGCDCJSignal const& rhs)
2200  {
2201  return lhs.m_int == rhs.m_int && lhs.m_minInt == rhs.m_minInt && lhs.m_maxInt == rhs.m_maxInt
2202  && lhs.m_toReal == rhs.m_toReal && lhs.m_actual == rhs.m_actual && lhs.m_minActual == rhs.m_minActual
2203  && lhs.m_maxActual == rhs.m_maxActual;
2204  }
2205 
2206  void TRGCDCJSignal::valuesToMapSignals(std::vector<std::tuple<string, double, int, double, double, int> > const& inValues,
2207  // cppcheck-suppress constParameter
2208  Belle2::TRGCDCJSignalData* inCommonData, std::map<std::string, Belle2::TRGCDCJSignal>& outMap)
2209  {
2210  for (unsigned iSignals = 0; iSignals < inValues.size(); iSignals++) {
2211  string const& t_name = get<0>(inValues[iSignals]);
2212  double const& t_value = get<1>(inValues[iSignals]);
2213  int const& t_bitWidth = get<2>(inValues[iSignals]);
2214  double const& t_min = get<3>(inValues[iSignals]);
2215  double const& t_max = get<4>(inValues[iSignals]);
2216  int const& t_clock = get<5>(inValues[iSignals]);
2217  // Put input to signal.
2218  // Input to finish clock is 0.
2219  // Signals that will be used will have finish clock 1 due to below line.
2220  outMap[t_name] <= Belle2::TRGCDCJSignal(t_bitWidth, t_value, t_min, t_max, t_clock, inCommonData);
2221  }
2222  }
2223 
2224  void TRGCDCJSignal::mapSignalsToValues(std::map<std::string, Belle2::TRGCDCJSignal> const& inMap,
2225  std::vector<std::pair<std::string, int> > const& inChoose,
2226  std::vector<std::tuple<string, double, int, double, double, int> >& outValues)
2227  {
2228  for (unsigned iSignals = 0; iSignals < inChoose.size(); iSignals++) {
2229  int const& b_integerEffect = inChoose[iSignals].second;
2230  string const& t_name = inChoose[iSignals].first;
2231  Belle2::TRGCDCJSignal const& t_signal = inMap.find(t_name)->second;
2232  double t_value = 0, t_min = 0, t_max = 0;
2233  int t_bitwidth = t_signal.getBitsize();
2234  if (b_integerEffect == 1) {
2235  t_value = t_signal.getRealInt();
2236  t_min = t_signal.getRealMinInt();
2237  t_max = t_signal.getRealMaxInt();
2238  } else {
2239  t_value = t_signal.getActual();
2240  t_min = t_signal.getMinActual();
2241  t_max = t_signal.getMaxActual();
2242  }
2243  int t_clock = t_signal.getFinishClock();
2244  tuple<string, double, int, double, double, int> outValue(t_name, t_value, t_bitwidth, t_min, t_max, t_clock);
2245  outValues.push_back(outValue);
2246  }
2247  }
2248 
2250 }
Belle2::TRGCDCJSignalData
A class to hold common data for JSignals.
Definition: JSignalData.h:33
Belle2::TRGCDCJSignalData::m_printVhdl
bool m_printVhdl
Status if code should be printed.
Definition: JSignalData.h:89
Belle2::TRGCDCJSignalData::m_vhdlInProcess
std::string m_vhdlInProcess
Holds VHDL process code.
Definition: JSignalData.h:85
Belle2::TRGCDCJSignalData::m_vhdlOutputFile
std::string m_vhdlOutputFile
Memebers.
Definition: JSignalData.h:79
Belle2::TRGCDCJSignalData::m_buffers
std::map< std::string, std::vector< int > > m_buffers
vector<int> is {type, bitwidth, buffer} Holds all the requried VHDL buffers.
Definition: JSignalData.h:94
Belle2::TRGCDCJSignal
A class to use Signals for TRGCDC 3D tracker.
Definition: JSignal.h:35
Belle2::TRGCDCJSignal::m_argumentSignals
std::vector< std::pair< std::string, std::vector< int > > > m_argumentSignals
vector<int> is {type, bitwidth, clock} Holds the arguments that made the signal.
Definition: JSignal.h:303
Belle2::TRGCDCJSignal::m_finishClock
int m_finishClock
Holds the clock tick when the signal is valid.
Definition: JSignal.h:305
Belle2::TRGCDCJSignal::m_toReal
double m_toReal
The toReal value.
Definition: JSignal.h:296
Belle2::TRGCDCJSignal::m_minActual
double m_minActual
The minimum float value.
Definition: JSignal.h:292
Belle2::TRGCDCJSignal::m_debug
bool m_debug
The debug flag.
Definition: JSignal.h:298
Belle2::TRGCDCJSignal::m_minInt
signed long long m_minInt
The minimum integer value.
Definition: JSignal.h:286
Belle2::TRGCDCJSignal::m_maxActual
double m_maxActual
The maximum float value.
Definition: JSignal.h:294
Belle2::TRGCDCJSignal::m_bitsize
int m_bitsize
+1: unsigned.
Definition: JSignal.h:280
Belle2::TRGCDCJSignal::m_type
int m_type
Type of signal.
Definition: JSignal.h:278
Belle2::TRGCDCJSignal::m_int
signed long long m_int
integer value of signal.
Definition: JSignal.h:282
Belle2::TRGCDCJSignal::m_commonData
TRGCDCJSignalData * m_commonData
The common JSignalData.
Definition: JSignal.h:308
Belle2::TRGCDCJSignal::m_maxInt
signed long long m_maxInt
The maximum integer value.
Definition: JSignal.h:288
Belle2::TRGCDCJSignal::m_name
std::string m_name
Memebers.
Definition: JSignal.h:276
Belle2::TRGCDCJSignal::m_vhdlCode
std::string m_vhdlCode
Holds the vhdl code.
Definition: JSignal.h:300
Belle2::TRGCDCJSignal::m_actual
double m_actual
The float value.
Definition: JSignal.h:290
Belle2::TRGCDCJSignal::m_slv
std::vector< bool > m_slv
storage for std_logic_vector. (Will be deprecated.)
Definition: JSignal.h:284
FpgaUtility::roundInt
static double roundInt(double value)
Round double value.
Definition: FpgaUtility.cc:38
Belle2::TRGCDCJSignal::calMaxInteger
signed long long calMaxInteger() const
Calculate max value for a binary number.
Definition: JSignal.cc:1535
Belle2::TRGCDCJSignal::calType
int calType() const
Calculated what type the signal is.
Definition: JSignal.cc:1447
Belle2::TRGCDCJSignal::getActual
double getActual() const
Get float value of signal.
Definition: JSignal.cc:1392
Belle2::TRGCDCJSignal::invOffset
TRGCDCJSignal const invOffset(TRGCDCJSignal const &valueMin) const
Outputs a signal that is not offset.
Definition: JSignal.cc:606
Belle2::TRGCDCJSignal::printVhdl
void printVhdl(const std::string &vhdlCode) const
Prints vhdl code.
Definition: JSignal.cc:2157
Belle2::TRGCDCJSignal::getName
std::string getName() const
Get name of signal.
Definition: JSignal.cc:1362
Belle2::TRGCDCJSignal::getVhdlOutputFile
std::string getVhdlOutputFile() const
Gets the vhdl output file name.
Definition: JSignal.cc:1506
Belle2::TRGCDCJSignal::setCommonData
void setCommonData(TRGCDCJSignalData *)
Sets JSignalData to signal.
Definition: JSignal.cc:1357
Belle2::TRGCDCJSignal::setBitsize
void setBitsize(int bitsize)
Sets bitwidth of signal.
Definition: JSignal.cc:1323
Belle2::TRGCDCJSignal::operator-
TRGCDCJSignal const operator-() const
Unary operator.
Definition: JSignal.cc:279
Belle2::TRGCDCJSignal::vhdlCode
static void vhdlCode(TRGCDCJSignal const &first, const std::string &operation, TRGCDCJSignal const &second, TRGCDCJSignal const &result, std::string &targtVhdlCode)
Writes vhdl code using two signals.
Definition: JSignal.cc:1779
Belle2::TRGCDCJSignal::valuesToMapSignals
static void valuesToMapSignals(std::vector< std::tuple< std::string, double, int, double, double, int > > const &inValues, Belle2::TRGCDCJSignalData *inCommonData, std::map< std::string, Belle2::TRGCDCJSignal > &outMap)
Values => [name, value, bitwidth, min, max, clock] Changes values to signals.
Definition: JSignal.cc:2206
Belle2::TRGCDCJSignal::operator+
TRGCDCJSignal const operator+(TRGCDCJSignal const &rhs) const
Arithmetic add operator.
Definition: JSignal.cc:310
Belle2::TRGCDCJSignal::assignTo
TRGCDCJSignal & assignTo(TRGCDCJSignal const &rhs, int targetClock, std::string &finalCode)
Assign operator with setting target clock with outputing final code.
Definition: JSignal.cc:172
Belle2::TRGCDCJSignal::offset
TRGCDCJSignal const offset(TRGCDCJSignal const &valueMin) const
Outputs an offset signal which is an unsigned signal.
Definition: JSignal.cc:592
Belle2::TRGCDCJSignal::orderLargestBitsize
bool orderLargestBitsize(TRGCDCJSignal &large, TRGCDCJSignal &small) const
Orders the TRGCDCJSignals by bitsize. Next priority is unsigned, signed, minus unsigned....
Definition: JSignal.cc:1515
Belle2::TRGCDCJSignal::isSameSignal
static bool isSameSignal(TRGCDCJSignal const &lhs, TRGCDCJSignal const &rhs)
Checks if signal is same signal.
Definition: JSignal.cc:2199
Belle2::TRGCDCJSignal::setActual
void setActual(double value)
Sets float value of signal.
Definition: JSignal.cc:1308
Belle2::TRGCDCJSignal::replaceWithSignalNames
static std::string replaceWithSignalNames(std::string const &fromVhdlCode, std::vector< std::pair< std::string, std::vector< int > > > const &fromVhdlSignals, int const &finishClock, std::map< std::string, std::vector< int > > &buffers)
Writes final vhdl code.
Definition: JSignal.cc:1897
Belle2::TRGCDCJSignal::shift
TRGCDCJSignal const shift(int nBits, int operate=1) const
Shift signal. Shift direction is right. operate=0 to change m_toReal(unit).
Definition: JSignal.cc:561
Belle2::TRGCDCJSignal::getCommonData
TRGCDCJSignalData * getCommonData() const
Get the sharged JSignalData.
Definition: JSignal.cc:1437
Belle2::TRGCDCJSignal::getMaxActual
double getMaxActual() const
Get maximum float value of signal.
Definition: JSignal.cc:1402
Belle2::TRGCDCJSignal::choose
static void choose(TRGCDCJSignal &target, TRGCDCJSignal const &targetMin, TRGCDCJSignal const &targetMax, TRGCDCJSignal const &reference, std::vector< std::vector< TRGCDCJSignal > > data, int targetClock)
Case method.
Definition: JSignal.cc:621
Belle2::TRGCDCJSignal::toSlv
static TRGCDCJSignal const toSlv(TRGCDCJSignal const &in, int test)
Change signal to std_logic_vector using vector<bool>. (Will be deprecated.)
Definition: JSignal.cc:1121
Belle2::TRGCDCJSignal::initArgumentSignals
void initArgumentSignals()
Initializes the argument signals for the signal.
Definition: JSignal.cc:1705
Belle2::TRGCDCJSignal::setVhdlOutputFile
void setVhdlOutputFile(const std::string &filename)
Sets ouptut VHDL filename.
Definition: JSignal.cc:1349
Belle2::TRGCDCJSignal::getVhdlCode
std::string getVhdlCode() const
Gets the vhdl code for the signal.
Definition: JSignal.cc:1492
Belle2::TRGCDCJSignal::setInt
void setInt(signed long long value)
Sets integer value of signal.
Definition: JSignal.cc:1303
Belle2::TRGCDCJSignal::calBitwidth
int calBitwidth() const
Calculates the bit width.
Definition: JSignal.cc:1461
Belle2::TRGCDCJSignal::getPrintVhdl
bool getPrintVhdl() const
Gets the print vhdl flag from common JSignalData class.
Definition: JSignal.cc:1497
Belle2::TRGCDCJSignal::ifElse
static void ifElse(std::vector< std::pair< TRGCDCJSignal, std::vector< std::pair< TRGCDCJSignal *, TRGCDCJSignal > > > > &data, int targetClock)
If else implementation with target clock.
Definition: JSignal.cc:800
Belle2::TRGCDCJSignal::getArgumentSignals
std::vector< std::pair< std::string, std::vector< int > > > const getArgumentSignals() const
Gets the signal names and values that made this signal.
Definition: JSignal.cc:1432
Belle2::TRGCDCJSignal::assignVhdlCode
static std::string assignVhdlCode(TRGCDCJSignal const &target, TRGCDCJSignal const &from)
Writes the assign vhdl code.
Definition: JSignal.cc:1946
Belle2::TRGCDCJSignal::resize
TRGCDCJSignal const resize(int bitwidth) const
Resizes signal.
Definition: JSignal.cc:989
Belle2::TRGCDCJSignal::getRealMinInt
double getRealMinInt() const
Get converted float value of minimum integer.
Definition: JSignal.cc:1412
Belle2::TRGCDCJSignal::combineArguments
static void combineArguments(TRGCDCJSignal const &first, TRGCDCJSignal const &second, TRGCDCJSignal &result)
Combines arguments of signals.
Definition: JSignal.cc:1732
Belle2::TRGCDCJSignal::chooseVhdlCode
static std::string chooseVhdlCode(TRGCDCJSignal const &target, TRGCDCJSignal const &reference, std::vector< std::vector< TRGCDCJSignal > > const &data)
Writes the choose vhdl code.
Definition: JSignal.cc:2002
Belle2::TRGCDCJSignal::absolute
static TRGCDCJSignal const absolute(TRGCDCJSignal const &first)
Absolute TRGCDCJSignal. Removes 1 bit if signed or minus unsigned.
Definition: JSignal.cc:1562
Belle2::TRGCDCJSignal::getFinishClock
int getFinishClock() const
Gets clock tick where signal is make.
Definition: JSignal.cc:1427
Belle2::TRGCDCJSignal::calInt
static signed long long calInt(double value, TRGCDCJSignal const &mother)
Calculates integer value with unit of a TRGCDCJSignal.
Definition: JSignal.cc:1662
Belle2::TRGCDCJSignal::setFinishClock
void setFinishClock(int finishClock)
Sets finish clock of signal.
Definition: JSignal.cc:1331
Belle2::TRGCDCJSignal::getInt
signed long long getInt() const
Get integer value of signal.
Definition: JSignal.cc:1377
Belle2::TRGCDCJSignal::getToReal
double getToReal() const
Get toReal value of signal.
Definition: JSignal.cc:1422
Belle2::TRGCDCJSignal::matchUnit
void matchUnit(TRGCDCJSignal &first, TRGCDCJSignal &second) const
Utilities.
Definition: JSignal.cc:1260
Belle2::TRGCDCJSignal::setDebug
void setDebug(bool debug)
Sets debug flag for signal.
Definition: JSignal.cc:1336
Belle2::TRGCDCJSignal::limit
TRGCDCJSignal const limit(signed long long minInt, signed long long maxInt, double minActual, double maxActual) const
Limits min and max values using specific integers. Use only for ifElse. Doesn't check overflow,...
Definition: JSignal.cc:957
Belle2::TRGCDCJSignal::calVhdlTypeBitwidth
static void calVhdlTypeBitwidth(TRGCDCJSignal const &first, const std::string &operation, TRGCDCJSignal const &second, int &type, int &bitwidth)
Calculates vhdl bitwidth and type for operation.
Definition: JSignal.cc:1667
Belle2::TRGCDCJSignal::setName
void setName(const std::string &name)
Setters, Getters Sets name of signal.
Definition: JSignal.cc:1298
Belle2::TRGCDCJSignal::getRealMaxInt
double getRealMaxInt() const
Get converted float value of maximum integer.
Definition: JSignal.cc:1417
Belle2::TRGCDCJSignal::checkInt
void checkInt(const std::string &name) const
Checks underflow or overflow for TRGCDCJSignal.
Definition: JSignal.cc:2171
Belle2::TRGCDCJSignal::swap
void swap(TRGCDCJSignal &first, TRGCDCJSignal &second) const
Swaps the TRGCDCJSignals.
Definition: JSignal.cc:1241
Belle2::TRGCDCJSignal::operator*
TRGCDCJSignal const operator*(TRGCDCJSignal const &rhs) const
Arithmetic multiply operator.
Definition: JSignal.cc:432
Belle2::TRGCDCJSignal::getBitsize
double getBitsize() const
Get bitwidth of signal.
Definition: JSignal.cc:1372
Belle2::TRGCDCJSignal::operator<=
TRGCDCJSignal & operator<=(TRGCDCJSignal const &rhs)
Assign operator.
Definition: JSignal.cc:272
Belle2::TRGCDCJSignal::calMinInteger
signed long long calMinInteger() const
Calculate min value for a binary number.
Definition: JSignal.cc:1548
Belle2::TRGCDCJSignal::initVhdlCode
void initVhdlCode()
Initializes the vhdl code.
Definition: JSignal.cc:1739
Belle2::TRGCDCJSignal::setPrintVhdl
void setPrintVhdl(bool printVhdl)
Sets print flag for signal.
Definition: JSignal.cc:1341
Belle2::TRGCDCJSignal::getType
int getType() const
Get type of signal.
Definition: JSignal.cc:1367
Belle2::TRGCDCJSignal::ifElseVhdlCode
static std::string ifElseVhdlCode(std::vector< std::pair< TRGCDCJSignal, std::vector< std::pair< TRGCDCJSignal *, TRGCDCJSignal > > > > const &data)
Writes the ifElse vhdl code.
Definition: JSignal.cc:2113
Belle2::TRGCDCJSignal::toUnsignedVhdlCode
void toUnsignedVhdlCode()
Changes signal type to unsigned type in VHDL.
Definition: JSignal.cc:1766
Belle2::TRGCDCJSignal::getMinActual
double getMinActual() const
Get minimum float value of signal.
Definition: JSignal.cc:1397
Belle2::TRGCDCJSignal::getMaxInt
signed long long getMaxInt() const
Get maximum integer value of signal.
Definition: JSignal.cc:1387
Belle2::TRGCDCJSignal::calFinishClock
int calFinishClock() const
Claculates the clock tick where the signal is valid.
Definition: JSignal.cc:1477
Belle2::TRGCDCJSignal::slvToUnsigned
static TRGCDCJSignal const slvToUnsigned(TRGCDCJSignal const &in, double const &toReal, signed long long const &minInt, signed long long const &maxInt, double const &actual, double const &minActual, double const &maxActual, int const &finishClock)
Change slv to unsigned with target clock.
Definition: JSignal.cc:1081
Belle2::TRGCDCJSignal::dump
void dump() const
Methods.
Definition: JSignal.cc:539
Belle2::TRGCDCJSignal::getRealInt
double getRealInt() const
Get converted float value of integer.
Definition: JSignal.cc:1407
Belle2::TRGCDCJSignal::TRGCDCJSignal
TRGCDCJSignal()
Constructor.
Definition: JSignal.cc:55
Belle2::TRGCDCJSignal::getMinInt
signed long long getMinInt() const
Get minimum integer value of signal.
Definition: JSignal.cc:1382
Belle2::TRGCDCJSignal::setToReal
void setToReal(double value)
Sets toReal factor of signal.
Definition: JSignal.cc:1313
Belle2::TRGCDCJSignal::mapSignalsToValues
static void mapSignalsToValues(std::map< std::string, Belle2::TRGCDCJSignal >const &inMap, std::vector< std::pair< std::string, int > > const &inChoose, std::vector< std::tuple< std::string, double, int, double, double, int > > &outValues)
Choose => [signalName, FpgaEffects(=1)/NoFpgaEffects(=0)] Values => [name, value, bitwidth,...
Definition: JSignal.cc:2224
Belle2::TRGCDCJSignal::setType
void setType(int type)
Sets type of signal.
Definition: JSignal.cc:1318
Belle2::TRGCDCJSignal::toSignedVhdlCode
void toSignedVhdlCode()
Changes signal type to signed type in VHDL.
Definition: JSignal.cc:1748
Belle2::TRGCDCJSignal::comp
static TRGCDCJSignal comp(TRGCDCJSignal const &lhs, const std::string &operate, TRGCDCJSignal const &rhs)
Compare two signals.
Definition: JSignal.cc:1169
Belle2::TRGCDCJSignal::slvToSigned
static TRGCDCJSignal const slvToSigned(TRGCDCJSignal const &in, double const &toReal, signed long long const &minInt, signed long long const &maxInt, double const &actual, double const &minActual, double const &maxActual, int const &finishClock)
Change slv to signed with target clock.
Definition: JSignal.cc:1040
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17