functor.cc

   1 /*
   2  * Copyright (c) 1999-2005 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  */
  19 #ifdef HAVE_CVS_IDENT
  20 #ident "$Id: functor.cc,v 1.35 2005/07/07 16:22:49 steve Exp $"
  21 #endif
  22
  23 # include "config.h"
  24
  25 # include  <iostream>
  26
  27 # include  "functor.h"
  28 # include  "netlist.h"
  29
  30 functor_t::~functor_t()
  31 {
  32 }
  33
  34 void functor_t::event(class Design*, class NetEvent*)
  35 {
  36 }
  37
  38 void functor_t::signal(class Design*, class NetNet*)
  39 {
  40 }
  41
  42 void functor_t::process(class Design*, class NetProcTop*)
  43 {
  44 }
  45
  46 void functor_t::lpm_add_sub(class Design*, class NetAddSub*)
  47 {
  48 }
  49
  50 void functor_t::lpm_compare(class Design*, class NetCompare*)
  51 {
  52 }
  53
  54 void functor_t::lpm_const(class Design*, class NetConst*)
  55 {
  56 }
  57
  58 void functor_t::lpm_divide(class Design*, class NetDivide*)
  59 {
  60 }
  61
  62 void functor_t::lpm_literal(class Design*, class NetLiteral*)
  63 {
  64 }
  65
  66 void functor_t::lpm_modulo(class Design*, class NetModulo*)
  67 {
  68 }
  69
  70 void functor_t::lpm_ff(class Design*, class NetFF*)
  71 {
  72 }
  73
  74 void functor_t::lpm_logic(class Design*, class NetLogic*)
  75 {
  76 }
  77
  78 void functor_t::lpm_mult(class Design*, class NetMult*)
  79 {
  80 }
  81
  82 void functor_t::lpm_mux(class Design*, class NetMux*)
  83 {
  84 }
  85
  86 void functor_t::sign_extend(class Design*, class NetSignExtend*)
  87 {
  88 }
  89
  90 void functor_t::lpm_ureduce(class Design*, class NetUReduce*)
  91 {
  92 }
  93
  94
  95 void NetScope::run_functor(Design*des, functor_t*fun)
  96 {
  97       for (NetScope*cur = sub_ ;  cur ;  cur = cur->sib_) {
  98             cur->run_functor(des, fun);
  99       }
 100
 101       for (NetEvent*cur = events_ ;  cur ;  /* */) {
 102             NetEvent*tmp = cur;
 103             cur = cur->snext_;
 104             fun->event(des, tmp);
 105       }
 106
 107         // apply to signals. Each iteration, allow for the possibility
 108         // that the current signal deletes itself.
 109       if (signals_) {
 110             unsigned count = 0;
 111             NetNet*cur = signals_->sig_next_;
 112             do {
 113                   count += 1;
 114                   cur = cur->sig_next_;
 115             } while (cur != signals_->sig_next_);
 116
 117             cur = signals_->sig_next_;
 118             for (unsigned idx = 0 ;  idx < count ;  idx += 1) {
 119                   NetNet*tmp = cur->sig_next_;
 120                   fun->signal(des, cur);
 121                   cur = tmp;
 122             }
 123       }
 124 }
 125
 126 void Design::functor(functor_t*fun)
 127 {
 128         // Scan the scopes
 129       for (list<NetScope*>::const_iterator scope = root_scopes_.begin();
 130            scope != root_scopes_.end(); scope++)
 131             (*scope)->run_functor(this, fun);
 132
 133         // apply to processes
 134       procs_idx_ = procs_;
 135       while (procs_idx_) {
 136             NetProcTop*idx = procs_idx_;
 137             procs_idx_ = idx->next_;
 138             fun->process(this, idx);
 139       }
 140
 141         // apply to nodes
 142       if (nodes_) {
 143             assert(nodes_functor_cur_ == 0);
 144             assert(nodes_functor_nxt_ == 0);
 145
 146               /* Scan the circular list of nodes, starting with the
 147                  front of the list.
 148
 149                  This loop interacts with the Design::del_node method
 150                  so that the functor is free to delete any nodes it
 151                  choose. The destructors of the NetNode objects call
 152                  the del_node method, which checks with the
 153                  nodes_functor_* members, to keep the iterator
 154                  operating safely. */
 155             nodes_functor_cur_ = nodes_;
 156             do {
 157                   nodes_functor_nxt_ = nodes_functor_cur_->node_next_;
 158                   nodes_functor_cur_->functor_node(this, fun);
 159
 160                   if (nodes_functor_nxt_ == 0)
 161                         break;
 162
 163                   nodes_functor_cur_ = nodes_functor_nxt_;
 164             } while (nodes_ && (nodes_functor_cur_ != nodes_));
 165             nodes_functor_cur_ = 0;
 166             nodes_functor_nxt_ = 0;
 167
 168       }
 169 }
 170
 171
 172 void NetNode::functor_node(Design*, functor_t*)
 173 {
 174 }
 175
 176 void NetAddSub::functor_node(Design*des, functor_t*fun)
 177 {
 178       fun->lpm_add_sub(des, this);
 179 }
 180
 181 void NetCompare::functor_node(Design*des, functor_t*fun)
 182 {
 183       fun->lpm_compare(des, this);
 184 }
 185
 186 void NetConst::functor_node(Design*des, functor_t*fun)
 187 {
 188       fun->lpm_const(des, this);
 189 }
 190
 191 void NetDivide::functor_node(Design*des, functor_t*fun)
 192 {
 193       fun->lpm_divide(des, this);
 194 }
 195
 196 void NetFF::functor_node(Design*des, functor_t*fun)
 197 {
 198       fun->lpm_ff(des, this);
 199 }
 200
 201 void NetLiteral::functor_node(Design*des, functor_t*fun)
 202 {
 203       fun->lpm_literal(des, this);
 204 }
 205
 206 void NetLogic::functor_node(Design*des, functor_t*fun)
 207 {
 208       fun->lpm_logic(des, this);
 209 }
 210
 211 void NetModulo::functor_node(Design*des, functor_t*fun)
 212 {
 213       fun->lpm_modulo(des, this);
 214 }
 215
 216 void NetMult::functor_node(Design*des, functor_t*fun)
 217 {
 218       fun->lpm_mult(des, this);
 219 }
 220
 221 void NetMux::functor_node(Design*des, functor_t*fun)
 222 {
 223       fun->lpm_mux(des, this);
 224 }
 225
 226 void NetSignExtend::functor_node(Design*des, functor_t*fun)
 227 {
 228       fun->sign_extend(des, this);
 229 }
 230
 231 void NetUReduce::functor_node(Design*des, functor_t*fun)
 232 {
 233       fun->lpm_ureduce(des, this);
 234 }
 235
 236 proc_match_t::~proc_match_t()
 237 {
 238 }
 239
 240 int NetProc::match_proc(proc_match_t*that)
 241 {
 242       return 0;
 243 }
 244
 245 int proc_match_t::assign(NetAssign*)
 246 {
 247       return 0;
 248 }
 249
 250 int NetAssign::match_proc(proc_match_t*that)
 251 {
 252       return that->assign(this);
 253 }
 254
 255 int proc_match_t::assign_nb(NetAssignNB*)
 256 {
 257       return 0;
 258 }
 259
 260 int NetAssignNB::match_proc(proc_match_t*that)
 261 {
 262       return that->assign_nb(this);
 263 }
 264
 265 int proc_match_t::block(NetBlock*)
 266 {
 267       return 0;
 268 }
 269
 270 int NetBlock::match_proc(proc_match_t*that)
 271 {
 272       return that->block(this);
 273 }
 274
 275 int proc_match_t::condit(NetCondit*)
 276 {
 277       return 0;
 278 }
 279
 280 int NetCondit::match_proc(proc_match_t*that)
 281 {
 282       return that->condit(this);
 283 }
 284
 285 int NetEvWait::match_proc(proc_match_t*that)
 286 {
 287       return that->event_wait(this);
 288 }
 289
 290 int proc_match_t::event_wait(NetEvWait*)
 291 {
 292       return 0;
 293 }
 294
 295 /*
 296  * $Log: functor.cc,v $
 297  * Revision 1.35  2005/07/07 16:22:49  steve
 298  *  Generalize signals to carry types.
 299  *
 300  * Revision 1.34  2005/05/24 01:44:27  steve
 301  *  Do sign extension of structuran nets.
 302  *
 303  * Revision 1.33  2005/02/03 04:56:20  steve
 304  *  laborate reduction gates into LPM_RED_ nodes.
 305  *
 306  * Revision 1.32  2004/10/04 01:10:53  steve
 307  *  Clean up spurious trailing white space.
 308  *
 309  * Revision 1.31  2002/08/16 05:18:27  steve
 310  *  Fix intermix of node functors and node delete.
 311  *
 312  * Revision 1.30  2002/08/12 01:34:59  steve
 313  *  conditional ident string using autoconfig.
 314  *
 315  * Revision 1.29  2002/08/10 22:07:38  steve
 316  *  Remove useless error messages.
 317  *
 318  * Revision 1.28  2002/06/05 03:44:25  steve
 319  *  Add support for memory words in l-value of
 320  *  non-blocking assignments, and remove the special
 321  *  NetAssignMem_ and NetAssignMemNB classes.
 322  *
 323  * Revision 1.27  2002/06/04 05:38:44  steve
 324  *  Add support for memory words in l-value of
 325  *  blocking assignments, and remove the special
 326  *  NetAssignMem class.
 327  *
 328  * Revision 1.26  2001/10/19 21:53:24  steve
 329  *  Support multiple root modules (Philip Blundell)
 330  *
 331  * Revision 1.25  2001/07/25 03:10:49  steve
 332  *  Create a config.h.in file to hold all the config
 333  *  junk, and support gcc 3.0. (Stephan Boettcher)
 334  *
 335  * Revision 1.24  2000/11/19 20:48:30  steve
 336  *  Fix cases where signal iteration might die early.
 337  *
 338  * Revision 1.23  2000/11/18 04:53:04  steve
 339  *  Watch out in functor, it may delete the last signal.
 340  *
 341  * Revision 1.22  2000/09/17 21:26:15  steve
 342  *  Add support for modulus (Eric Aardoom)
 343  *
 344  * Revision 1.21  2000/08/01 02:48:41  steve
 345  *  Support <= in synthesis of DFF and ram devices.
 346  */
 347