src/policy_manager/zipc/dummy_stm.c

   1 #include <string.h>
   2 #include "dummy_stm.h"
   3 #include "hmi-debug.h"
   4
   5 const char* gStmEventName[] = {
   6     "activate",
   7     "deactivate",
   8     "trans_gear_neutral",
   9     "trans_gear_not_neutral",
  10     "parking_brake_off",
  11     "parking_brake_on",
  12     "accel_pedal_off",
  13     "accel_pedal_on",
  14     "timer_expired",
  15     "lamp_off",
  16     "lamp_on",
  17     "lightstatus_brake_off",
  18     "lightstatus_brake_on",
  19     "restriction_mode_off",
  20     "restriction_mode_on",
  21 };
  22
  23 const int gStmEventNo[] = {
  24     STM_EVT_NO_ACTIVATE,
  25     STM_EVT_NO_DEACTIVATE,
  26     STM_EVT_NO_TRANS_GEAR_N,
  27     STM_EVT_NO_TRANS_GEAR_NOT_N,
  28     STM_EVT_NO_PARKING_BRAKE_OFF,
  29     STM_EVT_NO_PARKING_BRAKE_ON,
  30     STM_EVT_NO_ACCEL_PEDAL_OFF,
  31     STM_EVT_NO_ACCEL_PEDAL_ON,
  32     STM_EVT_NO_TIMER_EXPIRED,
  33     STM_EVT_NO_LAMP_OFF,
  34     STM_EVT_NO_LAMP_ON,
  35     STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF,
  36     STM_EVT_NO_LIGHTSTATUS_BRAKE_ON,
  37     STM_EVT_NO_RESTRICTION_MODE_OFF,
  38     STM_EVT_NO_RESTRICTION_MODE_ON,
  39 };
  40
  41 const char* gStmCategoryName[] = {
  42     "homescreen",
  43     "map",
  44     "general",
  45     "splitable",
  46     "popup",
  47     "system_alert",
  48     "restriction",
  49 };
  50
  51 const int gStmCategoryNo[] = {
  52     STM_CTG_NO_HOMESCREEN,
  53     STM_CTG_NO_MAP,
  54     STM_CTG_NO_GENERAL,
  55     STM_CTG_NO_SPLITABLE,
  56     STM_CTG_NO_POPUP,
  57     STM_CTG_NO_SYSTEM_ALERT,
  58     STM_CTG_NO_RESTRICTION,
  59 };
  60
  61 const char* gStmAreaName[] = {
  62     "full",
  63     "normal",
  64     "split.main",
  65     "split.sub",
  66     "onscreen",
  67     "restriction.normal",
  68     "restriction.split.main",
  69     "restriction.split.sub",
  70 };
  71
  72 const int gStmAreaNo[] = {
  73     STM_ARA_NO_FULL,
  74     STM_ARA_NO_NORMAL,
  75     STM_ARA_NO_SPLIT_MAIN,
  76     STM_ARA_NO_SPLIT_SUB,
  77     STM_ARA_NO_ON_SCREEN,
  78     STM_ARA_NO_RESTRICTION_NORMAL,
  79     STM_ARA_NO_RESTRICTION_SPLIT_MAIN,
  80     STM_ARA_NO_RESTRICTION_SPLIT_SUB,
  81 };
  82
  83 // String for state
  84 const char* gStmTransGearStateNo2Name[] = {
  85     "trans_gear_neutral",
  86     "trans_gear_not_neutral"
  87 };
  88
  89 const char* gStmParkingBrakeStateNo2Name[] = {
  90     "parking_brake_off",
  91     "parking_brake_on"
  92 };
  93
  94 const char* gStmAccelPedalStateNo2Name[] = {
  95     "accel_pedal_off",
  96     "accel_pedal_on"
  97 };
  98
  99 const char* gStmCarStateNo2Name[] = {
 100     "car_stop",
 101     "car_run"
 102 };
 103
 104 const char* gStmLampStateNo2Name[] = {
 105     "lamp_off",
 106     "lamp_on"
 107 };
 108
 109 const char* gStmLightstatusBrakeStateNo2Name[] = {
 110     "lightstatus_brake_off",
 111     "lightstatus_brake_on"
 112 };
 113
 114 const char* gStmRestrictionModeStateNo2Name[] = {
 115     "restriction_mode_off",
 116     "restriction_mode_on"
 117 };
 118
 119 const char* gStmLayoutNo2Name[] = {
 120     "none",
 121     "pu",
 122     "sa",
 123     "m1",
 124     "m2",
 125     "mf",
 126     "s1",
 127     "s2",
 128     "g",
 129     "hs",
 130     "restriction",
 131     "restriction.split.main",
 132     "restriction.split.sub",
 133 };
 134
 135 stm_state_t g_crr_state;
 136 stm_state_t g_prv_state;
 137 int g_prv_restriction_state_car_stop = 0;
 138 int g_prv_apps_state_car_stop = 0;
 139 int g_map_is_activated = STM_FALSE;
 140
 141 void stmInitialize() {
 142     // Initialize previous state
 143     memset(&g_prv_state, 0, sizeof(g_prv_state));
 144
 145     g_prv_state.layer.on_screen.state   = gStmLayoutNoNone;
 146     g_prv_state.layer.restriction.state = gStmLayoutNoNone;
 147     g_prv_state.layer.apps.state        = gStmLayoutNoNone;
 148     g_prv_state.layer.homescreen.state  = gStmLayoutNoNone;
 149     g_prv_state.trans_gear.state        = gStmTransGearStateNoN;
 150     g_prv_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
 151     g_prv_state.accel_pedal.state       = gStmAccelPedalStateNoOff;
 152     g_prv_state.car.state               = gStmCarStateNoStop;
 153     g_prv_state.lamp.state              = gStmLampStateNoOff;
 154     g_prv_state.parking_brake.state     = gStmParkingBrakeStateNoOn;
 155     g_prv_state.restriction_mode.state  = gStmRestrictionModeStateNoOff;
 156
 157     // Initialize current state
 158     g_crr_state = g_prv_state;
 159 }
 160
 161 int stmTransitionState(int event, stm_state_t* state) {
 162     int event_no, category_no, area_no;
 163     int restriction_state, apps_state;
 164     int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state, restriction_mode_state;
 165
 166     event_no    = event & STM_MSK_EVT_NO;
 167     category_no = event & STM_MSK_CTG_NO;
 168     area_no     = event & STM_MSK_ARA_NO;
 169
 170     // Backup previous state
 171     g_prv_state = g_crr_state;
 172
 173     // Get previous state
 174     restriction_state = g_prv_state.layer.restriction.state;
 175     apps_state        = g_prv_state.layer.apps.state;
 176     trans_gear_state        = g_prv_state.trans_gear.state;
 177     parking_brake_state     = g_prv_state.parking_brake.state;
 178     accel_pedal_state       = g_prv_state.accel_pedal.state;
 179     car_state               = g_prv_state.car.state;
 180     lamp_state              = g_prv_state.lamp.state;
 181     lightstatus_brake_state = g_prv_state.lightstatus_brake.state;
 182     restriction_mode_state  = g_prv_state.restriction_mode.state;
 183
 184     // Clear flags
 185     g_crr_state.layer.on_screen.is_changed   = STM_FALSE;
 186     g_crr_state.layer.restriction.is_changed = STM_FALSE;
 187     g_crr_state.layer.apps.is_changed        = STM_FALSE;
 188     g_crr_state.layer.homescreen.is_changed  = STM_FALSE;
 189     g_crr_state.trans_gear.is_changed        = STM_FALSE;
 190     g_crr_state.parking_brake.is_changed     = STM_FALSE;
 191     g_crr_state.lightstatus_brake.is_changed = STM_FALSE;
 192     g_crr_state.accel_pedal.is_changed       = STM_FALSE;
 193     g_crr_state.car.is_changed               = STM_FALSE;
 194     g_crr_state.lamp.is_changed              = STM_FALSE;
 195     g_crr_state.restriction_mode.is_changed  = STM_FALSE;
 196
 197
 198     // Set car state
 199     switch (event_no) {
 200     case STM_EVT_NO_TRANS_GEAR_N:
 201         if (gStmTransGearStateNoN != trans_gear_state) {
 202             g_crr_state.trans_gear.state = gStmTransGearStateNoN;
 203             g_crr_state.trans_gear.is_changed = STM_TRUE;
 204         }
 205         break;
 206     case STM_EVT_NO_TRANS_GEAR_NOT_N:
 207         if (gStmTransGearStateNoNotN != trans_gear_state) {
 208             g_crr_state.trans_gear.state = gStmTransGearStateNoNotN;
 209             g_crr_state.trans_gear.is_changed = STM_TRUE;
 210         }
 211         break;
 212     case STM_EVT_NO_PARKING_BRAKE_OFF:
 213         if (gStmParkingBrakeStateNoOff != parking_brake_state) {
 214             g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOff;
 215             g_crr_state.parking_brake.is_changed = STM_TRUE;
 216         }
 217         break;
 218     case STM_EVT_NO_PARKING_BRAKE_ON:
 219         if (gStmParkingBrakeStateNoOn != parking_brake_state) {
 220             g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOn;
 221             g_crr_state.parking_brake.is_changed = STM_TRUE;
 222         }
 223         break;
 224     case STM_EVT_NO_ACCEL_PEDAL_OFF:
 225         if (gStmAccelPedalStateNoOff != accel_pedal_state) {
 226             g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOff;
 227             g_crr_state.accel_pedal.is_changed = STM_TRUE;
 228         }
 229         break;
 230     case STM_EVT_NO_ACCEL_PEDAL_ON:
 231         if (gStmAccelPedalStateNoOn != accel_pedal_state) {
 232             g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOn;
 233             g_crr_state.accel_pedal.is_changed = STM_TRUE;
 234         }
 235         break;
 236     case STM_EVT_NO_LAMP_OFF:
 237         if (gStmLampStateNoOff != lamp_state) {
 238             g_crr_state.lamp.state = gStmLampStateNoOff;
 239             g_crr_state.lamp.is_changed = STM_TRUE;
 240         }
 241         break;
 242     case STM_EVT_NO_LAMP_ON:
 243         if (gStmLampStateNoOn != lamp_state) {
 244             g_crr_state.lamp.state = gStmLampStateNoOn;
 245             g_crr_state.lamp.is_changed = STM_TRUE;
 246         }
 247         break;
 248     case STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF:
 249         if (gStmLightstatusBrakeStateNoOff != lightstatus_brake_state) {
 250             g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOff;
 251             g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
 252         }
 253         break;
 254     case STM_EVT_NO_LIGHTSTATUS_BRAKE_ON:
 255         if (gStmLightstatusBrakeStateNoOn != lightstatus_brake_state) {
 256             g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
 257             g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
 258         }
 259         break;
 260     default:
 261         // nop
 262         break;
 263     }
 264
 265 #if 1 // FOR ALS
 266     if (g_crr_state.lightstatus_brake.is_changed
 267         || g_crr_state.accel_pedal.is_changed) {
 268         if ((gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state)
 269             && (gStmAccelPedalStateNoOn == g_crr_state.accel_pedal.state)){
 270 #else
 271     if (g_crr_state.parking_brake.is_changed
 272         || g_crr_state.trans_gear.is_changed) {
 273         if ((gStmParkingBrakeStateNoOff == g_crr_state.parking_brake.state)
 274             && (gStmTransGearStateNoNotN == g_crr_state.trans_gear.state)){
 275 #endif
 276             if (gStmCarStateNoRun != car_state) {
 277                 // Car state is changed stop -> run
 278                 g_crr_state.car.state = gStmCarStateNoRun;
 279                 g_crr_state.car.is_changed = STM_TRUE;
 280             }
 281         }
 282         else {
 283             if (gStmCarStateNoStop != car_state) {
 284                 // Car state is changed run -> stop
 285                 g_crr_state.car.state = gStmCarStateNoStop;
 286                 g_crr_state.car.is_changed = STM_TRUE;
 287             }
 288         }
 289     }
 290
 291     // Set restriction mode
 292     if ((STM_EVT_NO_RESTRICTION_MODE_ON == event_no)
 293       && (gStmRestrictionModeStateNoOn != restriction_mode_state)) {
 294         HMI_DEBUG("wm:pm:stm", "Restriction mode OFF -> ON");
 295
 296         // Restriction mode is changed OFF -> ON
 297         g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOn;
 298         g_crr_state.restriction_mode.is_changed = STM_TRUE;
 299
 300         // Update restriction layer
 301         g_prv_restriction_state_car_stop = restriction_state;
 302         g_crr_state.layer.restriction.state = gStmLayoutNoNone;
 303         g_crr_state.layer.restriction.is_changed = STM_TRUE;
 304
 305         // Update apps layer
 306         g_prv_apps_state_car_stop = apps_state;
 307         if (STM_TRUE == g_map_is_activated) {
 308             g_crr_state.layer.apps.state = gStmLayoutNoM1;
 309             g_crr_state.layer.apps.is_changed = STM_TRUE;
 310         }
 311     }
 312     else if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event_no)
 313       && (gStmRestrictionModeStateNoOff != restriction_mode_state)) {
 314         HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");
 315
 316         // Restriction mode is changed ON -> OFF
 317         g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOff;
 318         g_crr_state.restriction_mode.is_changed = STM_TRUE;
 319
 320         // Update restriction layer
 321         g_crr_state.layer.restriction.state = g_prv_restriction_state_car_stop;
 322         g_crr_state.layer.restriction.is_changed = STM_TRUE;
 323
 324         // Update apps layer
 325         if (STM_TRUE == g_map_is_activated) {
 326             g_crr_state.layer.apps.state = g_prv_apps_state_car_stop;
 327             g_crr_state.layer.apps.is_changed = STM_TRUE;
 328         }
 329     }
 330
 331     // Set apps/homescreen layer
 332     switch (event_no) {
 333     case STM_EVT_NO_ACTIVATE:
 334         if (gStmRestrictionModeStateNoOff == restriction_mode_state) {
 335             switch (category_no) {
 336             case STM_CTG_NO_HOMESCREEN:
 337                 // Apps layer
 338                 g_crr_state.layer.apps.state = gStmLayoutNoNone;
 339                 g_crr_state.layer.apps.is_changed = STM_TRUE;
 340
 341                 // Homescreen layer
 342                 g_crr_state.layer.homescreen.state = gStmLayoutNoHs;
 343                 g_crr_state.layer.homescreen.is_changed = STM_TRUE;
 344                 break;
 345             case STM_CTG_NO_MAP:
 346                 switch (area_no) {
 347                 case STM_ARA_NO_FULL:
 348                     // Apps layer
 349                     switch (apps_state) {
 350                     case gStmLayoutNoMf:
 351                         // nop
 352                         break;
 353                     default:
 354                         g_crr_state.layer.apps.state = gStmLayoutNoMf;
 355                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 356                         break;
 357                     }
 358                     break;
 359                 case STM_ARA_NO_NORMAL:
 360                     // Apps layer
 361                     switch (apps_state) {
 362                     case gStmLayoutNoM1:
 363                         // nop
 364                         break;
 365                     case gStmLayoutNoS1:
 366                         g_crr_state.layer.apps.state = gStmLayoutNoM2;
 367                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 368                         break;
 369                     default:
 370                         g_crr_state.layer.apps.state = gStmLayoutNoM1;
 371                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 372                     }
 373                     break;
 374                 case STM_ARA_NO_SPLIT_MAIN:
 375                     // Apps layer
 376                     switch (apps_state) {
 377                     case gStmLayoutNoS1:
 378                     case gStmLayoutNoS2:
 379                         g_crr_state.layer.apps.state = gStmLayoutNoS2;
 380                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 381                         break;
 382                     default:
 383                         // nop
 384                         break;
 385                     }
 386                     break;
 387                 }
 388                 break;
 389             case STM_CTG_NO_GENERAL:
 390                 switch (area_no) {
 391                 case STM_ARA_NO_NORMAL:
 392                     // Apps layer
 393                     switch (apps_state) {
 394                     case gStmLayoutNoMf:
 395                         // nop
 396                         break;
 397                     default:
 398                         g_crr_state.layer.apps.state = gStmLayoutNoG;
 399                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 400                         break;
 401                     }
 402                     break;
 403                 default:
 404                     // nop
 405                     break;
 406                 }
 407                 break;
 408             case STM_CTG_NO_SPLITABLE:
 409                 switch (area_no) {
 410                 case STM_ARA_NO_NORMAL:
 411                     // Apps layer
 412                     switch (apps_state) {
 413                     case gStmLayoutNoM1:
 414                         g_crr_state.layer.apps.state = gStmLayoutNoM2;
 415                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 416                         break;
 417                     case gStmLayoutNoMf:
 418                     case gStmLayoutNoS1:
 419                         // nop
 420                         break;
 421                     default:
 422                         g_crr_state.layer.apps.state = gStmLayoutNoS1;
 423                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 424                         break;
 425                     }
 426                     break;
 427                 case STM_ARA_NO_SPLIT_MAIN:
 428                     // Apps layer
 429                     switch (apps_state) {
 430                     case gStmLayoutNoS1:
 431                         g_crr_state.layer.apps.state = gStmLayoutNoS2;
 432                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 433                         break;
 434                     case gStmLayoutNoS2:
 435                         g_crr_state.layer.apps.state = gStmLayoutNoS2;
 436                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 437                         break;
 438                     default:
 439                         // nop
 440                         break;
 441                     }
 442                     break;
 443                 case STM_ARA_NO_SPLIT_SUB:
 444                     // Apps layer
 445                     switch (apps_state) {
 446                     case gStmLayoutNoM1:
 447                         g_crr_state.layer.apps.state = gStmLayoutNoM2;
 448                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 449                         break;
 450                     case gStmLayoutNoM2:
 451                         g_crr_state.layer.apps.state = gStmLayoutNoM2;
 452                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 453                         break;
 454                     case gStmLayoutNoS1:
 455                         g_crr_state.layer.apps.state = gStmLayoutNoS2;
 456                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 457                         break;
 458                     case gStmLayoutNoS2:
 459                         g_crr_state.layer.apps.state = gStmLayoutNoS2;
 460                         g_crr_state.layer.apps.is_changed = STM_TRUE;
 461                         break;
 462                     default:
 463                         // nop
 464                         break;
 465                     }
 466                     break;
 467                 default:
 468                     // nop
 469                     break;
 470                 }
 471                 break;
 472             default:
 473                 // nop
 474                 break;
 475             }
 476             break;
 477         }
 478     case STM_EVT_NO_DEACTIVATE:
 479         switch (category_no) {
 480         default:
 481             // nop
 482             break;
 483         }
 484         break;
 485     default:
 486         // nop
 487         break;
 488     }
 489
 490
 491     // Set restriction layer
 492     if (STM_CTG_NO_RESTRICTION == category_no) {
 493         if (STM_EVT_NO_ACTIVATE == event_no) {
 494             if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 495                 switch (area_no) {
 496                 case STM_ARA_NO_RESTRICTION_NORMAL:
 497                     switch (restriction_state) {
 498                     case gStmLayoutNoNone:
 499                         if (g_crr_state.layer.apps.state == gStmLayoutNoS1) {
 500                             g_crr_state.layer.restriction.state = gStmLayoutNoRestriction;
 501                             g_crr_state.layer.restriction.is_changed = STM_TRUE;
 502                         }
 503                         break;
 504                     default:
 505                         // nop
 506                         break;
 507                     }
 508                     break;
 509                 case STM_ARA_NO_RESTRICTION_SPLIT_MAIN:
 510                     switch (restriction_state) {
 511                     case gStmLayoutNoNone:
 512                         g_crr_state.layer.restriction.state = gStmLayoutNoRestrictionSplitMain;
 513                         g_crr_state.layer.restriction.is_changed = STM_TRUE;
 514                         break;
 515                     default:
 516                         // nop
 517                         break;
 518                     }
 519                     break;
 520                 case STM_ARA_NO_RESTRICTION_SPLIT_SUB:
 521                     switch (restriction_state) {
 522                     case gStmLayoutNoNone:
 523                         if (g_crr_state.layer.apps.state == gStmLayoutNoM2) {
 524                             g_crr_state.layer.restriction.state = gStmLayoutNoRestrictionSplitSub;
 525                             g_crr_state.layer.restriction.is_changed = STM_TRUE;
 526                         }
 527                         break;
 528                     default:
 529                         // nop
 530                         break;
 531                     }
 532                     break;
 533                 default:
 534                     // nop
 535                     break;
 536                 }
 537             }
 538         }
 539         else if (STM_EVT_NO_DEACTIVATE == event_no) {
 540             switch (restriction_state) {
 541             case gStmLayoutNoRestriction:
 542             case gStmLayoutNoRestrictionSplitMain:
 543             case gStmLayoutNoRestrictionSplitSub:
 544                 g_crr_state.layer.restriction.state = gStmLayoutNoNone;
 545                 g_crr_state.layer.restriction.is_changed = STM_TRUE;
 546                 break;
 547             default:
 548                 // nop
 549                 break;
 550             }
 551         }
 552     }
 553     else if (g_crr_state.layer.apps.is_changed) {
 554         if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
 555             if (gStmLayoutNoM2 == g_crr_state.layer.apps.state) {
 556                 g_crr_state.layer.restriction.state = gStmLayoutNoRestrictionSplitSub;
 557                 g_crr_state.layer.restriction.is_changed = STM_TRUE;
 558             }
 559             else if (gStmLayoutNoS1 == g_crr_state.layer.apps.state) {
 560                 g_crr_state.layer.restriction.state = gStmLayoutNoRestriction;
 561                 g_crr_state.layer.restriction.is_changed = STM_TRUE;
 562             }
 563             else {
 564                 if (gStmLayoutNoNone != g_crr_state.layer.restriction.state) {
 565                     g_crr_state.layer.restriction.state = gStmLayoutNoNone;
 566                     g_crr_state.layer.restriction.is_changed = STM_TRUE;
 567                 }
 568             }
 569         }
 570         else {
 571             if (gStmLayoutNoNone != g_crr_state.layer.restriction.state) {
 572                 g_crr_state.layer.restriction.state = gStmLayoutNoNone;
 573                 g_crr_state.layer.restriction.is_changed = STM_TRUE;
 574             }
 575         }
 576     }
 577
 578     // Copy current state for return
 579     memcpy(state, &g_crr_state, sizeof(g_crr_state));
 580
 581     if ((STM_FALSE == g_map_is_activated)
 582         && (STM_TRUE == g_crr_state.layer.apps.is_changed)
 583         && ((gStmLayoutNoM1 == g_crr_state.layer.apps.state)
 584             || (gStmLayoutNoM2 == g_crr_state.layer.apps.state)
 585             || (gStmLayoutNoMf == g_crr_state.layer.apps.state))) {
 586         g_map_is_activated = STM_TRUE;
 587     }
 588
 589     return 0;
 590 }