gdb/testsuite/gdb.base/exprs.exp

   1 #   Copyright (C) 1988, 1990, 1991, 1992, 1994 Free Software Foundation, Inc.
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 2 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program; if not, write to the Free Software
  15 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  16
  17 # Please email any bugs, comments, and/or additions to this file to:
  18 # bug-gdb@prep.ai.mit.edu
  19
  20 # This file was written by Rob Savoye. (rob@cygnus.com)
  21
  22 if $tracelevel then {
  23         strace $tracelevel
  24         }
  25
  26 #
  27 # test running programs
  28 #
  29 set prms_id 0
  30 set bug_id 0
  31
  32 set testfile "exprs"
  33 set srcfile ${srcdir}/$subdir/${testfile}.c
  34 set binfile ${objdir}/${subdir}/${testfile}
  35 if  { [compile "${srcfile} -g -o ${binfile}"] != "" } {
  36     perror "Couldn't compile ${srcfile}"
  37     return -1
  38 }
  39
  40 execute_anywhere "rm -f ${binfile}.ci"
  41 if  { [compile "-E ${srcdir}/${subdir}/compiler.c > ${binfile}.ci"] != "" } {
  42     perror "Couldn't make ${testfile}.ci file"
  43     return -1
  44 }
  45
  46 gdb_exit
  47 gdb_start
  48 gdb_reinitialize_dir $srcdir/$subdir
  49 gdb_load ${binfile}
  50
  51 source ${binfile}.ci
  52
  53 #
  54 # set it up at a breakpoint so we can play with the variable values
  55 #
  56
  57 if ![runto_main] then {
  58     perror "couldn't run to breakpoint"
  59     continue
  60 }
  61
  62 #
  63 # test expressions with "char" types
  64 #
  65 send "set variable v_char=127\n"
  66 expect {
  67     -re "set.*$prompt $" {
  68         send "print v_char == 0\n"
  69         expect {
  70             -re "print.*.\[0-9\]* = 0.*$prompt $" {
  71                 send "print v_char == 127\n"
  72                 expect {
  73                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print char ==" }
  74                     -re "$prompt $"                      { fail "print char ==" }
  75                     timeout                              { fail "(timeout) print char ==" }
  76                 }
  77             }
  78             -re "$prompt $"                      { fail "print char ==" }
  79             timeout                              { fail "(timeout) print char ==" }
  80         }
  81     }
  82     -re "$prompt $"                              { fail "print char ==" }
  83     timeout                                      { fail "(timeout) print char ==" }
  84 }
  85
  86
  87 send "set variable v_char=127\n"
  88 expect {
  89     -re "set.*$prompt $" {
  90         send "print v_char != 0\n"
  91         expect {
  92             -re "print.*.\[0-9\]* = 1.*$prompt $" {
  93                 send "print v_char != 127\n"
  94                 expect {
  95                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print char !=" }
  96                     -re "$prompt $"                      { fail "print char !=" }
  97                     timeout                              { fail "(timeout) print char !=" }
  98                 }
  99             }
 100             -re "$prompt $"                      { fail "print char !=" }
 101             timeout                              { fail "(timeout) print char !=" }
 102         }
 103     }
 104     -re "$prompt $"                              { fail "print char !=" }
 105     timeout                                      { fail "(timeout) print char !=" }
 106 }
 107
 108
 109 send "set variable v_char=127\n"
 110 expect {
 111     -re "set.*$prompt $" {
 112         send "print v_char < 0\n"
 113         expect {
 114             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 115                 send "print v_char < 127\n"
 116                 expect {
 117                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print char <" }
 118                     -re "$prompt $"                      { fail "print char <" }
 119                     timeout                              { fail "(timeout) print char <" }
 120                 }
 121             }
 122             -re "$prompt $"                      { fail "print char <" }
 123             timeout                              { fail "(timeout) print char <" }
 124         }
 125     }
 126     -re "$prompt $"                              { fail "print char <" }
 127     timeout                                      { fail "(timeout) print char <" }
 128 }
 129
 130
 131 send "set variable v_char=127\n"
 132 expect {
 133     -re "set.*$prompt $" {
 134         send "print v_char > 0\n"
 135         expect {
 136             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 137                 send "print v_char > 127\n"
 138                 expect {
 139                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print char >" }
 140                     -re "$prompt $"                      { fail "print char >" }
 141                     timeout                              { fail "(timeout) print char >" }
 142                 }
 143             }
 144             -re "$prompt $"                      { fail "print char >" }
 145             timeout                              { fail "(timeout) print char >" }
 146         }
 147     }
 148     -re "$prompt $"                              { fail "print char >" }
 149     timeout                                      { fail "(timeout) print char >" }
 150 }
 151
 152
 153 #
 154 # test expressions with "signed char" types
 155 #
 156 send "set variable v_signed_char=127\n"
 157 expect {
 158     -re "set.*$prompt $" {
 159         send "print v_signed_char == 0\n"
 160         expect {
 161             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 162                 send "print v_signed_char == 127\n"
 163                 expect {
 164                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed char ==" }
 165                     -re "$prompt $"                      { fail "print signed char ==" }
 166                     timeout                              { fail "(timeout) print signed char ==" }
 167                 }
 168             }
 169             -re "$prompt $"                      { fail "print signed char ==" }
 170             timeout                              { fail "(timeout) print signed char ==" }
 171         }
 172     }
 173     -re "$prompt $"                              { fail "print signed char ==" }
 174     timeout                                      { fail "(timeout) print signed char ==" }
 175 }
 176
 177
 178 send "set variable v_signed_char=127\n"
 179 expect {
 180     -re "set.*$prompt $" {
 181         send "print v_signed_char != 0\n"
 182         expect {
 183             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 184                 send "print v_signed_char != 127\n"
 185                 expect {
 186                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed char !=" }
 187                     -re "$prompt $"                      { fail "print signed char !=" }
 188                     timeout                              { fail "(timeout) print signed char !=" }
 189                 }
 190             }
 191             -re "$prompt $"                      { fail "print signed char !=" }
 192             timeout                              { fail "(timeout) print signed char !=" }
 193         }
 194     }
 195     -re "$prompt $"                              { fail "print signed char !=" }
 196     timeout                                      { fail "(timeout) print signed char !=" }
 197 }
 198
 199
 200 send "set variable v_signed_char=127\n"
 201 expect {
 202     -re "set.*$prompt $" {
 203         send "print v_signed_char < 0\n"
 204         expect {
 205             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 206                 send "print v_signed_char < 127\n"
 207                 expect {
 208                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed char <" }
 209                     -re "$prompt $"                      { fail "print signed char <" }
 210                     timeout                              { fail "(timeout) print signed char <" }
 211                 }
 212             }
 213             -re "$prompt $"                      { fail "print signed char <" }
 214             timeout                              { fail "(timeout) print signed char <" }
 215         }
 216     }
 217     -re "$prompt $"                              { fail "print signed char <" }
 218     timeout                                      { fail "(timeout) print signed char <" }
 219 }
 220
 221
 222 send "set variable v_signed_char=127\n"
 223 expect {
 224     -re "set.*$prompt $" {
 225         send "print v_signed_char > 0\n"
 226         expect {
 227             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 228                 send "print v_signed_char > 127\n"
 229                 expect {
 230                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed char >" }
 231                     -re "$prompt $"                      { fail "print signed char >" }
 232                     timeout                              { fail "(timeout) print signed char >" }
 233                 }
 234             }
 235             -re "$prompt $"                      { fail "print signed char >" }
 236             timeout                              { fail "(timeout) print signed char >" }
 237         }
 238     }
 239     -re "$prompt $"                              { fail "print signed char >" }
 240     timeout                                      { fail "(timeout) print signed char >" }
 241 }
 242
 243
 244 # make char a minus
 245 if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix4*" }
 246 send "set variable v_signed_char=-1\n"
 247 expect {
 248     -re "set.*$prompt $" {
 249         send "print v_signed_char == 0\n"
 250         expect {
 251             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 252                 send "print v_signed_char == -1\n"
 253                 expect {
 254                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed char == (minus)" }
 255                     -re "$prompt $"                      { fail "print signed char == (minus)" }
 256                     timeout                              { fail "(timeout) print signed char == (minus)" }
 257                 }
 258             }
 259             -re "$prompt $"                      { fail "print signed char == (minus)" }
 260             timeout                              { fail "(timeout) print signed char == (minus)" }
 261         }
 262     }
 263     -re "$prompt $"                              { fail "print signed char == (minus)" }
 264     timeout                                      { fail "(timeout) print signed char == (minus)" }
 265 }
 266
 267
 268 if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix4*" }
 269 send "set variable v_signed_char=-1\n"
 270 expect {
 271     -re "set.*$prompt $" {
 272         send "print v_signed_char != 0\n"
 273         expect {
 274             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 275                 send "print v_signed_char != -1\n"
 276                 expect {
 277                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed char != (minus)" }
 278                     -re "$prompt $"                      { fail "print signed char != (minus)" }
 279                     timeout                              { fail "(timeout) print signed char != (minus)" }
 280                 }
 281             }
 282             -re "$prompt $"                      { fail "print signed char != (minus)" }
 283             timeout                              { fail "(timeout) print signed char != (minus)" }
 284         }
 285     }
 286     -re "$prompt $"                              { fail "print signed char != (minus)" }
 287     timeout                                      { fail "(timeout) print signed char != (minus)" }
 288 }
 289
 290
 291 if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix4*" }
 292 send "set variable v_signed_char=-1\n"
 293 expect {
 294     -re "set.*$prompt $" {
 295         send "print v_signed_char < 0\n"
 296         expect {
 297             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 298                 send "print v_signed_char < 127\n"
 299                 expect {
 300                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed char < (minus)" }
 301                     -re "$prompt $"                      { fail "print signed char < (minus)" }
 302                     timeout                              { fail "(timeout) print signed char < (minus)" }
 303                 }
 304             }
 305             -re "$prompt $"                      { fail "print signed char < (minus)" }
 306             timeout                              { fail "(timeout) print signed char < (minus)" }
 307         }
 308     }
 309     -re "$prompt $"                              { fail "print signed char < (minus)" }
 310     timeout                                      { fail "(timeout) print signed char < (minus)" }
 311 }
 312
 313 if {!$gcc_compiled} then { setup_xfail "mips-sgi-irix4*" }
 314 send "set variable v_signed_char=-1\n"
 315 expect {
 316     -re "set.*$prompt $" {
 317         send "print v_signed_char > 0\n"
 318         expect {
 319             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 320                 send "print v_signed_char > 127\n"
 321                 expect {
 322                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed char > (minus)" }
 323                     -re "$prompt $"                      { fail "print signed char > (minus)" }
 324                     timeout                              { fail "(timeout) print signed char > (minus)" }
 325                 }
 326             }
 327             -re "$prompt $"                      { fail "print signed char > (minus)" }
 328             timeout                              { fail "(timeout) print signed char > (minus)" }
 329         }
 330     }
 331     -re "$prompt $"                              { fail "print signed char > (minus)" }
 332     timeout                                      { fail "(timeout) print signed char > (minus)" }
 333 }
 334
 335
 336 #
 337 # test expressions with "unsigned char" types
 338 #
 339 send "set variable v_unsigned_char=127\n"
 340 expect {
 341     -re "set.*$prompt $" {
 342         send "print v_unsigned_char == 0\n"
 343         expect {
 344             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 345                 send "print v_unsigned_char == 127\n"
 346                 expect {
 347                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned char ==" }
 348                     -re "$prompt $"                      { fail "print unsigned char ==" }
 349                     timeout                              { fail "(timeout) print unsigned char ==" }
 350                 }
 351             }
 352             -re "$prompt $"                      { fail "print unsigned char ==" }
 353             timeout                              { fail "(timeout) print unsigned char ==" }
 354         }
 355     }
 356     -re "$prompt $"                              { fail "print unsigned char ==" }
 357     timeout                                      { fail "(timeout) print unsigned char ==" }
 358 }
 359
 360
 361 send "set variable v_unsigned_char=127\n"
 362 expect {
 363     -re "set.*$prompt $" {
 364         send "print v_unsigned_char != 0\n"
 365         expect {
 366             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 367                 send "print v_unsigned_char != 127\n"
 368                 expect {
 369                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned char !=" }
 370                     -re "$prompt $"                      { fail "print unsigned char !=" }
 371                     timeout                              { fail "(timeout) print unsigned char !=" }
 372                 }
 373             }
 374             -re "$prompt $"                      { fail "print unsigned char !=" }
 375             timeout                              { fail "(timeout) print unsigned char !=" }
 376         }
 377     }
 378     -re "$prompt $"                              { fail "print unsigned char !=" }
 379     timeout                                      { fail "(timeout) print unsigned char !=" }
 380 }
 381
 382
 383 send "set variable v_unsigned_char=127\n"
 384 expect {
 385     -re "set.*$prompt $" {
 386         send "print v_unsigned_char < 0\n"
 387         expect {
 388             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 389                 send "print v_unsigned_char < 127\n"
 390                 expect {
 391                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned char <" }
 392                     -re "$prompt $"                      { fail "print unsigned char <" }
 393                     timeout                              { fail "(timeout) print unsigned char <" }
 394                 }
 395             }
 396             -re "$prompt $"                      { fail "print unsigned char <" }
 397             timeout                              { fail "(timeout) print unsigned char <" }
 398         }
 399     }
 400     -re "$prompt $"                              { fail "print unsigned char <" }
 401     timeout                                      { fail "(timeout) print unsigned char <" }
 402 }
 403
 404
 405 send "set variable v_unsigned_char=127\n"
 406 expect {
 407     -re "set.*$prompt $" {
 408         send "print v_unsigned_char > 0\n"
 409         expect {
 410             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 411                 send "print v_unsigned_char > 127\n"
 412                 expect {
 413                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned char >" }
 414                     -re "$prompt $"                      { fail "print unsigned char >" }
 415                     timeout                              { fail "(timeout) print unsigned char >" }
 416                 }
 417             }
 418             -re "$prompt $"                      { fail "print unsigned char >" }
 419             timeout                              { fail "(timeout) print unsigned char >" }
 420         }
 421     }
 422     -re "$prompt $"                              { fail "print unsigned char >" }
 423     timeout                                      { fail "(timeout) print unsigned char >" }
 424 }
 425
 426
 427 # make char a minus
 428 # FIXME:  gdb mishandles the cast (unsigned char) on the i960, so I've
 429 # set up an expected failure for this case.
 430 send "set variable v_unsigned_char=~0\n"
 431 expect {
 432     -re "set.*$prompt $" {
 433         send "print v_unsigned_char == 0\n"
 434         expect {
 435             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 436                 send "print v_unsigned_char == ~0\n"
 437                 expect {
 438                     -re "print.*.\[0-9\]* = 0.*$prompt $" {
 439                         setup_xfail "i960-*-*" 1821
 440                         send "print v_unsigned_char == (unsigned char)~0\n"
 441                         expect {
 442                             -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned char == (~0)" }
 443                             -re "$prompt $"                      { fail "print unsigned char == (~0)" }
 444                             timeout                              { fail "(timeout) print unsigned char == (~0)" }
 445                         }
 446                     }
 447                     -re "$prompt $"                      { fail "print unsigned char == (~0)" }
 448                     timeout                              { fail "(timeout) print unsigned char == (~0)" }
 449                 }
 450             }
 451             -re "$prompt $"                      { fail "print unsigned char == (~0)" }
 452             timeout                              { fail "(timeout) print unsigned char == (~0)" }
 453         }
 454     }
 455     -re "$prompt $"                              { fail "print unsigned char == (~0)" }
 456     timeout                                      { fail "(timeout) print unsigned char == (~0)" }
 457 }
 458
 459
 460 # FIXME:  gdb mishandles the cast (unsigned char) on the i960, so I've
 461 # set up an expected failure for this case.
 462 send "set variable v_unsigned_char=~0\n"
 463 expect {
 464     -re "set.*$prompt $" {
 465         send "print v_unsigned_char != 0\n"
 466         expect {
 467             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 468                 setup_xfail "i960-*-*" 1821
 469                 send "print v_unsigned_char != (unsigned char)~0\n"
 470                 expect {
 471                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned char != (~0)" }
 472                     -re "$prompt $"                      { fail "print unsigned char != (~0)" }
 473                     timeout                              { fail "(timeout) print unsigned char != (~0)" }
 474                 }
 475             }
 476             -re "$prompt $"                      { fail "print unsigned char != (~0)" }
 477             timeout                              { fail "(timeout) print unsigned char != (~0)" }
 478         }
 479     }
 480     -re "$prompt $"                              { fail "print unsigned char != (~0)" }
 481     timeout                                      { fail "(timeout) print unsigned char != (~0)" }
 482 }
 483
 484
 485 send "set variable v_unsigned_char=~0\n"
 486 expect {
 487     -re "set.*$prompt $" {
 488         send "print v_unsigned_char < 0\n"
 489         expect {
 490             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 491                 send "print v_unsigned_char < 127\n"
 492                 expect {
 493                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned char < (~0)" }
 494                     -re "$prompt $"                      { fail "print unsigned char < (~0)" }
 495                     timeout                              { fail "(timeout) print unsigned char < (~0)" }
 496                 }
 497             }
 498             -re "$prompt $"                      { fail "print unsigned char < (~0)" }
 499             timeout                              { fail "(timeout) print unsigned char < (~0)" }
 500         }
 501     }
 502     -re "$prompt $"                              { fail "print unsigned char < (~0)" }
 503     timeout                                      { fail "(timeout) print unsigned char < (~0)" }
 504 }
 505
 506
 507 send "set variable v_unsigned_char=~0\n"
 508 expect {
 509     -re "set.*$prompt $" {
 510         send "print v_unsigned_char > 0\n"
 511         expect {
 512             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 513                 send "print v_unsigned_char > 127\n"
 514                 expect {
 515                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned char > (~0)" }
 516                     -re "$prompt $"                      { fail "print unsigned char > (~0)" }
 517                     timeout                              { fail "(timeout) print unsigned char > (~0)" }
 518                 }
 519             }
 520             -re "$prompt $"                      { fail "print unsigned char > (~0)" }
 521             timeout                              { fail "(timeout) print unsigned char > (~0)" }
 522         }
 523     }
 524     -re "$prompt $"                              { fail "print unsigned char > (~0)" }
 525     timeout                                      { fail "(timeout) print unsigned char > (~0)" }
 526 }
 527
 528
 529 #
 530 # test expressions with "short" types
 531 #
 532 send "set variable v_short=0x7FFF\n"
 533 expect {
 534     -re "set.*$prompt $" {
 535         send "print v_short == 0\n"
 536         expect {
 537             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 538                 send "print v_short == 0x7FFF\n"
 539                 expect {
 540                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed short ==" }
 541                     -re "$prompt $"                      { fail "print signed short ==" }
 542                     timeout                              { fail "(timeout) print signed short ==" }
 543                 }
 544             }
 545             -re "$prompt $"                      { fail "print signed short ==" }
 546             timeout                              { fail "(timeout) print signed short ==" }
 547         }
 548     }
 549     -re "$prompt $"                              { fail "print signed short ==" }
 550     timeout                                      { fail "(timeout) print signed short ==" }
 551 }
 552
 553
 554 send "set variable v_short=0x7FFF\n"
 555 expect {
 556     -re "set.*$prompt $" {
 557         send "print v_short != 0\n"
 558         expect {
 559             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 560                 send "print v_short != 0x7FFF\n"
 561                 expect {
 562                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed short !=" }
 563                     -re "$prompt $"                      { fail "print signed short !=" }
 564                     timeout                              { fail "(timeout) print signed short !=" }
 565                 }
 566             }
 567             -re "$prompt $"                      { fail "print signed short !=" }
 568             timeout                              { fail "(timeout) print signed short !=" }
 569         }
 570     }
 571     -re "$prompt $"                              { fail "print signed short !=" }
 572     timeout                                      { fail "(timeout) print signed short !=" }
 573 }
 574
 575
 576 send "set variable v_short=0x7FFF\n"
 577 expect {
 578     -re "set.*$prompt $" {
 579         send "print v_short < 0\n"
 580         expect {
 581             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 582                 send "print v_short < 0x7FFF\n"
 583                 expect {
 584                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed short <" }
 585                     -re "$prompt $"                      { fail "print signed short <" }
 586                     timeout                              { fail "(timeout) print signed short <" }
 587                 }
 588             }
 589             -re "$prompt $"                      { fail "print signed short <" }
 590             timeout                              { fail "(timeout) print signed short <" }
 591         }
 592     }
 593     -re "$prompt $"                              { fail "print signed short <" }
 594     timeout                                      { fail "(timeout) print signed short <" }
 595 }
 596
 597
 598 send "set variable v_short=0x7FFF\n"
 599 expect {
 600     -re "set.*$prompt $" {
 601         send "print v_short > 0\n"
 602         expect {
 603             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 604                 send "print v_short > 0x7FFF\n"
 605                 expect {
 606                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed short >" }
 607                     -re "$prompt $"                      { fail "print signed short >" }
 608                     timeout                              { fail "(timeout) print signed short >" }
 609                 }
 610             }
 611             -re "$prompt $"                      { fail "print signed short >" }
 612             timeout                              { fail "(timeout) print signed short >" }
 613         }
 614     }
 615     -re "$prompt $"                              { fail "print signed short >" }
 616     timeout                                      { fail "(timeout) print signed short >" }
 617 }
 618
 619
 620 # make short a minus
 621 send "set variable v_short=-1\n"
 622 expect {
 623     -re "set.*$prompt $" {
 624         send "print v_short == 0\n"
 625         expect {
 626             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 627                 send "print v_short == -1\n"
 628                 expect {
 629                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed short == (minus)" }
 630                     -re "$prompt $"                      { fail "print signed short == (minus)" }
 631                     timeout                              { fail "(timeout) print signed short == (minus)" }
 632                 }
 633             }
 634             -re "$prompt $"                      { fail "print signed short == (minus)" }
 635             timeout                              { fail "(timeout) print signed short == (minus)" }
 636         }
 637     }
 638     -re "$prompt $"                              { fail "print signed short == (minus)" }
 639     timeout                                      { fail "(timeout) print signed short == (minus)" }
 640 }
 641
 642
 643 send "set variable v_short=-1\n"
 644 expect {
 645     -re "set.*$prompt $" {
 646         send "print v_short != 0\n"
 647         expect {
 648             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 649                 send "print v_short != -1\n"
 650                 expect {
 651                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed short != (minus)" }
 652                     -re "$prompt $"                      { fail "print signed short != (minus)" }
 653                     timeout                              { fail "(timeout) print signed short != (minus)" }
 654                 }
 655             }
 656             -re "$prompt $"                      { fail "print signed short != (minus)" }
 657             timeout                              { fail "(timeout) print signed short != (minus)" }
 658         }
 659     }
 660     -re "$prompt $"                              { fail "print signed short != (minus)" }
 661     timeout                                      { fail "(timeout) print signed short != (minus)" }
 662 }
 663
 664
 665 send "set variable v_short=-1\n"
 666 expect {
 667     -re "set.*$prompt $" {
 668         send "print v_short < 0\n"
 669         expect {
 670             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 671                 send "print v_short < 0x7FFF\n"
 672                 expect {
 673                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed short < (minus)" }
 674                     -re "$prompt $"                      { fail "print signed short < (minus)" }
 675                     timeout                              { fail "(timeout) print signed short < (minus)" }
 676                 }
 677             }
 678             -re "$prompt $"                      { fail "print signed short < (minus)" }
 679             timeout                              { fail "(timeout) print signed short < (minus)" }
 680         }
 681     }
 682     -re "$prompt $"                              { fail "print signed short < (minus)" }
 683     timeout                                      { fail "(timeout) print signed short < (minus)" }
 684 }
 685
 686
 687 send "set variable v_short=-1\n"
 688 expect {
 689     -re "set.*$prompt $" {
 690         send "print v_short > 0\n"
 691         expect {
 692             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 693                 send "print v_short > 0x7FFF\n"
 694                 expect {
 695                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed short > (minus)" }
 696                     -re "$prompt $"                      { fail "print signed short > (minus)" }
 697                     timeout                              { fail "(timeout) print signed short > (minus)" }
 698                 }
 699             }
 700             -re "$prompt $"                      { fail "print signed short > (minus)" }
 701             timeout                              { fail "(timeout) print signed short > (minus)" }
 702         }
 703     }
 704     -re "$prompt $"                              { fail "print signed short > (minus)" }
 705     timeout                                      { fail "(timeout) print signed short > (minus)" }
 706 }
 707
 708
 709 #
 710 # test expressions with "signed short" types
 711 #
 712 send "set variable v_signed_short=0x7FFF\n"
 713 expect {
 714     -re "set.*$prompt $" {
 715         send "print v_signed_short == 0\n"
 716         expect {
 717             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 718                 send "print v_signed_short == 0x7FFF\n"
 719                 expect {
 720                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed short ==" }
 721                     -re "$prompt $"                      { fail "print signed signed short ==" }
 722                     timeout                              { fail "(timeout) print signed signed short ==" }
 723                 }
 724             }
 725             -re "$prompt $"                      { fail "print signed signed short ==" }
 726             timeout                              { fail "(timeout) print signed signed short ==" }
 727         }
 728     }
 729     -re "$prompt $"                              { fail "print signed signed short ==" }
 730     timeout                                      { fail "(timeout) print signed signed short ==" }
 731 }
 732
 733
 734 send "set variable v_signed_short=0x7FFF\n"
 735 expect {
 736     -re "set.*$prompt $" {
 737         send "print v_signed_short != 0\n"
 738         expect {
 739             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 740                 send "print v_signed_short != 0x7FFF\n"
 741                 expect {
 742                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed short !=" }
 743                     -re "$prompt $"                      { fail "print signed signed short !=" }
 744                     timeout                              { fail "(timeout) print signed signed short !=" }
 745                 }
 746             }
 747             -re "$prompt $"                      { fail "print signed signed short !=" }
 748             timeout                              { fail "(timeout) print signed signed short !=" }
 749         }
 750     }
 751     -re "$prompt $"                              { fail "print signed signed short !=" }
 752     timeout                                      { fail "(timeout) print signed signed short !=" }
 753 }
 754
 755
 756 send "set variable v_signed_short=0x7FFF\n"
 757 expect {
 758     -re "set.*$prompt $" {
 759         send "print v_signed_short < 0\n"
 760         expect {
 761             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 762                 send "print v_signed_short < 0x7FFF\n"
 763                 expect {
 764                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed short <" }
 765                     -re "$prompt $"                      { fail "print signed signed short <" }
 766                     timeout                              { fail "(timeout) print signed signed short <" }
 767                 }
 768             }
 769             -re "$prompt $"                      { fail "print signed signed short <" }
 770             timeout                              { fail "(timeout) print signed signed short <" }
 771         }
 772     }
 773     -re "$prompt $"                              { fail "print signed signed short <" }
 774     timeout                                      { fail "(timeout) print signed signed short <" }
 775 }
 776
 777
 778 send "set variable v_signed_short=0x7FFF\n"
 779 expect {
 780     -re "set.*$prompt $" {
 781         send "print v_signed_short > 0\n"
 782         expect {
 783             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 784                 send "print v_signed_short > 0x7FFF\n"
 785                 expect {
 786                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed short >" }
 787                     -re "$prompt $"                      { fail "print signed signed short >" }
 788                     timeout                              { fail "(timeout) print signed signed short >" }
 789                 }
 790             }
 791             -re "$prompt $"                      { fail "print signed signed short >" }
 792             timeout                              { fail "(timeout) print signed signed short >" }
 793         }
 794     }
 795     -re "$prompt $"                              { fail "print signed signed short >" }
 796     timeout                                      { fail "(timeout) print signed signed short >" }
 797 }
 798
 799
 800 # make short a minus
 801 send "set variable v_signed_short=-1\n"
 802 expect {
 803     -re "set.*$prompt $" {
 804         send "print v_signed_short == 0\n"
 805         expect {
 806             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 807                 send "print v_signed_short == -1\n"
 808                 expect {
 809                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed short == (minus)" }
 810                     -re "$prompt $"                      { fail "print signed signed short == (minus)" }
 811                     timeout                              { fail "(timeout) print signed signed short == (minus)" }
 812                 }
 813             }
 814             -re "$prompt $"                      { fail "print signed signed short == (minus)" }
 815             timeout                              { fail "(timeout) print signed signed short == (minus)" }
 816         }
 817     }
 818     -re "$prompt $"                              { fail "print signed signed short == (minus)" }
 819     timeout                                      { fail "(timeout) print signed signed short == (minus)" }
 820 }
 821
 822
 823 send "set variable v_signed_short=-1\n"
 824 expect {
 825     -re "set.*$prompt $" {
 826         send "print v_signed_short != 0\n"
 827         expect {
 828             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 829                 send "print v_signed_short != -1\n"
 830                 expect {
 831                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed short != (minus)" }
 832                     -re "$prompt $"                      { fail "print signed signed short != (minus)" }
 833                     timeout                              { fail "(timeout) print signed signed short != (minus)" }
 834                 }
 835             }
 836             -re "$prompt $"                      { fail "print signed signed short != (minus)" }
 837             timeout                              { fail "(timeout) print signed signed short != (minus)" }
 838         }
 839     }
 840     -re "$prompt $"                              { fail "print signed signed short != (minus)" }
 841     timeout                                      { fail "(timeout) print signed signed short != (minus)" }
 842 }
 843
 844
 845 send "set variable v_signed_short=-1\n"
 846 expect {
 847     -re "set.*$prompt $" {
 848         send "print v_signed_short < 0\n"
 849         expect {
 850             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 851                 send "print v_signed_short < 0x7FFF\n"
 852                 expect {
 853                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed short < (minus)" }
 854                     -re "$prompt $"                      { fail "print signed signed short < (minus)" }
 855                     timeout                              { fail "(timeout) print signed signed short < (minus)" }
 856                 }
 857             }
 858             -re "$prompt $"                      { fail "print signed signed short < (minus)" }
 859             timeout                              { fail "(timeout) print signed signed short < (minus)" }
 860         }
 861     }
 862     -re "$prompt $"                              { fail "print signed signed short < (minus)" }
 863     timeout                                      { fail "(timeout) print signed signed short < (minus)" }
 864 }
 865
 866
 867 send "set variable v_signed_short=-1\n"
 868 expect {
 869     -re "set.*$prompt $" {
 870         send "print v_signed_short > 0\n"
 871         expect {
 872             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 873                 send "print v_signed_short > 0x7FFF\n"
 874                 expect {
 875                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed short > (minus)" }
 876                     -re "$prompt $"                      { fail "print signed signed short > (minus)" }
 877                     timeout                              { fail "(timeout) print signed signed short > (minus)" }
 878                 }
 879             }
 880             -re "$prompt $"                      { fail "print signed signed short > (minus)" }
 881             timeout                              { fail "(timeout) print signed signed short > (minus)" }
 882         }
 883     }
 884     -re "$prompt $"                              { fail "print signed signed short > (minus)" }
 885     timeout                                      { fail "(timeout) print signed signed short > (minus)" }
 886 }
 887
 888
 889 #
 890 # test expressions with "unsigned short" types
 891 #
 892 send "set variable v_unsigned_short=0x7FFF\n"
 893 expect {
 894     -re "set.*$prompt $" {
 895         send "print v_unsigned_short == 0\n"
 896         expect {
 897             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 898                 send "print v_unsigned_short == 0x7FFF\n"
 899                 expect {
 900                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned short ==" }
 901                     -re "$prompt $"                      { fail "print unsigned short ==" }
 902                     timeout                              { fail "(timeout) print unsigned short ==" }
 903                 }
 904             }
 905             -re "$prompt $"                      { fail "print unsigned short ==" }
 906             timeout                              { fail "(timeout) print unsigned short ==" }
 907         }
 908     }
 909     -re "$prompt $"                              { fail "print unsigned short ==" }
 910     timeout                                      { fail "(timeout) print unsigned short ==" }
 911 }
 912
 913
 914 send "set variable v_unsigned_short=0x7FFF\n"
 915 expect {
 916     -re "set.*$prompt $" {
 917         send "print v_unsigned_short != 0\n"
 918         expect {
 919             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 920                 send "print v_unsigned_short != 0x7FFF\n"
 921                 expect {
 922                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned short !=" }
 923                     -re "$prompt $"                      { fail "print unsigned short !=" }
 924                     timeout                              { fail "(timeout) print unsigned short !=" }
 925                 }
 926             }
 927             -re "$prompt $"                      { fail "print unsigned short !=" }
 928             timeout                              { fail "(timeout) print unsigned short !=" }
 929         }
 930     }
 931     -re "$prompt $"                              { fail "print unsigned short !=" }
 932     timeout                                      { fail "(timeout) print unsigned short !=" }
 933 }
 934
 935
 936 send "set variable v_unsigned_short=0x7FFF\n"
 937 expect {
 938     -re "set.*$prompt $" {
 939         send "print v_unsigned_short < 0\n"
 940         expect {
 941             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 942                 send "print v_unsigned_short < 0x7FFF\n"
 943                 expect {
 944                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned short <" }
 945                     -re "$prompt $"                      { fail "print unsigned short <" }
 946                     timeout                              { fail "(timeout) print unsigned short <" }
 947                 }
 948             }
 949             -re "$prompt $"                      { fail "print unsigned short <" }
 950             timeout                              { fail "(timeout) print unsigned short <" }
 951         }
 952     }
 953     -re "$prompt $"                              { fail "print unsigned short <" }
 954     timeout                                      { fail "(timeout) print unsigned short <" }
 955 }
 956
 957
 958 send "set variable v_unsigned_short=0x7FFF\n"
 959 expect {
 960     -re "set.*$prompt $" {
 961         send "print v_unsigned_short > 0\n"
 962         expect {
 963             -re "print.*.\[0-9\]* = 1.*$prompt $" {
 964                 send "print v_unsigned_short > 0x7FFF\n"
 965                 expect {
 966                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned short >" }
 967                     -re "$prompt $"                      { fail "print unsigned short >" }
 968                     timeout                              { fail "(timeout) print unsigned short >" }
 969                 }
 970             }
 971             -re "$prompt $"                      { fail "print unsigned short >" }
 972             timeout                              { fail "(timeout) print unsigned short >" }
 973         }
 974     }
 975     -re "$prompt $"                              { fail "print unsigned short >" }
 976     timeout                                      { fail "(timeout) print unsigned short >" }
 977 }
 978
 979
 980 # make short a minus
 981 send "set variable v_unsigned_short=~0\n"
 982 expect {
 983     -re "set.*$prompt $" {
 984         send "print v_unsigned_short == 0\n"
 985         expect {
 986             -re "print.*.\[0-9\]* = 0.*$prompt $" {
 987                 send "print v_unsigned_short == ~0\n"
 988                 expect {
 989                     -re "print.*.\[0-9\]* = 0.*$prompt $" {
 990                         send "print v_unsigned_short == (unsigned short)~0\n"
 991                         expect {
 992                             -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned short == (~0)" }
 993                             -re "$prompt $"                      { fail "print unsigned short == (~0)" }
 994                             timeout                              { fail "(timeout) print unsigned short == (~0)" }
 995                         }
 996                     }
 997                     -re "$prompt $"                      { fail "print unsigned short == (~0)" }
 998                     timeout                              { fail "(timeout) print unsigned short == (~0)" }
 999                 }
1000             }
1001             -re "$prompt $"                      { fail "print unsigned short == (~0)" }
1002             timeout                              { fail "(timeout) print unsigned short == (~0)" }
1003         }
1004     }
1005     -re "$prompt $"                              { fail "print unsigned short == (~0)" }
1006     timeout                                      { fail "(timeout) print unsigned short == (~0)" }
1007 }
1008
1009
1010 send "set variable v_unsigned_short=~0\n"
1011 expect {
1012     -re "set.*$prompt $" {
1013         send "print v_unsigned_short != 0\n"
1014         expect {
1015             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1016                 send "print v_unsigned_short != (unsigned short)~0\n"
1017                 expect {
1018                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned short != (~0)" }
1019                     -re "$prompt $"                      { fail "print unsigned short != (~0)" }
1020                     timeout                              { fail "(timeout) print unsigned short != (~0)" }
1021                 }
1022             }
1023             -re "$prompt $"                      { fail "print unsigned short != (~0)" }
1024             timeout                              { fail "(timeout) print unsigned short != (~0)" }
1025         }
1026     }
1027     -re "$prompt $"                              { fail "print unsigned short != (~0)" }
1028     timeout                                      { fail "(timeout) print unsigned short != (~0)" }
1029 }
1030
1031
1032 send "set variable v_unsigned_short=~0\n"
1033 expect {
1034     -re "set.*$prompt $" {
1035         send "print v_unsigned_short < 0\n"
1036         expect {
1037             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1038                 send "print v_unsigned_short < 0x7FFF\n"
1039                 expect {
1040                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned short < (~0)" }
1041                     -re "$prompt $"                      { fail "print unsigned short < (~0)" }
1042                     timeout                              { fail "(timeout) print unsigned short < (~0)" }
1043                 }
1044             }
1045             -re "$prompt $"                      { fail "print unsigned short < (~0)" }
1046             timeout                              { fail "(timeout) print unsigned short < (~0)" }
1047         }
1048     }
1049     -re "$prompt $"                              { fail "print unsigned short < (~0)" }
1050     timeout                                      { fail "(timeout) print unsigned short < (~0)" }
1051 }
1052
1053
1054 send "set variable v_unsigned_short=~0\n"
1055 expect {
1056     -re "set.*$prompt $" {
1057         send "print v_unsigned_short > 0\n"
1058         expect {
1059             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1060                 send "print v_unsigned_short > 0x7FFF\n"
1061                 expect {
1062                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned short > (~0)" }
1063                     -re "$prompt $"                      { fail "print unsigned short > (~0)" }
1064                     timeout                              { fail "(timeout) print unsigned short > (~0)" }
1065                 }
1066             }
1067             -re "$prompt $"                      { fail "print unsigned short > (~0)" }
1068             timeout                              { fail "(timeout) print unsigned short > (~0)" }
1069         }
1070     }
1071     -re "$prompt $"                              { fail "print unsigned short > (~0)" }
1072     timeout                                      { fail "(timeout) print unsigned short > (~0)" }
1073 }
1074
1075
1076 #
1077 # test expressions with "int" types
1078 #
1079 send "set variable v_int=0x7FFF\n"
1080 expect {
1081     -re "set.*$prompt $" {
1082         send "print v_int == 0\n"
1083         expect {
1084             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1085                 send "print v_int == 0x7FFF\n"
1086                 expect {
1087                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed int ==" }
1088                     -re "$prompt $"                      { fail "print signed int ==" }
1089                     timeout                              { fail "(timeout) print signed int ==" }
1090                 }
1091             }
1092             -re "$prompt $"                      { fail "print signed int ==" }
1093             timeout                              { fail "(timeout) print signed int ==" }
1094         }
1095     }
1096     -re "$prompt $"                              { fail "print signed int ==" }
1097     timeout                                      { fail "(timeout) print signed int ==" }
1098 }
1099
1100
1101 send "set variable v_int=0x7FFF\n"
1102 expect {
1103     -re "set.*$prompt $" {
1104         send "print v_int != 0\n"
1105         expect {
1106             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1107                 send "print v_int != 0x7FFF\n"
1108                 expect {
1109                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed int !=" }
1110                     -re "$prompt $"                      { fail "print signed int !=" }
1111                     timeout                              { fail "(timeout) print signed int !=" }
1112                 }
1113             }
1114             -re "$prompt $"                      { fail "print signed int !=" }
1115             timeout                              { fail "(timeout) print signed int !=" }
1116         }
1117     }
1118     -re "$prompt $"                              { fail "print signed int !=" }
1119     timeout                                      { fail "(timeout) print signed int !=" }
1120 }
1121
1122
1123 send "set variable v_int=0x7FFF\n"
1124 expect {
1125     -re "set.*$prompt $" {
1126         send "print v_int < 0\n"
1127         expect {
1128             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1129                 send "print v_int < 0x7FFF\n"
1130                 expect {
1131                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed int <" }
1132                     -re "$prompt $"                      { fail "print signed int <" }
1133                     timeout                              { fail "(timeout) print signed int <" }
1134                 }
1135             }
1136             -re "$prompt $"                      { fail "print signed int <" }
1137             timeout                              { fail "(timeout) print signed int <" }
1138         }
1139     }
1140     -re "$prompt $"                              { fail "print signed int <" }
1141     timeout                                      { fail "(timeout) print signed int <" }
1142 }
1143
1144
1145 send "set variable v_int=0x7FFF\n"
1146 expect {
1147     -re "set.*$prompt $" {
1148         send "print v_int > 0\n"
1149         expect {
1150             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1151                 send "print v_int > 0x7FFF\n"
1152                 expect {
1153                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed int >" }
1154                     -re "$prompt $"                      { fail "print signed int >" }
1155                     timeout                              { fail "(timeout) print signed int >" }
1156                 }
1157             }
1158             -re "$prompt $"                      { fail "print signed int >" }
1159             timeout                              { fail "(timeout) print signed int >" }
1160         }
1161     }
1162     -re "$prompt $"                              { fail "print signed int >" }
1163     timeout                                      { fail "(timeout) print signed int >" }
1164 }
1165
1166
1167 # make int a minus
1168 send "set variable v_int=-1\n"
1169 expect {
1170     -re "set.*$prompt $" {
1171         send "print v_int == 0\n"
1172         expect {
1173             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1174                 send "print v_int == -1\n"
1175                 expect {
1176                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed int == (minus)" }
1177                     -re "$prompt $"                      { fail "print signed int == (minus)" }
1178                     timeout                              { fail "(timeout) print signed int == (minus)" }
1179                 }
1180             }
1181             -re "$prompt $"                      { fail "print signed int == (minus)" }
1182             timeout                              { fail "(timeout) print signed int == (minus)" }
1183         }
1184     }
1185     -re "$prompt $"                              { fail "print signed int == (minus)" }
1186     timeout                                      { fail "(timeout) print signed int == (minus)" }
1187 }
1188
1189
1190 send "set variable v_int=-1\n"
1191 expect {
1192     -re "set.*$prompt $" {
1193         send "print v_int != 0\n"
1194         expect {
1195             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1196                 send "print v_int != -1\n"
1197                 expect {
1198                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed int != (minus)" }
1199                     -re "$prompt $"                      { fail "print signed int != (minus)" }
1200                     timeout                              { fail "(timeout) print signed int != (minus)" }
1201                 }
1202             }
1203             -re "$prompt $"                      { fail "print signed int != (minus)" }
1204             timeout                              { fail "(timeout) print signed int != (minus)" }
1205         }
1206     }
1207     -re "$prompt $"                              { fail "print signed int != (minus)" }
1208     timeout                                      { fail "(timeout) print signed int != (minus)" }
1209 }
1210
1211
1212 send "set variable v_int=-1\n"
1213 expect {
1214     -re "set.*$prompt $" {
1215         send "print v_int < 0\n"
1216         expect {
1217             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1218                 send "print v_int < 0x7FFF\n"
1219                 expect {
1220                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed int < (minus)" }
1221                     -re "$prompt $"                      { fail "print signed int < (minus)" }
1222                     timeout                              { fail "(timeout) print signed int < (minus)" }
1223                 }
1224             }
1225             -re "$prompt $"                      { fail "print signed int < (minus)" }
1226             timeout                              { fail "(timeout) print signed int < (minus)" }
1227         }
1228     }
1229     -re "$prompt $"                              { fail "print signed int < (minus)" }
1230     timeout                                      { fail "(timeout) print signed int < (minus)" }
1231 }
1232
1233
1234 send "set variable v_int=-1\n"
1235 expect {
1236     -re "set.*$prompt $" {
1237         send "print v_int > 0\n"
1238         expect {
1239             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1240                 send "print v_int > 0x7FFF\n"
1241                 expect {
1242                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed int > (minus)" }
1243                     -re "$prompt $"                      { fail "print signed int > (minus)" }
1244                     timeout                              { fail "(timeout) print signed int > (minus)" }
1245                 }
1246             }
1247             -re "$prompt $"                      { fail "print signed int > (minus)" }
1248             timeout                              { fail "(timeout) print signed int > (minus)" }
1249         }
1250     }
1251     -re "$prompt $"                              { fail "print signed int > (minus)" }
1252     timeout                                      { fail "(timeout) print signed int > (minus)" }
1253 }
1254
1255
1256 #
1257 # test expressions with "signed int" types
1258 #
1259 send "set variable v_signed_int=0x7FFF\n"
1260 expect {
1261     -re "set.*$prompt $" {
1262         send "print v_signed_int == 0\n"
1263         expect {
1264             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1265                 send "print v_signed_int == 0x7FFF\n"
1266                 expect {
1267                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed int ==" }
1268                     -re "$prompt $"                      { fail "print signed signed int ==" }
1269                     timeout                              { fail "(timeout) print signed signed int ==" }
1270                 }
1271             }
1272             -re "$prompt $"                      { fail "print signed signed int ==" }
1273             timeout                              { fail "(timeout) print signed signed int ==" }
1274         }
1275     }
1276     -re "$prompt $"                              { fail "print signed signed int ==" }
1277     timeout                                      { fail "(timeout) print signed signed int ==" }
1278 }
1279
1280
1281 send "set variable v_signed_int=0x7FFF\n"
1282 expect {
1283     -re "set.*$prompt $" {
1284         send "print v_signed_int != 0\n"
1285         expect {
1286             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1287                 send "print v_signed_int != 0x7FFF\n"
1288                 expect {
1289                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed int !=" }
1290                     -re "$prompt $"                      { fail "print signed signed int !=" }
1291                     timeout                              { fail "(timeout) print signed signed int !=" }
1292                 }
1293             }
1294             -re "$prompt $"                      { fail "print signed signed int !=" }
1295             timeout                              { fail "(timeout) print signed signed int !=" }
1296         }
1297     }
1298     -re "$prompt $"                              { fail "print signed signed int !=" }
1299     timeout                                      { fail "(timeout) print signed signed int !=" }
1300 }
1301
1302
1303 send "set variable v_signed_int=0x7FFF\n"
1304 expect {
1305     -re "set.*$prompt $" {
1306         send "print v_signed_int < 0\n"
1307         expect {
1308             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1309                 send "print v_signed_int < 0x7FFF\n"
1310                 expect {
1311                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed int <" }
1312                     -re "$prompt $"                      { fail "print signed signed int <" }
1313                     timeout                              { fail "(timeout) print signed signed int <" }
1314                 }
1315             }
1316             -re "$prompt $"                      { fail "print signed signed int <" }
1317             timeout                              { fail "(timeout) print signed signed int <" }
1318         }
1319     }
1320     -re "$prompt $"                              { fail "print signed signed int <" }
1321     timeout                                      { fail "(timeout) print signed signed int <" }
1322 }
1323
1324
1325 send "set variable v_signed_int=0x7FFF\n"
1326 expect {
1327     -re "set.*$prompt $" {
1328         send "print v_signed_int > 0\n"
1329         expect {
1330             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1331                 send "print v_signed_int > 0x7FFF\n"
1332                 expect {
1333                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed int >" }
1334                     -re "$prompt $"                      { fail "print signed signed int >" }
1335                     timeout                              { fail "(timeout) print signed signed int >" }
1336                 }
1337             }
1338             -re "$prompt $"                      { fail "print signed signed int >" }
1339             timeout                              { fail "(timeout) print signed signed int >" }
1340         }
1341     }
1342     -re "$prompt $"                              { fail "print signed signed int >" }
1343     timeout                                      { fail "(timeout) print signed signed int >" }
1344 }
1345
1346
1347 # make int a minus
1348 send "set variable v_signed_int=-1\n"
1349 expect {
1350     -re "set.*$prompt $" {
1351         send "print v_signed_int == 0\n"
1352         expect {
1353             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1354                 send "print v_signed_int == -1\n"
1355                 expect {
1356                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed int == (minus)" }
1357                     -re "$prompt $"                      { fail "print signed signed int == (minus)" }
1358                     timeout                              { fail "(timeout) print signed signed int == (minus)" }
1359                 }
1360             }
1361             -re "$prompt $"                      { fail "print signed signed int == (minus)" }
1362             timeout                              { fail "(timeout) print signed signed int == (minus)" }
1363         }
1364     }
1365     -re "$prompt $"                              { fail "print signed signed int == (minus)" }
1366     timeout                                      { fail "(timeout) print signed signed int == (minus)" }
1367 }
1368
1369
1370 send "set variable v_signed_int=-1\n"
1371 expect {
1372     -re "set.*$prompt $" {
1373         send "print v_signed_int != 0\n"
1374         expect {
1375             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1376                 send "print v_signed_int != -1\n"
1377                 expect {
1378                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed int != (minus)" }
1379                     -re "$prompt $"                      { fail "print signed signed int != (minus)" }
1380                     timeout                              { fail "(timeout) print signed signed int != (minus)" }
1381                 }
1382             }
1383             -re "$prompt $"                      { fail "print signed signed int != (minus)" }
1384             timeout                              { fail "(timeout) print signed signed int != (minus)" }
1385         }
1386     }
1387     -re "$prompt $"                              { fail "print signed signed int != (minus)" }
1388     timeout                                      { fail "(timeout) print signed signed int != (minus)" }
1389 }
1390
1391
1392 send "set variable v_signed_int=-1\n"
1393 expect {
1394     -re "set.*$prompt $" {
1395         send "print v_signed_int < 0\n"
1396         expect {
1397             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1398                 send "print v_signed_int < 0x7FFF\n"
1399                 expect {
1400                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed int < (minus)" }
1401                     -re "$prompt $"                      { fail "print signed signed int < (minus)" }
1402                     timeout                              { fail "(timeout) print signed signed int < (minus)" }
1403                 }
1404             }
1405             -re "$prompt $"                      { fail "print signed signed int < (minus)" }
1406             timeout                              { fail "(timeout) print signed signed int < (minus)" }
1407         }
1408     }
1409     -re "$prompt $"                              { fail "print signed signed int < (minus)" }
1410     timeout                                      { fail "(timeout) print signed signed int < (minus)" }
1411 }
1412
1413
1414 send "set variable v_signed_int=-1\n"
1415 expect {
1416     -re "set.*$prompt $" {
1417         send "print v_signed_int > 0\n"
1418         expect {
1419             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1420                 send "print v_signed_int > 0x7FFF\n"
1421                 expect {
1422                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed int > (minus)" }
1423                     -re "$prompt $"                      { fail "print signed signed int > (minus)" }
1424                     timeout                              { fail "(timeout) print signed signed int > (minus)" }
1425                 }
1426             }
1427             -re "$prompt $"                      { fail "print signed signed int > (minus)" }
1428             timeout                              { fail "(timeout) print signed signed int > (minus)" }
1429         }
1430     }
1431     -re "$prompt $"                              { fail "print signed signed int > (minus)" }
1432     timeout                                      { fail "(timeout) print signed signed int > (minus)" }
1433 }
1434
1435
1436 #
1437 # test expressions with "unsigned int" types
1438 #
1439 send "set variable v_unsigned_int=0x7FFF\n"
1440 expect {
1441     -re "set.*$prompt $" {
1442         send "print v_unsigned_int == 0\n"
1443         expect {
1444             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1445                 send "print v_unsigned_int == 0x7FFF\n"
1446                 expect {
1447                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned int ==" }
1448                     -re "$prompt $"                      { fail "print unsigned int ==" }
1449                     timeout                              { fail "(timeout) print unsigned int ==" }
1450                 }
1451             }
1452             -re "$prompt $"                      { fail "print unsigned int ==" }
1453             timeout                              { fail "(timeout) print unsigned int ==" }
1454         }
1455     }
1456     -re "$prompt $"                              { fail "print unsigned int ==" }
1457     timeout                                      { fail "(timeout) print unsigned int ==" }
1458 }
1459
1460
1461 send "set variable v_unsigned_int=0x7FFF\n"
1462 expect {
1463     -re "set.*$prompt $" {
1464         send "print v_unsigned_int != 0\n"
1465         expect {
1466             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1467                 send "print v_unsigned_int != 0x7FFF\n"
1468                 expect {
1469                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned int !=" }
1470                     -re "$prompt $"                      { fail "print unsigned int !=" }
1471                     timeout                              { fail "(timeout) print unsigned int !=" }
1472                 }
1473             }
1474             -re "$prompt $"                      { fail "print unsigned int !=" }
1475             timeout                              { fail "(timeout) print unsigned int !=" }
1476         }
1477     }
1478     -re "$prompt $"                              { fail "print unsigned int !=" }
1479     timeout                                      { fail "(timeout) print unsigned int !=" }
1480 }
1481
1482
1483 send "set variable v_unsigned_int=0x7FFF\n"
1484 expect {
1485     -re "set.*$prompt $" {
1486         send "print v_unsigned_int < 0\n"
1487         expect {
1488             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1489                 send "print v_unsigned_int < 0x7FFF\n"
1490                 expect {
1491                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned int <" }
1492                     -re "$prompt $"                      { fail "print unsigned int <" }
1493                     timeout                              { fail "(timeout) print unsigned int <" }
1494                 }
1495             }
1496             -re "$prompt $"                      { fail "print unsigned int <" }
1497             timeout                              { fail "(timeout) print unsigned int <" }
1498         }
1499     }
1500     -re "$prompt $"                              { fail "print unsigned int <" }
1501     timeout                                      { fail "(timeout) print unsigned int <" }
1502 }
1503
1504
1505 send "set variable v_unsigned_int=0x7FFF\n"
1506 expect {
1507     -re "set.*$prompt $" {
1508         send "print v_unsigned_int > 0\n"
1509         expect {
1510             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1511                 send "print v_unsigned_int > 0x7FFF\n"
1512                 expect {
1513                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned int >" }
1514                     -re "$prompt $"                      { fail "print unsigned int >" }
1515                     timeout                              { fail "(timeout) print unsigned int >" }
1516                 }
1517             }
1518             -re "$prompt $"                      { fail "print unsigned int >" }
1519             timeout                              { fail "(timeout) print unsigned int >" }
1520         }
1521     }
1522     -re "$prompt $"                              { fail "print unsigned int >" }
1523     timeout                                      { fail "(timeout) print unsigned int >" }
1524 }
1525
1526
1527 # make int a minus
1528 send "set variable v_unsigned_int=~0\n"
1529 expect {
1530     -re "set.*$prompt $" {
1531         send "print v_unsigned_int == 0\n"
1532         expect {
1533             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1534                 send "print v_unsigned_int == ~0\n"
1535                 expect {
1536                     -re "print.*.\[0-9\]* = 1.*$prompt $" {
1537                         send "print v_unsigned_int == (unsigned int)~0\n"
1538                         expect {
1539                             -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned int == (~0)" }
1540                             -re "$prompt $"                      { fail "print unsigned int == (~0)" }
1541                             timeout                              { fail "(timeout) print unsigned int == (~0)" }
1542                         }
1543                     }
1544                     -re "print.*.\[0-9\]* = 0.*$prompt $" {
1545                         fail "print unsigned int == (~0)"
1546                         send "print v_unsigned_int == (unsigned int)~0\n"
1547                         expect {
1548                             -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned int == (~0)" }
1549                             -re "$prompt $"                      { fail "print unsigned int == (~0)" }
1550                             timeout                              { fail "(timeout) print unsigned int == (~0)" }
1551                         }
1552                     }
1553                     -re "$prompt $"                      { fail "print unsigned int == (~0)" }
1554                     timeout                              { fail "(timeout) print unsigned int == (~0)" }
1555                 }
1556             }
1557             -re "$prompt $"                      { fail "print unsigned int == (~0)" }
1558             timeout                              { fail "(timeout) print unsigned int == (~0)" }
1559         }
1560     }
1561     -re "$prompt $"                              { fail "print unsigned int == (~0)" }
1562     timeout                                      { fail "(timeout) print unsigned int == (~0)" }
1563 }
1564
1565
1566 send "set variable v_unsigned_int=~0\n"
1567 expect {
1568     -re "set.*$prompt $" {
1569         send "print v_unsigned_int != 0\n"
1570         expect {
1571             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1572                 send "print v_unsigned_int != (unsigned int)~0\n"
1573                 expect {
1574                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned int != (~0)" }
1575                     -re "$prompt $"                      { fail "print unsigned int != (~0)" }
1576                     timeout                              { fail "(timeout) print unsigned int != (~0)" }
1577                 }
1578             }
1579             -re "$prompt $"                      { fail "print unsigned int != (~0)" }
1580             timeout                              { fail "(timeout) print unsigned int != (~0)" }
1581         }
1582     }
1583     -re "$prompt $"                              { fail "print unsigned int != (~0)" }
1584     timeout                                      { fail "(timeout) print unsigned int != (~0)" }
1585 }
1586
1587
1588 send "set variable v_unsigned_int=~0\n"
1589 expect {
1590     -re "set.*$prompt $" {
1591         send "print v_unsigned_int < 0\n"
1592         expect {
1593             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1594                 send "print v_unsigned_int < 0x7FFF\n"
1595                 expect {
1596                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned int < (~0)" }
1597                     -re "$prompt $"                      { fail "print unsigned int < (~0)" }
1598                     timeout                              { fail "(timeout) print unsigned int < (~0)" }
1599                 }
1600             }
1601             -re "$prompt $"                      { fail "print unsigned int < (~0)" }
1602             timeout                              { fail "(timeout) print unsigned int < (~0)" }
1603         }
1604     }
1605     -re "$prompt $"                              { fail "print unsigned int < (~0)" }
1606     timeout                                      { fail "(timeout) print unsigned int < (~0)" }
1607 }
1608
1609
1610 send "set variable v_unsigned_int=~0\n"
1611 expect {
1612     -re "set.*$prompt $" {
1613         send "print v_unsigned_int > 0\n"
1614         expect {
1615             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1616                 send "print v_unsigned_int > 0x7FFF\n"
1617                 expect {
1618                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned int > (~0)" }
1619                     -re "$prompt $"                      { fail "print unsigned int > (~0)" }
1620                     timeout                              { fail "(timeout) print unsigned int > (~0)" }
1621                 }
1622             }
1623             -re "$prompt $"                      { fail "print unsigned int > (~0)" }
1624             timeout                              { fail "(timeout) print unsigned int > (~0)" }
1625         }
1626     }
1627     -re "$prompt $"                              { fail "print unsigned int > (~0)" }
1628     timeout                                      { fail "(timeout) print unsigned int > (~0)" }
1629 }
1630
1631
1632 #
1633 # test expressions with "long" types
1634 #
1635 send "set variable v_long=0x7FFF\n"
1636 expect {
1637     -re "set.*$prompt $" {
1638         send "print v_long == 0\n"
1639         expect {
1640             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1641                 send "print v_long == 0x7FFF\n"
1642                 expect {
1643                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed long ==" }
1644                     -re "$prompt $"                      { fail "print signed long ==" }
1645                     timeout                              { fail "(timeout) print signed long ==" }
1646                 }
1647             }
1648             -re "$prompt $"                      { fail "print signed long ==" }
1649             timeout                              { fail "(timeout) print signed long ==" }
1650         }
1651     }
1652     -re "$prompt $"                              { fail "print signed long ==" }
1653     timeout                                      { fail "(timeout) print signed long ==" }
1654 }
1655
1656
1657 send "set variable v_long=0x7FFF\n"
1658 expect {
1659     -re "set.*$prompt $" {
1660         send "print v_long != 0\n"
1661         expect {
1662             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1663                 send "print v_long != 0x7FFF\n"
1664                 expect {
1665                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed long !=" }
1666                     -re "$prompt $"                      { fail "print signed long !=" }
1667                     timeout                              { fail "(timeout) print signed long !=" }
1668                 }
1669             }
1670             -re "$prompt $"                      { fail "print signed long !=" }
1671             timeout                              { fail "(timeout) print signed long !=" }
1672         }
1673     }
1674     -re "$prompt $"                              { fail "print signed long !=" }
1675     timeout                                      { fail "(timeout) print signed long !=" }
1676 }
1677
1678
1679 send "set variable v_long=0x7FFF\n"
1680 expect {
1681     -re "set.*$prompt $" {
1682         send "print v_long < 0\n"
1683         expect {
1684             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1685                 send "print v_long < 0x7FFF\n"
1686                 expect {
1687                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed long <" }
1688                     -re "$prompt $"                      { fail "print signed long <" }
1689                     timeout                              { fail "(timeout) print signed long <" }
1690                 }
1691             }
1692             -re "$prompt $"                      { fail "print signed long <" }
1693             timeout                              { fail "(timeout) print signed long <" }
1694         }
1695     }
1696     -re "$prompt $"                              { fail "print signed long <" }
1697     timeout                                      { fail "(timeout) print signed long <" }
1698 }
1699
1700
1701 send "set variable v_long=0x7FFF\n"
1702 expect {
1703     -re "set.*$prompt $" {
1704         send "print v_long > 0\n"
1705         expect {
1706             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1707                 send "print v_long > 0x7FFF\n"
1708                 expect {
1709                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed long >" }
1710                     -re "$prompt $"                      { fail "print signed long >" }
1711                     timeout                              { fail "(timeout) print signed long >" }
1712                 }
1713             }
1714             -re "$prompt $"                      { fail "print signed long >" }
1715             timeout                              { fail "(timeout) print signed long >" }
1716         }
1717     }
1718     -re "$prompt $"                              { fail "print signed long >" }
1719     timeout                                      { fail "(timeout) print signed long >" }
1720 }
1721
1722
1723 # make long a minus
1724 send "set variable v_long=-1\n"
1725 expect {
1726     -re "set.*$prompt $" {
1727         send "print v_long == 0\n"
1728         expect {
1729             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1730                 send "print v_long == -1\n"
1731                 expect {
1732                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed long == (minus)" }
1733                     -re "$prompt $"                      { fail "print signed long == (minus)" }
1734                     timeout                              { fail "(timeout) print signed long == (minus)" }
1735                 }
1736             }
1737             -re "$prompt $"                      { fail "print signed long == (minus)" }
1738             timeout                              { fail "(timeout) print signed long == (minus)" }
1739         }
1740     }
1741     -re "$prompt $"                              { fail "print signed long == (minus)" }
1742     timeout                                      { fail "(timeout) print signed long == (minus)" }
1743 }
1744
1745
1746 send "set variable v_long=-1\n"
1747 expect {
1748     -re "set.*$prompt $" {
1749         send "print v_long != 0\n"
1750         expect {
1751             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1752                 send "print v_long != -1\n"
1753                 expect {
1754                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed long != (minus)" }
1755                     -re "$prompt $"                      { fail "print signed long != (minus)" }
1756                     timeout                              { fail "(timeout) print signed long != (minus)" }
1757                 }
1758             }
1759             -re "$prompt $"                      { fail "print signed long != (minus)" }
1760             timeout                              { fail "(timeout) print signed long != (minus)" }
1761         }
1762     }
1763     -re "$prompt $"                              { fail "print signed long != (minus)" }
1764     timeout                                      { fail "(timeout) print signed long != (minus)" }
1765 }
1766
1767
1768 send "set variable v_long=-1\n"
1769 expect {
1770     -re "set.*$prompt $" {
1771         send "print v_long < 0\n"
1772         expect {
1773             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1774                 send "print v_long < 0x7FFF\n"
1775                 expect {
1776                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed long < (minus)" }
1777                     -re "$prompt $"                      { fail "print signed long < (minus)" }
1778                     timeout                              { fail "(timeout) print signed long < (minus)" }
1779                 }
1780             }
1781             -re "$prompt $"                      { fail "print signed long < (minus)" }
1782             timeout                              { fail "(timeout) print signed long < (minus)" }
1783         }
1784     }
1785     -re "$prompt $"                              { fail "print signed long < (minus)" }
1786     timeout                                      { fail "(timeout) print signed long < (minus)" }
1787 }
1788
1789
1790 send "set variable v_long=-1\n"
1791 expect {
1792     -re "set.*$prompt $" {
1793         send "print v_long > 0\n"
1794         expect {
1795             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1796                 send "print v_long > 0x7FFF\n"
1797                 expect {
1798                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed long > (minus)" }
1799                     -re "$prompt $"                      { fail "print signed long > (minus)" }
1800                     timeout                              { fail "(timeout) print signed long > (minus)" }
1801                 }
1802             }
1803             -re "$prompt $"                      { fail "print signed long > (minus)" }
1804             timeout                              { fail "(timeout) print signed long > (minus)" }
1805         }
1806     }
1807     -re "$prompt $"                              { fail "print signed long > (minus)" }
1808     timeout                                      { fail "(timeout) print signed long > (minus)" }
1809 }
1810
1811
1812 #
1813 # test expressions with "signed long" types
1814 #
1815 send "set variable v_signed_long=0x7FFF\n"
1816 expect {
1817     -re "set.*$prompt $" {
1818         send "print v_signed_long == 0\n"
1819         expect {
1820             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1821                 send "print v_signed_long == 0x7FFF\n"
1822                 expect {
1823                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed long ==" }
1824                     -re "$prompt $"                      { fail "print signed signed long ==" }
1825                     timeout                              { fail "(timeout) print signed signed long ==" }
1826                 }
1827             }
1828             -re "$prompt $"                      { fail "print signed signed long ==" }
1829             timeout                              { fail "(timeout) print signed signed long ==" }
1830         }
1831     }
1832     -re "$prompt $"                              { fail "print signed signed long ==" }
1833     timeout                                      { fail "(timeout) print signed signed long ==" }
1834 }
1835
1836
1837 send "set variable v_signed_long=0x7FFF\n"
1838 expect {
1839     -re "set.*$prompt $" {
1840         send "print v_signed_long != 0\n"
1841         expect {
1842             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1843                 send "print v_signed_long != 0x7FFF\n"
1844                 expect {
1845                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed long !=" }
1846                     -re "$prompt $"                      { fail "print signed signed long !=" }
1847                     timeout                              { fail "(timeout) print signed signed long !=" }
1848                 }
1849             }
1850             -re "$prompt $"                      { fail "print signed signed long !=" }
1851             timeout                              { fail "(timeout) print signed signed long !=" }
1852         }
1853     }
1854     -re "$prompt $"                              { fail "print signed signed long !=" }
1855     timeout                                      { fail "(timeout) print signed signed long !=" }
1856 }
1857
1858
1859 send "set variable v_signed_long=0x7FFF\n"
1860 expect {
1861     -re "set.*$prompt $" {
1862         send "print v_signed_long < 0\n"
1863         expect {
1864             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1865                 send "print v_signed_long < 0x7FFF\n"
1866                 expect {
1867                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed long <" }
1868                     -re "$prompt $"                      { fail "print signed signed long <" }
1869                     timeout                              { fail "(timeout) print signed signed long <" }
1870                 }
1871             }
1872             -re "$prompt $"                      { fail "print signed signed long <" }
1873             timeout                              { fail "(timeout) print signed signed long <" }
1874         }
1875     }
1876     -re "$prompt $"                              { fail "print signed signed long <" }
1877     timeout                                      { fail "(timeout) print signed signed long <" }
1878 }
1879
1880
1881 send "set variable v_signed_long=0x7FFF\n"
1882 expect {
1883     -re "set.*$prompt $" {
1884         send "print v_signed_long > 0\n"
1885         expect {
1886             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1887                 send "print v_signed_long > 0x7FFF\n"
1888                 expect {
1889                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed long >" }
1890                     -re "$prompt $"                      { fail "print signed signed long >" }
1891                     timeout                              { fail "(timeout) print signed signed long >" }
1892                 }
1893             }
1894             -re "$prompt $"                      { fail "print signed signed long >" }
1895             timeout                              { fail "(timeout) print signed signed long >" }
1896         }
1897     }
1898     -re "$prompt $"                              { fail "print signed signed long >" }
1899     timeout                                      { fail "(timeout) print signed signed long >" }
1900 }
1901
1902
1903 # make long a minus
1904 send "set variable v_signed_long=-1\n"
1905 expect {
1906     -re "set.*$prompt $" {
1907         send "print v_signed_long == 0\n"
1908         expect {
1909             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1910                 send "print v_signed_long == -1\n"
1911                 expect {
1912                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed long == (minus)" }
1913                     -re "$prompt $"                      { fail "print signed signed long == (minus)" }
1914                     timeout                              { fail "(timeout) print signed signed long == (minus)" }
1915                 }
1916             }
1917             -re "$prompt $"                      { fail "print signed signed long == (minus)" }
1918             timeout                              { fail "(timeout) print signed signed long == (minus)" }
1919         }
1920     }
1921     -re "$prompt $"                              { fail "print signed signed long == (minus)" }
1922     timeout                                      { fail "(timeout) print signed signed long == (minus)" }
1923 }
1924
1925
1926 send "set variable v_signed_long=-1\n"
1927 expect {
1928     -re "set.*$prompt $" {
1929         send "print v_signed_long != 0\n"
1930         expect {
1931             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1932                 send "print v_signed_long != -1\n"
1933                 expect {
1934                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed long != (minus)" }
1935                     -re "$prompt $"                      { fail "print signed signed long != (minus)" }
1936                     timeout                              { fail "(timeout) print signed signed long != (minus)" }
1937                 }
1938             }
1939             -re "$prompt $"                      { fail "print signed signed long != (minus)" }
1940             timeout                              { fail "(timeout) print signed signed long != (minus)" }
1941         }
1942     }
1943     -re "$prompt $"                              { fail "print signed signed long != (minus)" }
1944     timeout                                      { fail "(timeout) print signed signed long != (minus)" }
1945 }
1946
1947
1948 send "set variable v_signed_long=-1\n"
1949 expect {
1950     -re "set.*$prompt $" {
1951         send "print v_signed_long < 0\n"
1952         expect {
1953             -re "print.*.\[0-9\]* = 1.*$prompt $" {
1954                 send "print v_signed_long < 0x7FFF\n"
1955                 expect {
1956                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print signed signed long < (minus)" }
1957                     -re "$prompt $"                      { fail "print signed signed long < (minus)" }
1958                     timeout                              { fail "(timeout) print signed signed long < (minus)" }
1959                 }
1960             }
1961             -re "$prompt $"                      { fail "print signed signed long < (minus)" }
1962             timeout                              { fail "(timeout) print signed signed long < (minus)" }
1963         }
1964     }
1965     -re "$prompt $"                              { fail "print signed signed long < (minus)" }
1966     timeout                                      { fail "(timeout) print signed signed long < (minus)" }
1967 }
1968
1969
1970 send "set variable v_signed_long=-1\n"
1971 expect {
1972     -re "set.*$prompt $" {
1973         send "print v_signed_long > 0\n"
1974         expect {
1975             -re "print.*.\[0-9\]* = 0.*$prompt $" {
1976                 send "print v_signed_long > 0x7FFF\n"
1977                 expect {
1978                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print signed signed long > (minus)" }
1979                     -re "$prompt $"                      { fail "print signed signed long > (minus)" }
1980                     timeout                              { fail "(timeout) print signed signed long > (minus)" }
1981                 }
1982             }
1983             -re "$prompt $"                      { fail "print signed signed long > (minus)" }
1984             timeout                              { fail "(timeout) print signed signed long > (minus)" }
1985         }
1986     }
1987     -re "$prompt $"                              { fail "print signed signed long > (minus)" }
1988     timeout                                      { fail "(timeout) print signed signed long > (minus)" }
1989 }
1990
1991
1992 #
1993 # test expressions with "unsigned long" types
1994 #
1995 send "set variable v_unsigned_long=0x7FFF\n"
1996 expect {
1997     -re "set.*$prompt $" {
1998         send "print v_unsigned_long == 0\n"
1999         expect {
2000             -re "print.*.\[0-9\]* = 0.*$prompt $" {
2001                 send "print v_unsigned_long == 0x7FFF\n"
2002                 expect {
2003                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned long ==" }
2004                     -re "$prompt $"                      { fail "print unsigned long ==" }
2005                     timeout                              { fail "(timeout) print unsigned long ==" }
2006                 }
2007             }
2008             -re "$prompt $"                      { fail "print unsigned long ==" }
2009             timeout                              { fail "(timeout) print unsigned long ==" }
2010         }
2011     }
2012     -re "$prompt $"                              { fail "print unsigned long ==" }
2013     timeout                                      { fail "(timeout) print unsigned long ==" }
2014 }
2015
2016
2017 send "set variable v_unsigned_long=0x7FFF\n"
2018 expect {
2019     -re "set.*$prompt $" {
2020         send "print v_unsigned_long != 0\n"
2021         expect {
2022             -re "print.*.\[0-9\]* = 1.*$prompt $" {
2023                 send "print v_unsigned_long != 0x7FFF\n"
2024                 expect {
2025                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned long !=" }
2026                     -re "$prompt $"                      { fail "print unsigned long !=" }
2027                     timeout                              { fail "(timeout) print unsigned long !=" }
2028                 }
2029             }
2030             -re "$prompt $"                      { fail "print unsigned long !=" }
2031             timeout                              { fail "(timeout) print unsigned long !=" }
2032         }
2033     }
2034     -re "$prompt $"                              { fail "print unsigned long !=" }
2035     timeout                                      { fail "(timeout) print unsigned long !=" }
2036 }
2037
2038
2039 send "set variable v_unsigned_long=0x7FFF\n"
2040 expect {
2041     -re "set.*$prompt $" {
2042         send "print v_unsigned_long < 0\n"
2043         expect {
2044             -re "print.*.\[0-9\]* = 0.*$prompt $" {
2045                 send "print v_unsigned_long < 0x7FFF\n"
2046                 expect {
2047                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned long <" }
2048                     -re "$prompt $"                      { fail "print unsigned long <" }
2049                     timeout                              { fail "(timeout) print unsigned long <" }
2050                 }
2051             }
2052             -re "$prompt $"                      { fail "print unsigned long <" }
2053             timeout                              { fail "(timeout) print unsigned long <" }
2054         }
2055     }
2056     -re "$prompt $"                              { fail "print unsigned long <" }
2057     timeout                                      { fail "(timeout) print unsigned long <" }
2058 }
2059
2060
2061 send "set variable v_unsigned_long=0x7FFF\n"
2062 expect {
2063     -re "set.*$prompt $" {
2064         send "print v_unsigned_long > 0\n"
2065         expect {
2066             -re "print.*.\[0-9\]* = 1.*$prompt $" {
2067                 send "print v_unsigned_long > 0x7FFF\n"
2068                 expect {
2069                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned long >" }
2070                     -re "$prompt $"                      { fail "print unsigned long >" }
2071                     timeout                              { fail "(timeout) print unsigned long >" }
2072                 }
2073             }
2074             -re "$prompt $"                      { fail "print unsigned long >" }
2075             timeout                              { fail "(timeout) print unsigned long >" }
2076         }
2077     }
2078     -re "$prompt $"                              { fail "print unsigned long >" }
2079     timeout                                      { fail "(timeout) print unsigned long >" }
2080 }
2081
2082
2083 # make long a minus
2084 send "set variable v_unsigned_long=~0\n"
2085 expect {
2086     -re "set.*$prompt $" {
2087         send "print v_unsigned_long == 0\n"
2088         expect {
2089             -re "print.*.\[0-9\]* = 0.*$prompt $" {
2090                 send "print v_unsigned_long == ~0\n"
2091                 expect {
2092                     -re "print.*.\[0-9\]* = 1.*$prompt $" {
2093                         send "print v_unsigned_long == (unsigned long)~0\n"
2094                         expect {
2095                             -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned long == (~0)" }
2096                             -re "$prompt $"                      { fail "print unsigned long == (~0)" }
2097                             timeout                              { fail "(timeout) print unsigned long == (~0)" }
2098                         }
2099                     }
2100                     -re "$prompt $"                      { fail "print unsigned long == (~0)" }
2101                     timeout                              { fail "(timeout) print unsigned long == (~0)" }
2102                 }
2103             }
2104             -re "$prompt $"                      { fail "print unsigned long == (~0)" }
2105             timeout                              { fail "(timeout) print unsigned long == (~0)" }
2106         }
2107     }
2108     -re "$prompt $"                              { fail "print unsigned long == (~0)" }
2109     timeout                                      { fail "(timeout) print unsigned long == (~0)" }
2110 }
2111
2112
2113 send "set variable v_unsigned_long=~0\n"
2114 expect {
2115     -re "set.*$prompt $" {
2116         send "print v_unsigned_long != 0\n"
2117         expect {
2118             -re "print.*.\[0-9\]* = 1.*$prompt $" {
2119                 send "print v_unsigned_long != (unsigned long)~0\n"
2120                 expect {
2121                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned long != (~0)" }
2122                     -re "$prompt $"                      { fail "print unsigned long != (~0)" }
2123                     timeout                              { fail "(timeout) print unsigned long != (~0)" }
2124                 }
2125             }
2126             -re "$prompt $"                      { fail "print unsigned long != (~0)" }
2127             timeout                              { fail "(timeout) print unsigned long != (~0)" }
2128         }
2129     }
2130     -re "$prompt $"                              { fail "print unsigned long != (~0)" }
2131     timeout                                      { fail "(timeout) print unsigned long != (~0)" }
2132 }
2133
2134
2135 send "set variable v_unsigned_long=~0\n"
2136 expect {
2137     -re "set.*$prompt $" {
2138         send "print v_unsigned_long < 0\n"
2139         expect {
2140             -re "print.*.\[0-9\]* = 0.*$prompt $" {
2141                 send "print v_unsigned_long < 0x7FFF\n"
2142                 expect {
2143                     -re "print.*.\[0-9\]* = 0.*$prompt $" { pass "print unsigned long < (~0)" }
2144                     -re "$prompt $"                      { fail "print unsigned long < (~0)" }
2145                     timeout                              { fail "(timeout) print unsigned long < (~0)" }
2146                 }
2147             }
2148             -re "$prompt $"                      { fail "print unsigned long < (~0)" }
2149             timeout                              { fail "(timeout) print unsigned long < (~0)" }
2150         }
2151     }
2152     -re "$prompt $"                              { fail "print unsigned long < (~0)" }
2153     timeout                                      { fail "(timeout) print unsigned long < (~0)" }
2154 }
2155
2156
2157 send "set variable v_unsigned_long=~0\n"
2158 expect {
2159     -re "set.*$prompt $" {
2160         send "print v_unsigned_long > 0\n"
2161         expect {
2162             -re "print.*.\[0-9\]* = 1.*$prompt $" {
2163                 send "print v_unsigned_long > 0x7FFF\n"
2164                 expect {
2165                     -re "print.*.\[0-9\]* = 1.*$prompt $" { pass "print unsigned long > (~0)" }
2166                     -re "$prompt $"                      { fail "print unsigned long > (~0)" }
2167                     timeout                              { fail "(timeout) print unsigned long > (~0)" }
2168                 }
2169             }
2170             -re "$prompt $"                      { fail "print unsigned long > (~0)" }
2171             timeout                              { fail "(timeout) print unsigned long > (~0)" }
2172         }
2173     }
2174     -re "$prompt $"                              { fail "print unsigned long > (~0)" }
2175     timeout                                      { fail "(timeout) print unsigned long > (~0)" }
2176 }