Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 660 lines (546 sloc) 14.808 kb
5796524 Add ne_expr.cc
steve authored
1 /*
2 * Copyright (c) 2002 Stephen Williams (steve@icarus.com)
3 *
4 * This source code is free software; you can redistribute it
5 * and/or modify it in source code form under the terms of the GNU
6 * General Public License as published by the Free Software
7 * Foundation; either version 2 of the License, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
18 */
52bf4e6 conditional ident string using autoconfig.
steve authored
19 #ifdef HAVE_CVS_IDENT
49b65e8 Add support for power in constant expressions.
steve authored
20 #ident "$Id: net_expr.cc,v 1.27 2006/07/31 03:50:17 steve Exp $"
5796524 Add ne_expr.cc
steve authored
21 #endif
22
928df5c include config.h to eliminate warnings.
steve authored
23 # include "config.h"
5796524 Add ne_expr.cc
steve authored
24 # include "netlist.h"
4c67de5 Add the lex_strings string handler, and put
steve authored
25 # include "compiler.h"
28e0616 Use standard name for iostream.
steve authored
26 # include <iostream>
5796524 Add ne_expr.cc
steve authored
27
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
28 /*
29 * the grand default data type is a logic vector.
30 */
31 ivl_variable_type_t NetExpr::expr_type() const
46253ed Rework expression parsing and elaboration to
steve authored
32 {
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
33 return IVL_VT_LOGIC;
46253ed Rework expression parsing and elaboration to
steve authored
34 }
35
de94d09 No need to keep excess width from an
steve authored
36 /*
37 * Create an add/sub node from the two operands. Make a best guess of
e4ae832 Clean up spurious trailing white space.
steve authored
38 * the
de94d09 No need to keep excess width from an
steve authored
39 */
40 NetEBAdd::NetEBAdd(char op, NetExpr*l, NetExpr*r)
41 : NetEBinary(op, l, r)
42 {
43 NetEConst* tmp;
44
45 /* Catch the special case that one of the operands is an
46 unsized constant number. If so, then we should set the
47 width of that number to the size of the other operand, plus
48 one. This expands the expression to account for the largest
49 possible result.
50
51 The set_width applied to a constant value will only
52 truncate the constant so far as it can still hold its
53 logical value, so this is safe to do. */
54 if ( (tmp = dynamic_cast<NetEConst*>(r))
55 && (! tmp->has_width())
56 && (tmp->expr_width() > l->expr_width()) ) {
57
58 unsigned target_width = l->expr_width() + 1;
59 r->set_width(target_width);
60
61 /* Note: This constant value will not gain a defined
7c1401a Spelling patch.
steve authored
62 width from this. Make sure. */
de94d09 No need to keep excess width from an
steve authored
63 assert(! r->has_width() );
64
65 } else if ( (tmp = dynamic_cast<NetEConst*>(l))
66 && (! tmp->has_width())
67 && (tmp->expr_width() > r->expr_width()) ) {
68
69 unsigned target_width = r->expr_width() + 1;
70 l->set_width(target_width);
71
72 /* Note: This constant value will not gain a defined
7c1401a Spelling patch.
steve authored
73 width from this. Make sure. */
de94d09 No need to keep excess width from an
steve authored
74 assert(! l->has_width() );
75
76 }
77
78 /* Now that we have the operand sizes the way we like, or as
79 good as we are going to get them, set the size of myself. */
80 if (r->expr_width() > l->expr_width()) {
81
82 expr_width(r->expr_width());
83
84 } else {
85 expr_width(l->expr_width());
86 }
87
88 cast_signed(l->has_sign() && r->has_sign());
89 }
90
91 NetEBAdd::~NetEBAdd()
92 {
93 }
94
95 NetEBAdd* NetEBAdd::dup_expr() const
96 {
97 NetEBAdd*result = new NetEBAdd(op_, left_->dup_expr(),
98 right_->dup_expr());
99 return result;
100 }
101
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
102 ivl_variable_type_t NetEBAdd::expr_type() const
46253ed Rework expression parsing and elaboration to
steve authored
103 {
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
104 if (left_->expr_type() == IVL_VT_REAL)
105 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
106
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
107 if (right_->expr_type() == IVL_VT_REAL)
108 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
109
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
110 return IVL_VT_LOGIC;
46253ed Rework expression parsing and elaboration to
steve authored
111 }
112
c602d94 Comparison operators do have defined width.
steve authored
113 /*
114 * Create a comparison operator with two sub-expressions.
115 *
116 * Handle the special case of an unsized constant on the left or right
117 * side by resizing the number to match the other
118 * expression. Otherwise, the netlist will have to allow the
119 * expressions to have different widths.
120 */
121 NetEBComp::NetEBComp(char op, NetExpr*l, NetExpr*r)
122 : NetEBinary(op, l, r)
123 {
124 if (NetEConst*tmp = dynamic_cast<NetEConst*>(r)) do {
125
126 if (tmp->has_width())
127 break;
128
7e2848b Do not try to set constants to width 0.
steve authored
129 if (l->expr_width() == 0)
130 break;
131
c602d94 Comparison operators do have defined width.
steve authored
132 if (tmp->expr_width() == l->expr_width())
133 break;
134
135 tmp->set_width(l->expr_width());
136
137 } while (0);
138
139 if (NetEConst*tmp = dynamic_cast<NetEConst*>(l)) do {
140
141 if (tmp->has_width())
142 break;
143
7e2848b Do not try to set constants to width 0.
steve authored
144 if (r->expr_width() == 0)
145 break;
146
c602d94 Comparison operators do have defined width.
steve authored
147 if (tmp->expr_width() == r->expr_width())
148 break;
149
150 tmp->set_width(r->expr_width());
151
152 } while (0);
153
154
155 expr_width(1);
156 }
157
158 NetEBComp::~NetEBComp()
159 {
160 }
161
162 bool NetEBComp::has_width() const
163 {
164 return true;
165 }
166
9fd1657 Support bool expressions and compares handle them optimally.
steve authored
167 ivl_variable_type_t NetEBComp::expr_type() const
168 {
169 // Case compare always returns BOOL
170 if (op() == 'E' || op() == 'N')
171 return IVL_VT_BOOL;
172
173 if (left()->expr_type() == IVL_VT_LOGIC)
174 return IVL_VT_LOGIC;
175
176 if (right()->expr_type() == IVL_VT_LOGIC)
177 return IVL_VT_LOGIC;
178
179 return IVL_VT_BOOL;
180 }
181
46253ed Rework expression parsing and elaboration to
steve authored
182 NetEBDiv::NetEBDiv(char op, NetExpr*l, NetExpr*r)
183 : NetEBinary(op, l, r)
184 {
185 unsigned w = l->expr_width();
186 if (r->expr_width() > w)
187 w = r->expr_width();
188
189 expr_width(w);
190 cast_signed(l->has_sign() && r->has_sign());
191 }
192
193 NetEBDiv::~NetEBDiv()
194 {
195 }
196
197 NetEBDiv* NetEBDiv::dup_expr() const
198 {
199 NetEBDiv*result = new NetEBDiv(op_, left_->dup_expr(),
200 right_->dup_expr());
201 return result;
202 }
203
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
204 ivl_variable_type_t NetEBDiv::expr_type() const
46253ed Rework expression parsing and elaboration to
steve authored
205 {
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
206 if (left_->expr_type() == IVL_VT_REAL)
207 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
208
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
209 if (right_->expr_type() == IVL_VT_REAL)
210 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
211
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
212 return IVL_VT_LOGIC;
46253ed Rework expression parsing and elaboration to
steve authored
213 }
214
215 NetEBMult::NetEBMult(char op, NetExpr*l, NetExpr*r)
216 : NetEBinary(op, l, r)
217 {
218 expr_width(l->expr_width() + r->expr_width());
219 cast_signed(l->has_sign() && r->has_sign());
222eaa0 Operands of unsigned multiply are unsigned.
steve authored
220
221 /* If it turns out that this is not a signed expression, then
222 cast the signedness out of the operands as well. */
223 if (! has_sign()) {
224 l->cast_signed(false);
225 r->cast_signed(false);
226 }
46253ed Rework expression parsing and elaboration to
steve authored
227 }
228
229 NetEBMult::~NetEBMult()
230 {
231 }
232
233 NetEBMult* NetEBMult::dup_expr() const
234 {
235 NetEBMult*result = new NetEBMult(op_, left_->dup_expr(),
236 right_->dup_expr());
237 return result;
238 }
239
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
240 ivl_variable_type_t NetEBMult::expr_type() const
46253ed Rework expression parsing and elaboration to
steve authored
241 {
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
242 if (left_->expr_type() == IVL_VT_REAL)
243 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
244
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
245 if (right_->expr_type() == IVL_VT_REAL)
246 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
247
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
248 return IVL_VT_LOGIC;
46253ed Rework expression parsing and elaboration to
steve authored
249 }
250
49b65e8 Add support for power in constant expressions.
steve authored
251 NetEBPow::NetEBPow(char op, NetExpr*l, NetExpr*r)
252 : NetEBinary(op, l, r)
253 {
254 assert(op == 'p');
255 expr_width(l->expr_width());
256 cast_signed(l->has_sign() || r->has_sign());
257 }
258
259 NetEBPow::~NetEBPow()
260 {
261 }
262
263 NetEBPow* NetEBPow::dup_expr() const
264 {
265 NetEBPow*result = new NetEBPow(op_, left_->dup_expr(),
266 right_->dup_expr());
267 result->set_line(*this);
268 return result;
269 }
270
271 ivl_variable_type_t NetEBPow::expr_type() const
272 {
273 if (right_->expr_type() == IVL_VT_REAL)
274 return IVL_VT_REAL;
275 if (left_->expr_type() == IVL_VT_REAL)
276 return IVL_VT_REAL;
277 if (left_->has_sign())
278 return IVL_VT_REAL;
279 if (right_->has_sign())
280 return IVL_VT_REAL;
281
282 return IVL_VT_LOGIC;
283 }
284
71a404a Add arithmetic shift operators.
steve authored
285 NetEBShift::NetEBShift(char op, NetExpr*l, NetExpr*r)
286 : NetEBinary(op, l, r)
287 {
288 expr_width(l->expr_width());
289
290 // The >>> is signed if the left operand is signed.
291 if (op == 'R') cast_signed(l->has_sign());
292 }
293
294 NetEBShift::~NetEBShift()
295 {
296 }
297
298 bool NetEBShift::has_width() const
299 {
300 return left_->has_width();
301 }
302
303 NetEBShift* NetEBShift::dup_expr() const
304 {
305 NetEBShift*result = new NetEBShift(op_, left_->dup_expr(),
306 right_->dup_expr());
307 return result;
308 }
309
8667b9a Put off evaluation of concatenation repeat expresions
steve authored
310 NetEConcat::NetEConcat(unsigned cnt, NetExpr* r)
311 : parms_(cnt), repeat_(r)
312 {
313 if (repeat_ == 0) {
314 repeat_calculated_ = true;
315 repeat_value_ = 1;
316 } else {
317 repeat_calculated_ = false;
318 }
319
320 expr_width(0);
321 }
322
323 NetEConcat::~NetEConcat()
324 {
325 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
326 delete parms_[idx];
327 }
328
aa8869a Postpone parameter width check to evaluation.
steve authored
329 bool NetEConcat::has_width() const
330 {
331 return true;
332 }
333
8667b9a Put off evaluation of concatenation repeat expresions
steve authored
334 void NetEConcat::set(unsigned idx, NetExpr*e)
335 {
336 assert(idx < parms_.count());
337 assert(parms_[idx] == 0);
338 parms_[idx] = e;
339 expr_width( expr_width() + e->expr_width() );
340 }
341
342 NetEConcat* NetEConcat::dup_expr() const
343 {
344 NetEConcat*dup = new NetEConcat(parms_.count(), repeat_);
345 for (unsigned idx = 0 ; idx < parms_.count() ; idx += 1)
346 if (parms_[idx]) {
347 NetExpr*tmp = parms_[idx]->dup_expr();
348 assert(tmp);
349 dup->parms_[idx] = tmp;
350 }
351
352
353 dup->expr_width(expr_width());
354 return dup;
355 }
356
357 unsigned NetEConcat::repeat()
358 {
359 if (repeat_calculated_)
360 return repeat_value_;
361
362 assert(repeat_);
363
364 if (! dynamic_cast<NetEConst*>(repeat_)) {
365 NetExpr*tmp = repeat_->eval_tree();
366 if (tmp != 0) {
367 delete repeat_;
368 repeat_ = tmp;
369 }
370 }
371
372 NetEConst*repeat_const = dynamic_cast<NetEConst*>(repeat_);
373
374 /* This should not be possible, as it was checked earlier to
375 assure that this is a constant expression. */
376 if (repeat_const == 0) {
377 cerr << get_line() << ": internal error: repeat expression "
378 << "is not a compile time constant." << endl;
379 cerr << get_line() << ": : Expression is: "
380 << *repeat_ << endl;
381 repeat_calculated_ = true;
382 repeat_value_ = 1;
383 return 1;
384 }
385
386 repeat_calculated_ = true;
387 repeat_value_ = repeat_const->value().as_ulong();
388
389 delete repeat_;
390 repeat_ = 0;
391
392 return repeat_value_;
393 }
394
395 unsigned NetEConcat::repeat() const
396 {
397 assert(repeat_calculated_);
398 return repeat_value_;
399 }
400
46253ed Rework expression parsing and elaboration to
steve authored
401 NetECReal::NetECReal(const verireal&val)
402 : value_(val)
403 {
404 }
405
406 NetECReal::~NetECReal()
407 {
408 }
409
410 const verireal& NetECReal::value() const
411 {
412 return value_;
413 }
414
589422b Real constants have no defined vector width
steve authored
415 bool NetECReal::has_width() const
416 {
417 return false;
418 }
419
46253ed Rework expression parsing and elaboration to
steve authored
420 NetECReal* NetECReal::dup_expr() const
421 {
422 NetECReal*tmp = new NetECReal(value_);
423 tmp->set_line(*this);
424 return tmp;
425 }
426
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
427 ivl_variable_type_t NetECReal::expr_type() const
46253ed Rework expression parsing and elaboration to
steve authored
428 {
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
429 return IVL_VT_REAL;
46253ed Rework expression parsing and elaboration to
steve authored
430 }
431
1295058 parameter keys are per_strings.
steve authored
432 NetECRealParam::NetECRealParam(NetScope*s, perm_string n, const verireal&v)
5903f07 Support parameters in real expressions and
steve authored
433 : NetECReal(v), scope_(s), name_(n)
434 {
435 }
436
437 NetECRealParam::~NetECRealParam()
438 {
439 }
440
1295058 parameter keys are per_strings.
steve authored
441 perm_string NetECRealParam::name() const
5903f07 Support parameters in real expressions and
steve authored
442 {
443 return name_;
444 }
445
446 const NetScope* NetECRealParam::scope() const
447 {
448 return scope_;
449 }
450
451
7e1e44e Properly cast signedness of parameters with ranges.
steve authored
452 NetEParam::NetEParam()
4350180 Redo the parameter vector support to allow
steve authored
453 : des_(0), scope_(0)
7e1e44e Properly cast signedness of parameters with ranges.
steve authored
454 {
455 }
456
1295058 parameter keys are per_strings.
steve authored
457 NetEParam::NetEParam(Design*d, NetScope*s, perm_string n)
7e1e44e Properly cast signedness of parameters with ranges.
steve authored
458 : des_(d), scope_(s), name_(n)
459 {
460 }
461
462 NetEParam::~NetEParam()
463 {
464 }
465
466 bool NetEParam::has_width() const
467 {
468 return false;
469 }
470
471 NetEParam* NetEParam::dup_expr() const
472 {
5903f07 Support parameters in real expressions and
steve authored
473 NetEParam*tmp = new NetEParam(des_, scope_, name_);
474 tmp->set_line(*this);
475 return tmp;
7e1e44e Properly cast signedness of parameters with ranges.
steve authored
476 }
477
5796524 Add ne_expr.cc
steve authored
478 NetESelect::NetESelect(NetExpr*exp, NetExpr*base, unsigned wid)
479 : expr_(exp), base_(base)
480 {
481 expr_width(wid);
482 }
483
484 NetESelect::~NetESelect()
485 {
486 delete expr_;
487 delete base_;
488 }
489
490 const NetExpr*NetESelect::sub_expr() const
491 {
492 return expr_;
493 }
494
495 const NetExpr*NetESelect::select() const
496 {
497 return base_;
498 }
499
500 bool NetESelect::has_width() const
501 {
502 return true;
503 }
504
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
505 NetESFunc::NetESFunc(const char*n, ivl_variable_type_t t,
6d94f2e Better organize the NetESFunc return type guesses.
steve authored
506 unsigned width, unsigned np)
507 : name_(0), type_(t)
04ada23 Support in various contexts the $realtime
steve authored
508 {
4c67de5 Add the lex_strings string handler, and put
steve authored
509 name_ = lex_strings.add(n);
04ada23 Support in various contexts the $realtime
steve authored
510 expr_width(width);
511 nparms_ = np;
512 parms_ = new NetExpr*[np];
513 for (unsigned idx = 0 ; idx < nparms_ ; idx += 1)
514 parms_[idx] = 0;
515 }
516
517 NetESFunc::~NetESFunc()
518 {
519 for (unsigned idx = 0 ; idx < nparms_ ; idx += 1)
520 if (parms_[idx]) delete parms_[idx];
521
522 delete[]parms_;
4c67de5 Add the lex_strings string handler, and put
steve authored
523 /* name_ string ls lex_strings allocated. */
04ada23 Support in various contexts the $realtime
steve authored
524 }
525
526 const char* NetESFunc::name() const
527 {
528 return name_;
529 }
530
531 unsigned NetESFunc::nparms() const
532 {
533 return nparms_;
534 }
535
536 void NetESFunc::parm(unsigned idx, NetExpr*v)
537 {
538 assert(idx < nparms_);
539 if (parms_[idx])
540 delete parms_[idx];
541 parms_[idx] = v;
542 }
543
544 const NetExpr* NetESFunc::parm(unsigned idx) const
545 {
546 assert(idx < nparms_);
547 return parms_[idx];
548 }
549
550 NetExpr* NetESFunc::parm(unsigned idx)
551 {
552 assert(idx < nparms_);
553 return parms_[idx];
554 }
555
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
556 ivl_variable_type_t NetESFunc::expr_type() const
04ada23 Support in various contexts the $realtime
steve authored
557 {
6d94f2e Better organize the NetESFunc return type guesses.
steve authored
558 return type_;
04ada23 Support in various contexts the $realtime
steve authored
559 }
560
5796524 Add ne_expr.cc
steve authored
561 /*
562 * $Log: net_expr.cc,v $
49b65e8 Add support for power in constant expressions.
steve authored
563 * Revision 1.27 2006/07/31 03:50:17 steve
564 * Add support for power in constant expressions.
565 *
0e044d6 More precise about r-value width of constants.
steve authored
566 * Revision 1.26 2005/11/26 00:35:43 steve
567 * More precise about r-value width of constants.
568 *
9fd1657 Support bool expressions and compares handle them optimally.
steve authored
569 * Revision 1.25 2005/09/14 02:53:14 steve
570 * Support bool expressions and compares handle them optimally.
571 *
b9799cf Remove NetVariable and ivl_variable_t structures.
steve authored
572 * Revision 1.24 2005/07/11 16:56:50 steve
573 * Remove NetVariable and ivl_variable_t structures.
574 *
e4ae832 Clean up spurious trailing white space.
steve authored
575 * Revision 1.23 2004/10/04 01:10:54 steve
576 * Clean up spurious trailing white space.
577 *
1295058 parameter keys are per_strings.
steve authored
578 * Revision 1.22 2004/02/20 06:22:56 steve
579 * parameter keys are per_strings.
580 *
7c1401a Spelling patch.
steve authored
581 * Revision 1.21 2003/08/28 04:11:19 steve
582 * Spelling patch.
583 *
71a404a Add arithmetic shift operators.
steve authored
584 * Revision 1.20 2003/06/18 03:55:18 steve
585 * Add arithmetic shift operators.
586 *
222eaa0 Operands of unsigned multiply are unsigned.
steve authored
587 * Revision 1.19 2003/06/15 18:53:20 steve
588 * Operands of unsigned multiply are unsigned.
589 *
5903f07 Support parameters in real expressions and
steve authored
590 * Revision 1.18 2003/05/30 02:55:32 steve
591 * Support parameters in real expressions and
592 * as real expressions, and fix multiply and
593 * divide with real results.
594 *
7e2848b Do not try to set constants to width 0.
steve authored
595 * Revision 1.17 2003/05/20 15:05:33 steve
596 * Do not try to set constants to width 0.
597 *
c602d94 Comparison operators do have defined width.
steve authored
598 * Revision 1.16 2003/03/15 18:08:43 steve
599 * Comparison operators do have defined width.
600 *
6d94f2e Better organize the NetESFunc return type guesses.
steve authored
601 * Revision 1.15 2003/03/15 04:46:29 steve
602 * Better organize the NetESFunc return type guesses.
603 *
4c67de5 Add the lex_strings string handler, and put
steve authored
604 * Revision 1.14 2003/03/01 06:25:30 steve
605 * Add the lex_strings string handler, and put
606 * scope names and system task/function names
607 * into this table. Also, permallocate event
608 * names from the beginning.
609 *
589422b Real constants have no defined vector width
steve authored
610 * Revision 1.13 2003/02/06 17:50:23 steve
611 * Real constants have no defined vector width
612 *
04ada23 Support in various contexts the $realtime
steve authored
613 * Revision 1.12 2003/01/27 00:14:37 steve
614 * Support in various contexts the $realtime
615 * system task.
616 *
46253ed Rework expression parsing and elaboration to
steve authored
617 * Revision 1.11 2003/01/26 21:15:58 steve
618 * Rework expression parsing and elaboration to
619 * accommodate real/realtime values and expressions.
620 *
aa8869a Postpone parameter width check to evaluation.
steve authored
621 * Revision 1.10 2002/11/09 01:40:19 steve
622 * Postpone parameter width check to evaluation.
623 *
de94d09 No need to keep excess width from an
steve authored
624 * Revision 1.9 2002/11/06 02:25:13 steve
625 * No need to keep excess width from an
626 * unsigned constant value, if it can
627 * be trimmed safely.
628 *
4350180 Redo the parameter vector support to allow
steve authored
629 * Revision 1.8 2002/10/19 22:59:49 steve
630 * Redo the parameter vector support to allow
631 * parameter names in range expressions.
632 *
7e1e44e Properly cast signedness of parameters with ranges.
steve authored
633 * Revision 1.7 2002/09/01 03:01:48 steve
634 * Properly cast signedness of parameters with ranges.
635 *
52bf4e6 conditional ident string using autoconfig.
steve authored
636 * Revision 1.6 2002/08/12 01:34:59 steve
637 * conditional ident string using autoconfig.
638 *
28e0616 Use standard name for iostream.
steve authored
639 * Revision 1.5 2002/06/06 18:57:18 steve
640 * Use standard name for iostream.
641 *
8941a59 include iostream for gcc 3.1
steve authored
642 * Revision 1.4 2002/05/25 16:51:37 steve
643 * include iostream for gcc 3.1
644 *
8667b9a Put off evaluation of concatenation repeat expresions
steve authored
645 * Revision 1.3 2002/05/05 21:11:50 steve
646 * Put off evaluation of concatenation repeat expresions
647 * until after parameters are defined. This allows parms
648 * to be used in repeat expresions.
649 *
650 * Add the builtin $signed system function.
651 *
928df5c include config.h to eliminate warnings.
steve authored
652 * Revision 1.2 2002/01/29 22:36:31 steve
653 * include config.h to eliminate warnings.
654 *
5796524 Add ne_expr.cc
steve authored
655 * Revision 1.1 2002/01/28 01:39:45 steve
656 * Add ne_expr.cc
657 *
658 */
659
Something went wrong with that request. Please try again.