QP/C: qhsm_dis.c Source File

00001 /*****************************************************************************
00002 * Product: QEP/C
00003 * Last Updated for Version: 4.1.00
00004 * Date of the Last Update:  Oct 09, 2009
00005 *
00006 *                    Q u a n t u m     L e a P s
00007 *                    ---------------------------
00008 *                    innovating embedded systems
00009 *
00010 * Copyright (C) 2002-2009 Quantum Leaps, LLC. All rights reserved.
00011 *
00012 * This software may be distributed and modified under the terms of the GNU
00013 * General Public License version 2 (GPL) as published by the Free Software
00014 * Foundation and appearing in the file GPL.TXT included in the packaging of
00015 * this file. Please note that GPL Section 2[b] requires that all works based
00016 * on this software must also be made publicly available under the terms of
00017 * the GPL ("Copyleft").
00018 *
00019 * Alternatively, this software may be distributed and modified under the
00020 * terms of Quantum Leaps commercial licenses, which expressly supersede
00021 * the GPL and are specifically designed for licensees interested in
00022 * retaining the proprietary status of their code.
00023 *
00024 * Contact information:
00025 * Quantum Leaps Web site:  http://www.quantum-leaps.com
00026 * e-mail:                  info@quantum-leaps.com
00027 *****************************************************************************/
00028 #include "qep_pkg.h"
00029 #include "qassert.h"
00030 
00031 Q_DEFINE_THIS_MODULE(qhsm_dis)
00032 
00033 
00039 /*..........................................................................*/
00040 void QHsm_dispatch(QHsm *me, QEvent const *e) {
00041     QStateHandler path[QEP_MAX_NEST_DEPTH_];
00042     QStateHandler s;
00043     QStateHandler t;
00044     QState r;
00045     QS_INT_LOCK_KEY_
00046 
00047     t = me->state;                                /* save the current state */
00048 
00049     QS_BEGIN_(QS_QEP_DISPATCH, QS_smObj_, me)
00050         QS_TIME_();                                           /* time stamp */
00051         QS_SIG_(e->sig);                         /* the signal of the event */
00052         QS_OBJ_(me);                           /* this state machine object */
00053         QS_FUN_(t);                                    /* the current state */
00054     QS_END_()
00055 
00056     do {                             /* process the event hierarchically... */
00057         s = me->state;
00058         r = (*s)(me, e);                          /* invoke state handler s */
00059     } while (r == Q_RET_SUPER);
00060 
00061     if (r == Q_RET_TRAN) {                             /* transition taken? */
00062 #ifdef Q_SPY
00063         QStateHandler src = s;    /* save the transition source for tracing */
00064 #endif
00065         int8_t ip = (int8_t)(-1);            /* transition entry path index */
00066         int8_t iq;                    /* helper transition entry path index */
00067 
00068         path[0] = me->state;           /* save the target of the transition */
00069         path[1] = t;
00070 
00071         while (t != s) {    /* exit current state to transition source s... */
00072             if (QEP_TRIG_(t, Q_EXIT_SIG) == Q_RET_HANDLED) {/*exit handled? */
00073                 QS_BEGIN_(QS_QEP_STATE_EXIT, QS_smObj_, me)
00074                     QS_OBJ_(me);               /* this state machine object */
00075                     QS_FUN_(t);                         /* the exited state */
00076                 QS_END_()
00077 
00078                 (void)QEP_TRIG_(t, QEP_EMPTY_SIG_); /* find superstate of t */
00079             }
00080             t = me->state;                /* me->state holds the superstate */
00081         }
00082 
00083         t = path[0];                            /* target of the transition */
00084 
00085         if (s == t) {      /* (a) check source==target (transition to self) */
00086             QEP_EXIT_(s)                                 /* exit the source */
00087             ip = (int8_t)0;                             /* enter the target */
00088         }
00089         else {
00090             (void)QEP_TRIG_(t, QEP_EMPTY_SIG_);     /* superstate of target */
00091             t = me->state;
00092             if (s == t) {                /* (b) check source==target->super */
00093                 ip = (int8_t)0;                         /* enter the target */
00094             }
00095             else {
00096                 (void)QEP_TRIG_(s, QEP_EMPTY_SIG_);    /* superstate of src */
00097                                   /* (c) check source->super==target->super */
00098                 if (me->state == t) {
00099                     QEP_EXIT_(s)                         /* exit the source */
00100                     ip = (int8_t)0;                     /* enter the target */
00101                 }
00102                 else {
00103                                          /* (d) check source->super==target */
00104                     if (me->state == path[0]) {
00105                         QEP_EXIT_(s)                     /* exit the source */
00106                     }
00107                     else { /* (e) check rest of source==target->super->super..
00108                             * and store the entry path along the way
00109                             */
00110                         iq = (int8_t)0;      /* indicate that LCA not found */
00111                         ip = (int8_t)1;  /* enter target and its superstate */
00112                         path[1] = t;       /* save the superstate of target */
00113                         t = me->state;                /* save source->super */
00114                                                /* find target->super->super */
00115                         r = QEP_TRIG_(path[1], QEP_EMPTY_SIG_);
00116                         while (r == Q_RET_SUPER) {
00117                             path[++ip] = me->state; /* store the entry path */
00118                             if (me->state == s) {      /* is it the source? */
00119                                 iq = (int8_t)1;  /* indicate that LCA found */
00120                                             /* entry path must not overflow */
00121                                 Q_ASSERT(ip < (int8_t)QEP_MAX_NEST_DEPTH_);
00122                                 --ip;            /* do not enter the source */
00123                                 r = Q_RET_HANDLED;    /* terminate the loop */
00124                             }
00125                             else {   /* it is not the source, keep going up */
00126                                 r = QEP_TRIG_(me->state, QEP_EMPTY_SIG_);
00127                             }
00128                         }
00129                         if (iq == (int8_t)0) {    /* the LCA not found yet? */
00130 
00131                                             /* entry path must not overflow */
00132                             Q_ASSERT(ip < (int8_t)QEP_MAX_NEST_DEPTH_);
00133 
00134                             QEP_EXIT_(s)                /* exit the source */
00135 
00136                                 /* (f) check the rest of source->super
00137                                  *                  == target->super->super...
00138                                  */
00139                             iq = ip;
00140                             r = Q_RET_IGNORED;    /* indicate LCA NOT found */
00141                             do {
00142                                 if (t == path[iq]) {    /* is this the LCA? */
00143                                     r = Q_RET_HANDLED;/* indicate LCA found */
00144                                     ip = (int8_t)(iq - 1);/*do not enter LCA*/
00145                                     iq = (int8_t)(-1);/* terminate the loop */
00146                                 }
00147                                 else {
00148                                     --iq; /* try lower superstate of target */
00149                                 }
00150                             } while (iq >= (int8_t)0);
00151 
00152                             if (r != Q_RET_HANDLED) { /* LCA not found yet? */
00153                                     /* (g) check each source->super->...
00154                                      * for each target->super...
00155                                      */
00156                                 r = Q_RET_IGNORED;          /* keep looping */
00157                                 do {
00158                                                        /* exit t unhandled? */
00159                                     if (QEP_TRIG_(t, Q_EXIT_SIG)
00160                                         == Q_RET_HANDLED)
00161                                     {
00162                                         QS_BEGIN_(QS_QEP_STATE_EXIT,
00163                                                   QS_smObj_, me)
00164                                             QS_OBJ_(me);
00165                                             QS_FUN_(t);
00166                                         QS_END_()
00167 
00168                                         (void)QEP_TRIG_(t, QEP_EMPTY_SIG_);
00169                                     }
00170                                     t = me->state;    /*  set to super of t */
00171                                     iq = ip;
00172                                     do {
00173                                         if (t == path[iq]) {/* is this LCA? */
00174                                                         /* do not enter LCA */
00175                                             ip = (int8_t)(iq - 1);
00176                                             iq = (int8_t)(-1);/*break inner */
00177                                             r = Q_RET_HANDLED;/*break outer */
00178                                         }
00179                                         else {
00180                                             --iq;
00181                                         }
00182                                     } while (iq >= (int8_t)0);
00183                                 } while (r != Q_RET_HANDLED);
00184                             }
00185                         }
00186                     }
00187                 }
00188             }
00189         }
00190                     /* retrace the entry path in reverse (desired) order... */
00191         for (; ip >= (int8_t)0; --ip) {
00192             QEP_ENTER_(path[ip])                          /* enter path[ip] */
00193         }
00194         t = path[0];                      /* stick the target into register */
00195         me->state = t;                          /* update the current state */
00196 
00197                                       /* drill into the target hierarchy... */
00198         while (QEP_TRIG_(t, Q_INIT_SIG) == Q_RET_TRAN) {
00199 
00200             QS_BEGIN_(QS_QEP_STATE_INIT, QS_smObj_, me)
00201                 QS_OBJ_(me);                   /* this state machine object */
00202                 QS_FUN_(t);                     /* the source (pseudo)state */
00203                 QS_FUN_(me->state);         /* the target of the transition */
00204             QS_END_()
00205 
00206             ip = (int8_t)0;
00207             path[0] = me->state;
00208             (void)QEP_TRIG_(me->state, QEP_EMPTY_SIG_);  /* find superstate */
00209             while (me->state != t) {
00210                 path[++ip] = me->state;
00211                 (void)QEP_TRIG_(me->state, QEP_EMPTY_SIG_);/*find superstate*/
00212             }
00213             me->state = path[0];
00214                                             /* entry path must not overflow */
00215             Q_ASSERT(ip < (int8_t)QEP_MAX_NEST_DEPTH_);
00216 
00217             do {    /* retrace the entry path in reverse (correct) order... */
00218                 QEP_ENTER_(path[ip])                      /* enter path[ip] */
00219             } while ((--ip) >= (int8_t)0);
00220 
00221             t = path[0];
00222         }
00223 
00224         QS_BEGIN_(QS_QEP_TRAN, QS_smObj_, me)
00225             QS_TIME_();                                       /* time stamp */
00226             QS_SIG_(e->sig);                     /* the signal of the event */
00227             QS_OBJ_(me);                       /* this state machine object */
00228             QS_FUN_(src);                   /* the source of the transition */
00229             QS_FUN_(t);                             /* the new active state */
00230         QS_END_()
00231 
00232     }
00233     else {                                          /* transition not taken */
00234 #ifdef Q_SPY
00235         if (r == Q_RET_IGNORED) {                         /* event ignored? */
00236 
00237             QS_BEGIN_(QS_QEP_IGNORED, QS_smObj_, me)
00238                 QS_TIME_();                                   /* time stamp */
00239                 QS_SIG_(e->sig);                 /* the signal of the event */
00240                 QS_OBJ_(me);                   /* this state machine object */
00241                 QS_FUN_(t);                            /* the current state */
00242             QS_END_()
00243 
00244         }
00245         else {                                             /* event handled */
00246 
00247             QS_BEGIN_(QS_QEP_INTERN_TRAN, QS_smObj_, me)
00248                 QS_TIME_();                                   /* time stamp */
00249                 QS_SIG_(e->sig);                 /* the signal of the event */
00250                 QS_OBJ_(me);                   /* this state machine object */
00251                 QS_FUN_(s);             /* the state that handled the event */
00252             QS_END_()
00253 
00254         }
00255 #endif
00256     }
00257     me->state = t;            /* set new state or restore the current state */
00258 }