gdb/testsuite/gdb.base/constvars.exp

   1 # Copyright (C) 1997, 1998 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 # written by Elena Zannoni (elz@apollo.hp.com)
  21 #
  22 # This file is part of the gdb testsuite
  23 #
  24 # tests for const variables
  25 #           const pointers to vars
  26 #           pointers to const variables
  27 #           const pointers to const vars
  28 # with mixed types
  29
  30 if $tracelevel then {
  31         strace $tracelevel
  32         }
  33
  34 #
  35 # test running programs
  36 #
  37 set prms_id 0
  38 set bug_id 0
  39
  40 set testfile "constvars"
  41 set srcfile ${testfile}.c
  42 set binfile ${objdir}/${subdir}/${testfile}
  43
  44 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
  45      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
  46 }
  47
  48
  49 gdb_exit
  50 gdb_start
  51 gdb_reinitialize_dir $srcdir/$subdir
  52 gdb_load ${binfile}
  53
  54
  55 #
  56 # set it up at a breakpoint so we can play with the variable values
  57 #
  58 if ![runto_main] then {
  59     perror "couldn't run to breakpoint"
  60     continue
  61 }
  62
  63 send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"
  64
  65     send_gdb "cont\n"
  66     gdb_expect {
  67         -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" {
  68             send_gdb "up\n"
  69             gdb_expect {
  70                 -re ".*$gdb_prompt $" {}
  71                 timeout { fail "up from marker1" }
  72             }
  73         }
  74         -re "Break.* marker1__.* \\(\\) at .*:$decimal.*$gdb_prompt $" {
  75             fail "continue to marker1 (demangling)"
  76             send_gdb "up\n"
  77             gdb_expect {
  78                 -re ".*$gdb_prompt $" {}
  79                 timeout { fail "up from marker1" }
  80             }
  81         }
  82         -re "$gdb_prompt $" { fail "continue to marker1"  }
  83         timeout { fail "(timeout) continue to marker1"  }
  84     }
  85
  86 # test function parameters
  87 send_gdb "ptype qux1\n"
  88 gdb_expect {
  89     -re "type = int \\(const char, const char &, const char \\*, char \\* const\\).*$gdb_prompt $" {
  90         pass "ptype qux1"
  91     }
  92     -re ".*$gdb_prompt $" { fail "ptype qux1" }
  93     timeout           { fail "(timeout) ptype qux1" }
  94   }
  95
  96 # test vars and pointers
  97
  98 send_gdb "print lave\n"
  99 gdb_expect {
 100     -re ".\[0-9\]* = 66 \'B\'.*$gdb_prompt $" {
 101         pass "print value of lave"
 102       }
 103     -re ".*$gdb_prompt $" { fail "print value of lave" }
 104     timeout           { fail "(timeout) print value of lave" }
 105   }
 106
 107
 108 send_gdb "ptype lave\n"
 109 gdb_expect {
 110     -re "type = char.*$gdb_prompt $"  { pass "ptype lave" }
 111     -re ".*$gdb_prompt $"   {  fail "ptype lave" }
 112     timeout             { fail "(timeout) ptype lave" }
 113 }
 114
 115
 116 send_gdb "print lavish\n"
 117 gdb_expect {
 118     -re ".\[0-9\]* = 10 \'\\\\n\'.*$gdb_prompt $" {
 119         pass "print value of lavish"
 120       }
 121     -re ".*$gdb_prompt $" { fail "print value of lavish" }
 122     timeout           { fail "(timeout) print value of lavish" }
 123   }
 124
 125
 126 send_gdb "ptype lavish\n"
 127 gdb_expect {
 128     -re "type = unsigned char.*$gdb_prompt $"  { pass "ptype lavish" }
 129     -re ".*$gdb_prompt $"   {  fail "ptype lavish " }
 130     timeout             { fail "(timeout) ptype lavish " }
 131 }
 132
 133
 134 send_gdb "print lax\n"
 135 gdb_expect {
 136     -re ".\[0-9\]* = 20.*$gdb_prompt $" {
 137         pass "print value of lax"
 138       }
 139     -re ".*$gdb_prompt $" { fail "print value of lax" }
 140     timeout           { fail "(timeout) print value of lax" }
 141   }
 142
 143
 144 send_gdb "ptype lax\n"
 145 gdb_expect {
 146     -re "type = short.*$gdb_prompt $"  { pass "ptype lax" }
 147     -re ".*$gdb_prompt $"   {  fail "ptype lax" }
 148     timeout             { fail "(timeout) ptype lax" }
 149 }
 150
 151
 152 send_gdb "print lecherous\n"
 153 gdb_expect {
 154     -re ".\[0-9\]* = 30.*$gdb_prompt $" {
 155         pass "print value of lecherous"
 156       }
 157     -re ".*$gdb_prompt $" { fail "print value of lecherous" }
 158     timeout           { fail "(timeout) print value of lecherous" }
 159   }
 160
 161
 162 send_gdb "ptype lecherous\n"
 163 gdb_expect {
 164     -re "type = unsigned short.*$gdb_prompt $"  { pass "ptype lecherous" }
 165     -re "type = short unsigned.*$gdb_prompt $"  { pass "ptype lecherous" }
 166     -re ".*$gdb_prompt $"   {  fail "ptype lecherous" }
 167     timeout             { fail "(timeout) ptype lecherous" }
 168 }
 169
 170
 171 send_gdb "print lechery\n"
 172 gdb_expect {
 173     -re ".\[0-9\]* = 40.*$gdb_prompt $" {
 174         pass "print value of lechery"
 175       }
 176     -re ".*$gdb_prompt $" { fail "print value of lechery" }
 177     timeout           { fail "(timeout) print value of lechery" }
 178   }
 179
 180
 181 send_gdb "ptype lechery\n"
 182 gdb_expect {
 183     -re "type = long.*$gdb_prompt $"  { pass "ptype lechery" }
 184     -re ".*$gdb_prompt $"   {  fail "ptype lechery" }
 185     timeout             { fail "(timeout) ptype lechery" }
 186 }
 187
 188
 189 send_gdb "print lectern\n"
 190 gdb_expect {
 191     -re ".\[0-9\]* = 50.*$gdb_prompt $" {
 192         pass "print value of lectern"
 193       }
 194     -re ".*$gdb_prompt $" { fail "print value of lectern" }
 195     timeout           { fail "(timeout) print value of lectern " }
 196   }
 197
 198
 199 send_gdb "ptype lectern\n"
 200 gdb_expect {
 201     -re "type = unsigned long.*$gdb_prompt $"  { pass "ptype lectern" }
 202     -re "type = long unsigned.*$gdb_prompt $"  { pass "ptype lectern" }
 203     -re ".*$gdb_prompt $"   {  fail "ptype lectern" }
 204     timeout             { fail "(timeout) ptype lectern" }
 205 }
 206
 207
 208 send_gdb "print leeway\n"
 209 gdb_expect {
 210     -re ".\[0-9\]* = 60.*$gdb_prompt $" {
 211         pass "print value of leeway"
 212       }
 213     -re ".*$gdb_prompt $" { fail "print value of leeway" }
 214     timeout           { fail "(timeout) print value of leeway" }
 215   }
 216
 217
 218 send_gdb "ptype leeway\n"
 219 gdb_expect {
 220     -re "type = float.*$gdb_prompt $"  { pass "ptype leeway" }
 221     -re ".*$gdb_prompt $"   {  fail "ptype leeway" }
 222     timeout             { fail "(timeout) ptype leeway" }
 223 }
 224
 225
 226 send_gdb "print legacy\n"
 227 gdb_expect {
 228     -re ".\[0-9\]* = 70.*$gdb_prompt $" {
 229         pass "print value of legacy"
 230       }
 231     -re ".*$gdb_prompt $" { fail "print value of legacy" }
 232     timeout           { fail "(timeout) print value of legacy" }
 233   }
 234
 235
 236 send_gdb "ptype legacy\n"
 237 gdb_expect {
 238     -re "type = double.*$gdb_prompt $"  { pass "ptype legacy" }
 239     -re ".*$gdb_prompt $"   {  fail "ptype legacy" }
 240     timeout             { fail "(timeout) ptype legacy" }
 241 }
 242
 243
 244 send_gdb "print laconic\n"
 245 gdb_expect {
 246     -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
 247         pass "print value of laconic"
 248       }
 249     -re ".*$gdb_prompt $" { fail "print value of laconic" }
 250     timeout           { fail "(timeout) print value of laconic" }
 251   }
 252
 253
 254 send_gdb "ptype laconic\n"
 255 gdb_expect {
 256     -re "type = const char.*$gdb_prompt $"  { pass "ptype laconic" }
 257     -re ".*$gdb_prompt $"   {  fail "ptype laconic" }
 258     timeout             { fail "(timeout) ptype laconic" }
 259 }
 260
 261
 262 send_gdb "print laggard\n"
 263 gdb_expect {
 264     -re ".\[0-9\]* = 1 \'.001\'.*$gdb_prompt $" {
 265         pass "print value of laggard"
 266       }
 267     -re ".*$gdb_prompt $" { fail "print value of laggard" }
 268     timeout           { fail "(timeout) print value of laggard" }
 269   }
 270
 271
 272 send_gdb "ptype laggard\n"
 273 gdb_expect {
 274     -re "type = const unsigned char.*$gdb_prompt $"  { pass "ptype laggard" }
 275     -re ".*$gdb_prompt $"   {  fail "ptype laggard" }
 276     timeout             { fail "(timeout) ptype laggard" }
 277 }
 278
 279
 280 send_gdb "print lagoon\n"
 281 gdb_expect {
 282     -re ".\[0-9\]* = 2.*$gdb_prompt $" {
 283         pass "print value of  lagoon"
 284       }
 285     -re ".*$gdb_prompt $" { fail "print value of lagoon" }
 286     timeout           { fail "(timeout) print value of lagoon" }
 287   }
 288
 289
 290 send_gdb "ptype lagoon\n"
 291 gdb_expect {
 292     -re "type = const short.*$gdb_prompt $"  { pass "ptype lagoon" }
 293     -re ".*$gdb_prompt $"   {  fail "ptype lagoon" }
 294     timeout             { fail "(timeout) ptype lagoon" }
 295 }
 296
 297
 298 send_gdb "print laity\n"
 299 gdb_expect {
 300     -re ".\[0-9\]* = 3.*$gdb_prompt $" {
 301         pass "print value of laity"
 302       }
 303     -re ".*$gdb_prompt $" { fail "print value of laity" }
 304     timeout           { fail "(timeout) print value of laity" }
 305   }
 306
 307
 308 send_gdb "ptype laity\n"
 309 gdb_expect {
 310     -re "type = const unsigned short.*$gdb_prompt $"  { pass "ptype laity" }
 311     -re ".*$gdb_prompt $"   {  fail "ptype laity" }
 312     timeout             { fail "(timeout) ptype "laity }
 313 }
 314
 315
 316 send_gdb "print lambent\n"
 317 gdb_expect {
 318     -re ".\[0-9\]* = 4.*$gdb_prompt $" {
 319         pass "print value of lambent"
 320       }
 321     -re ".*$gdb_prompt $" { fail "print value of lambent" }
 322     timeout           { fail "(timeout) print value of lambent" }
 323   }
 324
 325
 326 send_gdb "ptype lambent\n"
 327 gdb_expect {
 328     -re "type = const long.*$gdb_prompt $"  { pass "ptype lambent" }
 329     -re ".*$gdb_prompt $"   {  fail "ptype lambent" }
 330     timeout             { fail "(timeout) ptype lambent" }
 331 }
 332
 333
 334 send_gdb "print laminated\n"
 335 gdb_expect {
 336     -re ".\[0-9\]* = 5.*$gdb_prompt $" {
 337         pass "print value of laminated"
 338       }
 339     -re ".*$gdb_prompt $" { fail "print value of laminated" }
 340     timeout           { fail "(timeout) print value of laminated" }
 341   }
 342
 343
 344 send_gdb "ptype laminated\n"
 345 gdb_expect {
 346     -re "type = const unsigned long.*$gdb_prompt $"  { pass "ptype laminated" }
 347     -re ".*$gdb_prompt $"   {  fail "ptype laminated" }
 348     timeout             { fail "(timeout) ptype laminated" }
 349 }
 350
 351
 352 send_gdb "print lampoon\n"
 353 gdb_expect {
 354     -re ".\[0-9\]* = 6.*$gdb_prompt $" {
 355         pass "print value of lampoon"
 356       }
 357     -re ".*$gdb_prompt $" { fail "print value of lampoon" }
 358     timeout           { fail "(timeout) print value of lampoon" }
 359   }
 360
 361
 362 send_gdb "ptype lampoon\n"
 363 gdb_expect {
 364     -re "type = const float.*$gdb_prompt $"  { pass "ptype lampoon" }
 365     -re ".*$gdb_prompt $"   {  fail "ptype lampoon" }
 366     timeout             { fail "(timeout) ptype lampoon" }
 367 }
 368
 369
 370 send_gdb "print languid\n"
 371 gdb_expect {
 372     -re ".\[0-9\]* = 7.*$gdb_prompt $" {
 373         pass "print value of languid"
 374       }
 375     -re ".*$gdb_prompt $" { fail "print value of languid" }
 376     timeout           { fail "(timeout) print value of languid" }
 377   }
 378
 379
 380 send_gdb "ptype languid\n"
 381 gdb_expect {
 382     -re "type = const double.*$gdb_prompt $"  { pass "ptype languid" }
 383     -re ".*$gdb_prompt $"   {  fail "ptype languid" }
 384     timeout             { fail "(timeout) ptype languid" }
 385 }
 386
 387
 388 send_gdb "print *legend\n"
 389 gdb_expect {
 390     -re ".\[0-9\]* = 66 \'B\'.*$gdb_prompt $" {
 391         pass "print value of *legend"
 392       }
 393     -re ".*$gdb_prompt $" { fail "print value of *legend" }
 394     timeout           { fail "(timeout) print value of *legend" }
 395   }
 396
 397
 398 send_gdb "ptype legend\n"
 399 gdb_expect {
 400     -re "type = const char \\*.*$gdb_prompt $"  { pass "ptype legend" }
 401     -re ".*$gdb_prompt $"   {  fail "ptype legend" }
 402     timeout             { fail "(timeout) ptype legend" }
 403 }
 404
 405
 406 send_gdb "print *legerdemain\n"
 407 gdb_expect {
 408     -re ".\[0-9\]* = 10 \'\\\\n\'.*$gdb_prompt $" {
 409         pass "print value of  *legerdemain"
 410       }
 411     -re ".*$gdb_prompt $" { fail "print value of  *legerdemain" }
 412     timeout           { fail "(timeout) print value of  *legerdemain" }
 413   }
 414
 415
 416 send_gdb "ptype  legerdemain\n"
 417 gdb_expect {
 418     -re "type = const unsigned char \\*.*$gdb_prompt $"  { pass "ptype  legerdemain" }
 419     -re ".*$gdb_prompt $"   {  fail "ptype  legerdemain" }
 420     timeout             { fail "(timeout) ptype  legerdemain" }
 421 }
 422
 423
 424 send_gdb "print *leniency\n"
 425 gdb_expect {
 426     -re ".\[0-9\]* = 20.*$gdb_prompt $" {
 427         pass "print value of *leniency"
 428       }
 429     -re ".*$gdb_prompt $" { fail "print value of *leniency" }
 430     timeout           { fail "(timeout) print value of *leniency" }
 431   }
 432
 433
 434 send_gdb "ptype leniency\n"
 435 gdb_expect {
 436     -re "type = const short \\*.*$gdb_prompt $"  { pass "ptype leniency" }
 437     -re ".*$gdb_prompt $"   {  fail "ptype leniency " }
 438     timeout             { fail "(timeout) ptype leniency" }
 439 }
 440
 441
 442 send_gdb "print *leonine\n"
 443 gdb_expect {
 444     -re ".\[0-9\]* = 30.*$gdb_prompt $" {
 445         pass "print value of *leonine"
 446       }
 447     -re ".*$gdb_prompt $" { fail "print value of *leonine" }
 448     timeout           { fail "(timeout) print value of *leonine" }
 449   }
 450
 451
 452 send_gdb "ptype leonine\n"
 453 gdb_expect {
 454     -re "type = const unsigned short \\*.*$gdb_prompt $"  { pass "ptype leonine" }
 455     -re ".*$gdb_prompt $"   {  fail "ptype leonine" }
 456     timeout             { fail "(timeout) ptype leonine" }
 457 }
 458
 459
 460 send_gdb "print *lesion\n"
 461 gdb_expect {
 462     -re ".\[0-9\]* = 40.*$gdb_prompt $" {
 463         pass "print value of *lesion"
 464       }
 465     -re ".*$gdb_prompt $" { fail "print value of *lesion" }
 466     timeout           { fail "(timeout) print value of *lesion" }
 467   }
 468
 469
 470 send_gdb "ptype lesion\n"
 471 gdb_expect {
 472     -re "type = const long \\*.*$gdb_prompt $"  { pass "ptype lesion" }
 473     -re ".*$gdb_prompt $"   {  fail "ptype lesion" }
 474     timeout             { fail "(timeout) ptype lesion" }
 475 }
 476
 477
 478 send_gdb "print *lethal\n"
 479 gdb_expect {
 480     -re ".\[0-9\]* = 50.*$gdb_prompt $" {
 481         pass "print value of *lethal"
 482       }
 483     -re ".*$gdb_prompt $" { fail "print value of *lethal" }
 484     timeout           { fail "(timeout) print value of *lethal" }
 485   }
 486
 487
 488 send_gdb "ptype lethal\n"
 489 gdb_expect {
 490     -re "type = const unsigned long \\*.*$gdb_prompt $"  { pass "ptype lethal" }
 491     -re ".*$gdb_prompt $"   {  fail "ptype lethal" }
 492     timeout             { fail "(timeout) ptype lethal" }
 493 }
 494
 495
 496 send_gdb "print *lethargic\n"
 497 gdb_expect {
 498     -re ".\[0-9\]* = 60.*$gdb_prompt $" {
 499         pass "print value of *lethargic"
 500       }
 501     -re ".*$gdb_prompt $" { fail "print value of *lethargic" }
 502     timeout           { fail "(timeout) print value of *lethargic" }
 503   }
 504
 505
 506 send_gdb "ptype lethargic\n"
 507 gdb_expect {
 508     -re "type = const float \\*.*$gdb_prompt $"  { pass "ptype lethargic" }
 509     -re ".*$gdb_prompt $"   {  fail "ptype lethargic" }
 510     timeout             { fail "(timeout) ptype lethargic" }
 511 }
 512
 513
 514 send_gdb "print *levity\n"
 515 gdb_expect {
 516     -re ".\[0-9\]* = 70.*$gdb_prompt $" {
 517         pass "print value of *levity"
 518       }
 519     -re ".*$gdb_prompt $" { fail "print value of *levity" }
 520     timeout           { fail "(timeout) print value of *levity" }
 521   }
 522
 523
 524 send_gdb "ptype levity\n"
 525 gdb_expect {
 526     -re "type = const double \\*.*$gdb_prompt $"  { pass "ptype levity" }
 527     -re ".*$gdb_prompt $"   {  fail "ptype levity" }
 528     timeout             { fail "(timeout) ptype levity" }
 529 }
 530
 531
 532 send_gdb "print *lewd\n"
 533 gdb_expect {
 534     -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
 535         pass "print value of *lewd"
 536       }
 537     -re ".*$gdb_prompt $" { fail "print value of *lewd" }
 538     timeout           { fail "(timeout) print value of *lewd" }
 539   }
 540
 541
 542 send_gdb "ptype lewd\n"
 543 gdb_expect {
 544     -re "type = const char \\* const.*$gdb_prompt $"  { pass "ptype lewd" }
 545     -re ".*$gdb_prompt $"   {  fail "ptype lewd" }
 546     timeout             { fail "(timeout) ptype lewd" }
 547 }
 548
 549
 550 send_gdb "print *lexicographer\n"
 551 gdb_expect {
 552     -re ".\[0-9\]* = 1 \'.001\'.*$gdb_prompt $" {
 553         pass "print value of *lexicographer"
 554       }
 555     -re ".*$gdb_prompt $" { fail "print value of *lexicographer" }
 556     timeout           { fail "(timeout) print value of *lexicographer" }
 557   }
 558
 559
 560 send_gdb "ptype lexicographer\n"
 561 gdb_expect {
 562     -re "type = const unsigned char \\* const.*$gdb_prompt $"  { pass "ptype lexicographer" }
 563     -re ".*$gdb_prompt $"   {  fail "ptype lexicographer" }
 564     timeout             { fail "(timeout) ptype lexicographer" }
 565 }
 566
 567
 568 send_gdb "print *lexicon\n"
 569 gdb_expect {
 570     -re ".\[0-9\]* = 2.*$gdb_prompt $" {
 571         pass "print value of *lexicon"
 572       }
 573     -re ".*$gdb_prompt $" { fail "print value of *lexicon" }
 574     timeout           { fail "(timeout) print value of *lexicon" }
 575   }
 576
 577
 578 send_gdb "ptype lexicon\n"
 579 gdb_expect {
 580     -re "type = const short \\* const.*$gdb_prompt $"  { pass "ptype lexicon" }
 581     -re ".*$gdb_prompt $"   {  fail "ptype lexicon" }
 582     timeout             { fail "(timeout) ptype lexicon" }
 583 }
 584
 585
 586 send_gdb "print *liaison\n"
 587 gdb_expect {
 588     -re ".\[0-9\]* = 3.*$gdb_prompt $" {
 589         pass "print value of *liaison"
 590       }
 591     -re ".*$gdb_prompt $" { fail "print value of *liaison" }
 592     timeout           { fail "(timeout) print value of *liaison" }
 593   }
 594
 595
 596 send_gdb "ptype liaison\n"
 597 gdb_expect {
 598     -re "type = const unsigned short \\* const.*$gdb_prompt $"  { pass "ptype liaison" }
 599     -re ".*$gdb_prompt $"   {  fail "ptype liaison" }
 600     timeout             { fail "(timeout) ptype liaison" }
 601 }
 602
 603
 604 send_gdb "print *libation\n"
 605 gdb_expect {
 606     -re ".\[0-9\]* = 4.*$gdb_prompt $" {
 607         pass "print value of *libation"
 608       }
 609     -re ".*$gdb_prompt $" { fail "print value of *libation" }
 610     timeout           { fail "(timeout) print value of *libation" }
 611   }
 612
 613
 614 send_gdb "ptype libation\n"
 615 gdb_expect {
 616     -re "type = const long \\* const.*$gdb_prompt $"  { pass "ptype libation" }
 617     -re ".*$gdb_prompt $"   {  fail "ptype libation" }
 618     timeout             { fail "(timeout) ptype libation" }
 619 }
 620
 621
 622 send_gdb "print *libelous\n"
 623 gdb_expect {
 624     -re ".\[0-9\]* = 5.*$gdb_prompt $" {
 625         pass "print value of *libelous"
 626       }
 627     -re ".*$gdb_prompt $" { fail "print value of *libelous" }
 628     timeout           { fail "(timeout) print value of *libelous" }
 629   }
 630
 631
 632 send_gdb "ptype libelous\n"
 633 gdb_expect {
 634     -re "type = const unsigned long \\* const.*$gdb_prompt $"  { pass "ptype libelous" }
 635     -re ".*$gdb_prompt $"   {  fail "ptype libelous" }
 636     timeout             { fail "(timeout) ptype libelous" }
 637 }
 638
 639
 640 send_gdb "print *libertine\n"
 641 gdb_expect {
 642     -re ".\[0-9\]* = 6.*$gdb_prompt $" {
 643         pass "print value of *libertine"
 644       }
 645     -re ".*$gdb_prompt $" { fail "print value of *libertine" }
 646     timeout           { fail "(timeout) print value of *libertine" }
 647   }
 648
 649
 650 send_gdb "ptype libertine\n"
 651 gdb_expect {
 652     -re "type = const float \\* const.*$gdb_prompt $"  { pass "ptype libertine" }
 653     -re ".*$gdb_prompt $"   {  fail "ptype libertine" }
 654     timeout             { fail "(timeout) ptype libertine" }
 655 }
 656
 657
 658 send_gdb "print *libidinous\n"
 659 gdb_expect {
 660     -re ".\[0-9\]* = 7.*$gdb_prompt $" {
 661         pass "print value of *libidinous"
 662       }
 663     -re ".*$gdb_prompt $" { fail "print value of *libidinous" }
 664     timeout           { fail "(timeout) print value of *libidinous" }
 665   }
 666
 667
 668 send_gdb "ptype libidinous\n"
 669 gdb_expect {
 670     -re "type = const double \\* const.*$gdb_prompt $"  { pass "ptype libidinous" }
 671     -re ".*$gdb_prompt $"   {  fail "ptype libidinous" }
 672     timeout             { fail "(timeout) ptype libidinous" }
 673 }
 674
 675
 676 send_gdb "print *languish\n"
 677 gdb_expect {
 678     -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
 679         pass "print value of *languish"
 680       }
 681     -re ".*$gdb_prompt $" { fail "print value of *languish" }
 682     timeout           { fail "(timeout) print value of *languish" }
 683   }
 684
 685
 686 send_gdb "ptype languish\n"
 687 gdb_expect {
 688     -re "type = const char \\*.*$gdb_prompt $"  { pass "ptype languish" }
 689     -re ".*$gdb_prompt $"   {  fail "ptype languish" }
 690     timeout             { fail "(timeout) ptype languish" }
 691 }
 692
 693
 694 send_gdb "print *languor\n"
 695 gdb_expect {
 696     -re ".\[0-9\]* = 1 \'.001\'.*$gdb_prompt $" {
 697         pass "print value of *languor"
 698       }
 699     -re ".*$gdb_prompt $" { fail "print value of *languor" }
 700     timeout           { fail "(timeout) print value of *languor" }
 701   }
 702
 703
 704 send_gdb "ptype languor\n"
 705 gdb_expect {
 706     -re "type = const unsigned char \\*.*$gdb_prompt $"  { pass "ptype languor" }
 707     -re ".*$gdb_prompt $"   {  fail "ptype languor" }
 708     timeout             { fail "(timeout) ptype languor" }
 709 }
 710
 711
 712 send_gdb "print *lank\n"
 713 gdb_expect {
 714     -re ".\[0-9\]* = 2.*.*$gdb_prompt $" {
 715         pass "print value of *lank"
 716       }
 717     -re ".*$gdb_prompt $" { fail "print value of *lank" }
 718     timeout           { fail "(timeout) print value of *lank" }
 719   }
 720
 721
 722 send_gdb "ptype lank\n"
 723 gdb_expect {
 724     -re "type = const short \\*.*$gdb_prompt $"  { pass "ptype lank" }
 725     -re ".*$gdb_prompt $"   {  fail "ptype lank" }
 726     timeout             { fail "(timeout) ptype lank" }
 727 }
 728
 729
 730 send_gdb "print *lapidary\n"
 731 gdb_expect {
 732     -re ".\[0-9\]* = 3.*$gdb_prompt $" {
 733         pass "print value of *lapidary"
 734       }
 735     -re ".*$gdb_prompt $" { fail "print value of *lapidary" }
 736     timeout           { fail "(timeout) print value of *lapidary" }
 737   }
 738
 739
 740 send_gdb "ptype lapidary\n"
 741 gdb_expect {
 742     -re "type = const unsigned short \\*.*$gdb_prompt $"  { pass "ptype lapidary" }
 743     -re ".*$gdb_prompt $"   {  fail "ptype lapidary" }
 744     timeout             { fail "(timeout) ptype lapidary" }
 745 }
 746
 747
 748 send_gdb "print *larceny\n"
 749 gdb_expect {
 750     -re ".\[0-9\]* = 4.*$gdb_prompt $" {
 751         pass "print value of *larceny"
 752       }
 753     -re ".*$gdb_prompt $" { fail "print value of *larceny" }
 754     timeout           { fail "(timeout) print value of *larceny" }
 755   }
 756
 757
 758 send_gdb "ptype larceny\n"
 759 gdb_expect {
 760     -re "type = const long \\*.*$gdb_prompt $"  { pass "ptype larceny" }
 761     -re ".*$gdb_prompt $"   {  fail "ptype larceny" }
 762     timeout             { fail "(timeout) ptype larceny" }
 763 }
 764
 765
 766 send_gdb "print *largess\n"
 767 gdb_expect {
 768     -re ".\[0-9\]* = 5.*$gdb_prompt $" {
 769         pass "print value of *largess"
 770       }
 771     -re ".*$gdb_prompt $" { fail "print value of *largess" }
 772     timeout           { fail "(timeout) print value of *largess" }
 773   }
 774
 775
 776 send_gdb "ptype largess\n"
 777 gdb_expect {
 778     -re "type = const unsigned long \\*.*$gdb_prompt $"  { pass "ptype largess" }
 779     -re ".*$gdb_prompt $"   {  fail "ptype largess" }
 780     timeout             { fail "(timeout) ptype largess" }
 781 }
 782
 783
 784 send_gdb "print *lascivious\n"
 785 gdb_expect {
 786     -re ".\[0-9\]* = 6.*$gdb_prompt $" {
 787         pass "print value of *lascivious"
 788       }
 789     -re ".*$gdb_prompt $" { fail "print value of *lascivious" }
 790     timeout           { fail "(timeout) print value of *lascivious" }
 791   }
 792
 793
 794 send_gdb "ptype lascivious\n"
 795 gdb_expect {
 796     -re "type = const float \\*.*$gdb_prompt $"  { pass "ptype lascivious" }
 797     -re ".*$gdb_prompt $"   {  fail "ptype lascivious" }
 798     timeout             { fail "(timeout) ptype lascivious" }
 799 }
 800
 801
 802 send_gdb "print *lassitude\n"
 803 gdb_expect {
 804     -re ".\[0-9\]* = 7.*$gdb_prompt $" {
 805         pass "print value of *lassitude"
 806       }
 807     -re ".*$gdb_prompt $" { fail "print value of *lassitude" }
 808     timeout           { fail "(timeout) print value of *lassitude" }
 809   }
 810
 811
 812 send_gdb "ptype lassitude\n"
 813 gdb_expect {
 814     -re "type = const double \\*.*$gdb_prompt $"  { pass "ptype lassitude" }
 815     -re ".*$gdb_prompt $"   {  fail "ptype lassitude" }
 816     timeout             { fail "(timeout) ptype lassitude" }
 817 }
 818
 819
 820 send_gdb "print *lamprey\n"
 821 gdb_expect {
 822     -re  ".\[0-9\]* = 66 \'B\'.*$gdb_prompt $" {
 823         pass "print value of *lamprey"
 824       }
 825     -re ".*$gdb_prompt $" { fail "print value of *lamprey" }
 826     timeout           { fail "(timeout) print value of *lamprey" }
 827   }
 828
 829
 830 send_gdb "ptype lamprey\n"
 831 gdb_expect {
 832     -re "type = char \\* const.*$gdb_prompt $"  { pass "ptype lamprey" }
 833     -re ".*$gdb_prompt $"   {  fail "ptype lamprey" }
 834     timeout             { fail "(timeout) ptype lamprey" }
 835 }
 836
 837 send_gdb "print *lariat\n"
 838 gdb_expect {
 839     -re  ".\[0-9\]* = 10 \'\\\\n\'.*$gdb_prompt $" {
 840         pass "print value of *lariat"
 841       }
 842     -re ".*$gdb_prompt $" { fail "print value of *lariat" }
 843     timeout           { fail "(timeout) print value of *lariat" }
 844   }
 845
 846
 847 send_gdb "ptype lariat\n"
 848 gdb_expect {
 849     -re "type = unsigned char \\* const.*$gdb_prompt $"  { pass "ptype lariat" }
 850     -re ".*$gdb_prompt $"   {  fail "ptype lariat" }
 851     timeout             { fail "(timeout) ptype lariat" }
 852 }
 853
 854 send_gdb "print *laudanum\n"
 855 gdb_expect {
 856     -re ".\[0-9\]* = 20.*$gdb_prompt $" {
 857         pass "print value of *laudanum"
 858       }
 859     -re ".*$gdb_prompt $" { fail "print value of *laudanum" }
 860     timeout           { fail "(timeout) print value of *laudanum" }
 861   }
 862
 863
 864 send_gdb "ptype laudanum\n"
 865 gdb_expect {
 866     -re "type = short \\* const.*$gdb_prompt $"  { pass "ptype laudanum" }
 867     -re ".*$gdb_prompt $"   {  fail "ptype laudanum" }
 868     timeout             { fail "(timeout) ptype laudanum" }
 869 }
 870
 871 send_gdb "print *lecithin\n"
 872 gdb_expect {
 873     -re  ".\[0-9\]* = 30.*$gdb_prompt $" {
 874         pass "print value of *lecithin"
 875       }
 876     -re ".*$gdb_prompt $" { fail "print value of *lecithin" }
 877     timeout           { fail "(timeout) print value of *lecithin" }
 878   }
 879
 880
 881 send_gdb "ptype lecithin\n"
 882 gdb_expect {
 883     -re "type = unsigned short \\* const.*$gdb_prompt $"  { pass "ptype lecithin" }
 884     -re ".*$gdb_prompt $"   {  fail "ptype lecithin" }
 885     timeout             { fail "(timeout) ptype lecithin" }
 886 }
 887
 888 send_gdb "print *leviathan\n"
 889 gdb_expect {
 890     -re  ".\[0-9\]* = 40.*$gdb_prompt $" {
 891         pass "print value of *leviathan"
 892       }
 893     -re ".*$gdb_prompt $" { fail "print value of *leviathan" }
 894     timeout           { fail "(timeout) print value of *leviathan" }
 895   }
 896
 897
 898 send_gdb "ptype leviathan\n"
 899 gdb_expect {
 900     -re "type = long \\* const.*$gdb_prompt $"  { pass "ptype leviathan" }
 901     -re ".*$gdb_prompt $"   {  fail "ptype leviathan" }
 902     timeout             { fail "(timeout) ptype leviathan" }
 903 }
 904
 905 send_gdb "print *libretto\n"
 906 gdb_expect {
 907     -re  ".\[0-9\]* = 50.*$gdb_prompt $" {
 908         pass "print value of *libretto"
 909       }
 910     -re ".*$gdb_prompt $" { fail "print value of *libretto" }
 911     timeout           { fail "(timeout) print value of *libretto" }
 912   }
 913
 914
 915 send_gdb "ptype libretto\n"
 916 gdb_expect {
 917     -re "type = unsigned long \\* const.*$gdb_prompt $"  { pass "ptype libretto" }
 918     -re ".*$gdb_prompt $"   {  fail "ptype libretto" }
 919     timeout             { fail "(timeout) ptype libretto" }
 920 }
 921
 922
 923 send_gdb "print *lissome\n"
 924 gdb_expect {
 925     -re  ".\[0-9\]* = 60.*$gdb_prompt $" {
 926         pass "print value of *lissome"
 927       }
 928     -re ".*$gdb_prompt $" { fail "print value of *lissome" }
 929     timeout           { fail "(timeout) print value of *lissome" }
 930   }
 931
 932
 933 send_gdb "ptype lissome\n"
 934 gdb_expect {
 935     -re "type = float \\* const.*$gdb_prompt $"  { pass "ptype lissome" }
 936     -re ".*$gdb_prompt $"   {  fail "ptype lissome" }
 937     timeout             { fail "(timeout) ptype lissome" }
 938 }
 939
 940 send_gdb "print *locust\n"
 941 gdb_expect {
 942     -re  ".\[0-9\]* = 70.*$gdb_prompt $" {
 943         pass "print value of *locust"
 944       }
 945     -re ".*$gdb_prompt $" { fail "print value of *locust" }
 946     timeout           { fail "(timeout) print value of *locust" }
 947   }
 948
 949
 950 send_gdb "ptype locust\n"
 951 gdb_expect {
 952     -re "type = double \\* const.*$gdb_prompt $"  { pass "ptype locust" }
 953     -re ".*$gdb_prompt $"   {  fail "ptype locust" }
 954     timeout             { fail "(timeout) ptype locust" }
 955 }
 956
 957 send_gdb "ptype radiation\n"
 958 gdb_expect {
 959     -re "type = const char &.*$gdb_prompt $"  { pass "ptype radiation" }
 960     -re ".*$gdb_prompt $"   {  fail "ptype radiation" }
 961     timeout             { fail "(timeout) ptype radiation" }
 962 }
 963