sim/common/hw-tree.c

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002, 2007 Free Software Foundation, Inc.
   4
   5    Contributed by Andrew Cagney and Red Hat.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "hw-main.h"
  24 #include "hw-base.h"
  25 #include "hw-tree.h"
  26
  27 #include "sim-io.h"
  28 #include "sim-assert.h"
  29
  30 #ifdef HAVE_STDLIB_H
  31 #include <stdlib.h>
  32 #endif
  33
  34 #ifdef HAVE_STRING_H
  35 #include <string.h>
  36 #else
  37 #ifdef HAVE_STRINGS_H
  38 #include <strings.h>
  39 #endif
  40 #endif
  41
  42 #include <ctype.h>
  43
  44 /* manipulate/lookup device names */
  45
  46 typedef struct _name_specifier {
  47
  48   /* components in the full length name */
  49   char *path;
  50   char *property;
  51   char *value;
  52
  53   /* current device */
  54   char *family;
  55   char *name;
  56   char *unit;
  57   char *args;
  58
  59   /* previous device */
  60   char *last_name;
  61   char *last_family;
  62   char *last_unit;
  63   char *last_args;
  64
  65   /* work area */
  66   char buf[1024];
  67
  68 } name_specifier;
  69
  70
  71
  72 /* Given a device specifier, break it up into its main components:
  73    path (and if present) property name and property value. */
  74
  75 static int
  76 split_device_specifier (struct hw *current,
  77                         const char *device_specifier,
  78                         name_specifier *spec)
  79 {
  80   char *chp = NULL;
  81
  82   /* expand any leading alias if present */
  83   if (current != NULL
  84       && *device_specifier != '\0'
  85       && *device_specifier != '.'
  86       && *device_specifier != '/')
  87     {
  88       struct hw *aliases = hw_tree_find_device (current, "/aliases");
  89       char alias[32];
  90       int len = 0;
  91       while (device_specifier[len] != '\0'
  92              && device_specifier[len] != '/'
  93              && device_specifier[len] != ':'
  94              && !isspace (device_specifier[len]))
  95         {
  96           alias[len] = device_specifier[len];
  97           len++;
  98           if (len >= sizeof(alias))
  99             hw_abort (NULL, "split_device_specifier: buffer overflow");
 100         }
 101       alias[len] = '\0';
 102       if (aliases != NULL
 103           && hw_find_property (aliases, alias))
 104         {
 105           strcpy (spec->buf, hw_find_string_property(aliases, alias));
 106           strcat (spec->buf, device_specifier + len);
 107         }
 108       else
 109         {
 110           strcpy (spec->buf, device_specifier);
 111         }
 112     }
 113   else
 114     {
 115       strcpy(spec->buf, device_specifier);
 116     }
 117
 118   /* check no overflow */
 119   if (strlen(spec->buf) >= sizeof(spec->buf))
 120     hw_abort (NULL, "split_device_specifier: buffer overflow\n");
 121
 122   /* strip leading spaces */
 123   chp = spec->buf;
 124   while (*chp != '\0' && isspace(*chp))
 125     chp++;
 126   if (*chp == '\0')
 127     return 0;
 128
 129   /* find the path and terminate it with null */
 130   spec->path = chp;
 131   while (*chp != '\0' && !isspace(*chp))
 132     chp++;
 133   if (*chp != '\0')
 134     {
 135       *chp = '\0';
 136       chp++;
 137     }
 138
 139   /* and any value */
 140   while (*chp != '\0' && isspace(*chp))
 141     chp++;
 142   spec->value = chp;
 143
 144   /* now go back and chop the property off of the path */
 145   if (spec->value[0] == '\0')
 146     {
 147       spec->property = NULL; /*not a property*/
 148       spec->value = NULL;
 149     }
 150   else if (spec->value[0] == '>'
 151            || spec->value[0] == '<')
 152     {
 153       /* an interrupt spec */
 154       spec->property = NULL;
 155     }
 156   else {
 157     chp = strrchr(spec->path, '/');
 158     if (chp == NULL)
 159       {
 160         spec->property = spec->path;
 161         spec->path = strchr(spec->property, '\0');
 162       }
 163     else {
 164       *chp = '\0';
 165       spec->property = chp+1;
 166     }
 167   }
 168
 169   /* and mark the rest as invalid */
 170   spec->name = NULL;
 171   spec->family = NULL;
 172   spec->unit = NULL;
 173   spec->args = NULL;
 174   spec->last_name = NULL;
 175   spec->last_family = NULL;
 176   spec->last_unit = NULL;
 177   spec->last_args = NULL;
 178
 179   return 1;
 180 }
 181
 182
 183 /* given a device specifier break it up into its main components -
 184    path and property name - assuming that the last `device' is a
 185    property name. */
 186
 187 static int
 188 split_property_specifier (struct hw *current,
 189                           const char *property_specifier,
 190                           name_specifier *spec)
 191 {
 192   if (split_device_specifier (current, property_specifier, spec))
 193     {
 194       if (spec->property == NULL)
 195         {
 196           /* force the last name to be a property name */
 197           char *chp = strrchr (spec->path, '/');
 198           if (chp == NULL)
 199             {
 200               spec->property = spec->path;
 201               spec->path = strrchr (spec->property, '\0');;
 202             }
 203           else
 204             {
 205               *chp = '\0';
 206               spec->property = chp + 1;
 207             }
 208         }
 209       return 1;
 210     }
 211   else
 212     return 0;
 213 }
 214
 215
 216 /* device the next device name and split it up, return 0 when no more
 217    names to struct hw */
 218
 219 static int
 220 split_device_name (name_specifier *spec)
 221 {
 222   char *chp;
 223   /* remember what came before */
 224   spec->last_name = spec->name;
 225   spec->last_family = spec->family;
 226   spec->last_unit = spec->unit;
 227   spec->last_args = spec->args;
 228   /* finished? */
 229   if (spec->path[0] == '\0')
 230     {
 231       spec->name = NULL;
 232       spec->family = NULL;
 233       spec->unit = NULL;
 234       spec->args = NULL;
 235       return 0;
 236     }
 237   /* break the current device spec from the path */
 238   spec->name = spec->path;
 239   chp = strchr (spec->name, '/');
 240   if (chp == NULL)
 241     spec->path = strchr (spec->name, '\0');
 242   else
 243     {
 244       spec->path = chp+1;
 245       *chp = '\0';
 246     }
 247   /* break out the base */
 248   if (spec->name[0] == '(')
 249     {
 250       chp = strchr(spec->name, ')');
 251       if (chp == NULL)
 252         {
 253           spec->family = spec->name;
 254         }
 255       else
 256         {
 257           *chp = '\0';
 258           spec->family = spec->name + 1;
 259           spec->name = chp + 1;
 260         }
 261     }
 262   else
 263     {
 264       spec->family = spec->name;
 265     }
 266   /* now break out the unit */
 267   chp = strchr(spec->name, '@');
 268   if (chp == NULL)
 269     {
 270       spec->unit = NULL;
 271       chp = spec->name;
 272     }
 273   else
 274     {
 275       *chp = '\0';
 276       chp += 1;
 277       spec->unit = chp;
 278     }
 279   /* finally any args */
 280   chp = strchr(chp, ':');
 281   if (chp == NULL)
 282     spec->args = NULL;
 283   else
 284     {
 285       *chp = '\0';
 286       spec->args = chp+1;
 287     }
 288   return 1;
 289 }
 290
 291
 292 /* device the value, returning the next non-space token */
 293
 294 static char *
 295 split_value (name_specifier *spec)
 296 {
 297   char *token;
 298   if (spec->value == NULL)
 299     return NULL;
 300   /* skip leading white space */
 301   while (isspace (spec->value[0]))
 302     spec->value++;
 303   if (spec->value[0] == '\0')
 304     {
 305       spec->value = NULL;
 306       return NULL;
 307     }
 308   token = spec->value;
 309   /* find trailing space */
 310   while (spec->value[0] != '\0' && !isspace (spec->value[0]))
 311     spec->value++;
 312   /* chop this value out */
 313   if (spec->value[0] != '\0')
 314     {
 315       spec->value[0] = '\0';
 316       spec->value++;
 317     }
 318   return token;
 319 }
 320
 321
 322
 323 /* traverse the path specified by spec starting at current */
 324
 325 static struct hw *
 326 split_find_device (struct hw *current,
 327                    name_specifier *spec)
 328 {
 329   /* strip off (and process) any leading ., .., ./ and / */
 330   while (1)
 331     {
 332       if (strncmp (spec->path, "/", strlen ("/")) == 0)
 333         {
 334           /* cd /... */
 335           while (current != NULL && hw_parent (current) != NULL)
 336             current = hw_parent (current);
 337           spec->path += strlen ("/");
 338         }
 339       else if (strncmp (spec->path, "./", strlen ("./")) == 0)
 340         {
 341           /* cd ./... */
 342           current = current;
 343           spec->path += strlen ("./");
 344         }
 345       else if (strncmp (spec->path, "../", strlen ("../")) == 0)
 346         {
 347           /* cd ../... */
 348           if (current != NULL && hw_parent (current) != NULL)
 349             current = hw_parent (current);
 350           spec->path += strlen ("../");
 351         }
 352       else if (strcmp (spec->path, ".") == 0)
 353         {
 354           /* cd . */
 355           current = current;
 356           spec->path += strlen (".");
 357         }
 358       else if (strcmp (spec->path, "..") == 0)
 359         {
 360           /* cd .. */
 361           if (current != NULL && hw_parent (current) != NULL)
 362             current = hw_parent (current);
 363           spec->path += strlen ("..");
 364         }
 365       else
 366         break;
 367     }
 368
 369   /* now go through the path proper */
 370
 371   if (current == NULL)
 372     {
 373       split_device_name (spec);
 374       return NULL;
 375     }
 376
 377   while (split_device_name (spec))
 378     {
 379       struct hw *child;
 380       for (child = hw_child (current);
 381            child != NULL; child = hw_sibling (child))
 382         {
 383           if (strcmp (spec->name, hw_name (child)) == 0)
 384             {
 385               if (spec->unit == NULL)
 386                 break;
 387               else
 388                 {
 389                   hw_unit phys;
 390                   hw_unit_decode (current, spec->unit, &phys);
 391                   if (memcmp (&phys, hw_unit_address (child),
 392                               sizeof (hw_unit)) == 0)
 393                     break;
 394                 }
 395             }
 396         }
 397       if (child == NULL)
 398         return current; /* search failed */
 399       current = child;
 400     }
 401
 402   return current;
 403 }
 404
 405
 406 static struct hw *
 407 split_fill_path (struct hw *current,
 408                  const char *device_specifier,
 409                  name_specifier *spec)
 410 {
 411   /* break it up */
 412   if (!split_device_specifier (current, device_specifier, spec))
 413     hw_abort (current, "error parsing %s\n", device_specifier);
 414
 415   /* fill our tree with its contents */
 416   current = split_find_device (current, spec);
 417
 418   /* add any additional devices as needed */
 419   if (spec->name != NULL)
 420     {
 421       do
 422         {
 423           if (current != NULL && !hw_finished_p (current))
 424             hw_finish (current);
 425           current = hw_create (NULL,
 426                                current,
 427                                spec->family,
 428                                spec->name,
 429                                spec->unit,
 430                                spec->args);
 431         }
 432       while (split_device_name (spec));
 433     }
 434
 435   return current;
 436 }
 437
 438 \f
 439 /* <non-white-space> */
 440
 441 static const char *
 442 skip_token(const char *chp)
 443 {
 444   while (!isspace(*chp) && *chp != '\0')
 445     chp++;
 446   while (isspace(*chp) && *chp != '\0')
 447     chp++;
 448   return chp;
 449 }
 450
 451
 452 /* count the number of entries */
 453
 454 static int
 455 count_entries (struct hw *current,
 456                const char *property_name,
 457                const char *property_value,
 458                int modulo)
 459 {
 460   const char *chp = property_value;
 461   int nr_entries = 0;
 462   while (*chp != '\0')
 463     {
 464       nr_entries += 1;
 465       chp = skip_token (chp);
 466     }
 467   if ((nr_entries % modulo) != 0)
 468     {
 469       hw_abort (current, "incorrect number of entries for %s property %s, should be multiple of %d",
 470                 property_name, property_value, modulo);
 471     }
 472   return nr_entries / modulo;
 473 }
 474
 475
 476
 477 /* parse: <address> ::= <token> ; device dependant */
 478
 479 static const char *
 480 parse_address (struct hw *current,
 481                struct hw *bus,
 482                const char *chp,
 483                hw_unit *address)
 484 {
 485   if (hw_unit_decode (bus, chp, address) < 0)
 486     hw_abort (current, "invalid unit address in %s", chp);
 487   return skip_token (chp);
 488 }
 489
 490
 491 /* parse: <size> ::= <number> { "," <number> } ; */
 492
 493 static const char *
 494 parse_size (struct hw *current,
 495             struct hw *bus,
 496             const char *chp,
 497             hw_unit *size)
 498 {
 499   int i;
 500   int nr;
 501   const char *curr = chp;
 502   memset(size, 0, sizeof(*size));
 503   /* parse the numeric list */
 504   size->nr_cells = hw_unit_nr_size_cells (bus);
 505   nr = 0;
 506   while (1)
 507     {
 508       char *next;
 509       size->cells[nr] = strtoul (curr, &next, 0);
 510       if (curr == next)
 511         hw_abort (current, "Problem parsing <size> %s", chp);
 512       nr += 1;
 513       if (next[0] != ',')
 514         break;
 515       if (nr == size->nr_cells)
 516         hw_abort (current, "Too many values in <size> %s", chp);
 517       curr = next + 1;
 518     }
 519   ASSERT (nr > 0 && nr <= size->nr_cells);
 520   /* right align the numbers */
 521   for (i = 1; i <= size->nr_cells; i++)
 522     {
 523       if (i <= nr)
 524         size->cells[size->nr_cells - i] = size->cells[nr - i];
 525       else
 526         size->cells[size->nr_cells - i] = 0;
 527     }
 528   return skip_token (chp);
 529 }
 530
 531
 532 /* parse: <reg> ::= { <address> <size> } ; */
 533
 534 static void
 535 parse_reg_property (struct hw *current,
 536                     const char *property_name,
 537                     const char *property_value)
 538 {
 539   int nr_regs;
 540   int reg_nr;
 541   reg_property_spec *regs;
 542   const char *chp;
 543
 544   /* determine the number of reg entries by counting tokens */
 545   nr_regs = count_entries (current, property_name, property_value, 2);
 546
 547   /* create working space */
 548   regs = zalloc (nr_regs * sizeof (*regs));
 549
 550   /* fill it in */
 551   chp = property_value;
 552   for (reg_nr = 0; reg_nr < nr_regs; reg_nr++)
 553     {
 554       chp = parse_address (current, hw_parent(current),
 555                            chp, &regs[reg_nr].address);
 556       chp = parse_size (current, hw_parent(current),
 557                         chp, &regs[reg_nr].size);
 558     }
 559
 560   /* create it */
 561   hw_add_reg_array_property (current, property_name,
 562                              regs, nr_regs);
 563
 564   zfree (regs);
 565 }
 566
 567
 568 /* { <child-address> <parent-address> <child-size> }* */
 569
 570 static void
 571 parse_ranges_property (struct hw *current,
 572                        const char *property_name,
 573                        const char *property_value)
 574 {
 575   int nr_ranges;
 576   int range_nr;
 577   range_property_spec *ranges;
 578   const char *chp;
 579
 580   /* determine the number of ranges specified */
 581   nr_ranges = count_entries (current, property_name, property_value, 3);
 582
 583   /* create a property of that size */
 584   ranges = zalloc (nr_ranges * sizeof(*ranges));
 585
 586   /* fill it in */
 587   chp = property_value;
 588   for (range_nr = 0; range_nr < nr_ranges; range_nr++)
 589     {
 590       chp = parse_address (current, current,
 591                            chp, &ranges[range_nr].child_address);
 592       chp = parse_address (current, hw_parent(current),
 593                            chp, &ranges[range_nr].parent_address);
 594       chp = parse_size (current, current,
 595                         chp, &ranges[range_nr].size);
 596     }
 597
 598   /* create it */
 599   hw_add_range_array_property (current, property_name, ranges, nr_ranges);
 600
 601   zfree (ranges);
 602 }
 603
 604
 605 /* <integer> ... */
 606
 607 static void
 608 parse_integer_property (struct hw *current,
 609                         const char *property_name,
 610                         const char *property_value)
 611 {
 612   int nr_entries;
 613   unsigned_cell words[1024];
 614   /* integer or integer array? */
 615   nr_entries = 0;
 616   while (1)
 617     {
 618       char *end;
 619       words[nr_entries] = strtoul (property_value, &end, 0);
 620       if (property_value == end)
 621         break;
 622       nr_entries += 1;
 623       if (nr_entries * sizeof (words[0]) >= sizeof (words))
 624         hw_abort (current, "buffer overflow");
 625       property_value = end;
 626     }
 627   if (nr_entries == 0)
 628     hw_abort (current, "error parsing integer property %s (%s)",
 629               property_name, property_value);
 630   else if (nr_entries == 1)
 631     hw_add_integer_property (current, property_name, words[0]);
 632   else
 633     {
 634       int i;
 635       for (i = 0; i < nr_entries; i++)
 636         {
 637           H2BE (words[i]);
 638         }
 639       /* perhaps integer array property is better */
 640       hw_add_array_property (current, property_name, words,
 641                              sizeof(words[0]) * nr_entries);
 642     }
 643 }
 644
 645
 646 /* <string> ... */
 647
 648 static void
 649 parse_string_property (struct hw *current,
 650                        const char *property_name,
 651                        const char *property_value)
 652 {
 653   char **strings;
 654   const char *chp;
 655   int nr_strings;
 656   int approx_nr_strings;
 657
 658   /* get an estimate as to the number of strings by counting double
 659      quotes */
 660   approx_nr_strings = 2;
 661   for (chp = property_value; *chp; chp++)
 662     {
 663       if (*chp == '"')
 664         approx_nr_strings++;
 665     }
 666   approx_nr_strings = (approx_nr_strings) / 2;
 667
 668   /* create a string buffer for that many (plus a null) */
 669   strings = (char**) zalloc ((approx_nr_strings + 1) * sizeof(char*));
 670
 671   /* now find all the strings */
 672   chp = property_value;
 673   nr_strings = 0;
 674   while (1)
 675     {
 676
 677       /* skip leading space */
 678       while (*chp != '\0' && isspace (*chp))
 679         chp += 1;
 680       if (*chp == '\0')
 681         break;
 682
 683       /* copy it in */
 684       if (*chp == '"')
 685         {
 686           /* a quoted string - watch for '\' et al. */
 687           /* estimate the size and allocate space for it */
 688           int pos;
 689           chp++;
 690           pos = 0;
 691           while (chp[pos] != '\0' && chp[pos] != '"')
 692             {
 693               if (chp[pos] == '\\' && chp[pos+1] != '\0')
 694                 pos += 2;
 695               else
 696                 pos += 1;
 697             }
 698           strings[nr_strings] = zalloc (pos + 1);
 699           /* copy the string over */
 700           pos = 0;
 701           while (*chp != '\0' && *chp != '"')
 702             {
 703               if (*chp == '\\' && *(chp+1) != '\0') {
 704                 strings[nr_strings][pos] = *(chp+1);
 705                 chp += 2;
 706                 pos++;
 707               }
 708               else
 709                 {
 710                   strings[nr_strings][pos] = *chp;
 711                   chp += 1;
 712                   pos++;
 713                 }
 714             }
 715           if (*chp != '\0')
 716             chp++;
 717           strings[nr_strings][pos] = '\0';
 718         }
 719       else
 720         {
 721           /* copy over a single unquoted token */
 722           int len = 0;
 723           while (chp[len] != '\0' && !isspace(chp[len]))
 724             len++;
 725           strings[nr_strings] = zalloc(len + 1);
 726           strncpy(strings[nr_strings], chp, len);
 727           strings[nr_strings][len] = '\0';
 728           chp += len;
 729         }
 730       nr_strings++;
 731       if (nr_strings > approx_nr_strings)
 732         hw_abort (current, "String property %s badly formatted",
 733                   property_name);
 734     }
 735   ASSERT (strings[nr_strings] == NULL); /* from zalloc */
 736
 737   /* install it */
 738   if (nr_strings == 0)
 739     hw_add_string_property (current, property_name, "");
 740   else if (nr_strings == 1)
 741     hw_add_string_property (current, property_name, strings[0]);
 742   else
 743     {
 744       const char **specs = (const char**) strings; /* stop a bogus error */
 745       hw_add_string_array_property (current, property_name,
 746                                     specs, nr_strings);
 747     }
 748
 749   /* flush the created string */
 750   while (nr_strings > 0)
 751     {
 752       nr_strings--;
 753       zfree (strings[nr_strings]);
 754     }
 755   zfree(strings);
 756 }
 757
 758
 759 /* <path-to-ihandle-device> */
 760
 761 #if NOT_YET
 762 static void
 763 parse_ihandle_property (struct hw *current,
 764                         const char *property,
 765                         const char *value)
 766 {
 767   ihandle_runtime_property_spec ihandle;
 768
 769   /* pass the full path */
 770   ihandle.full_path = value;
 771
 772   /* save this ready for the ihandle create */
 773   hw_add_ihandle_runtime_property (current, property,
 774                                    &ihandle);
 775 }
 776 #endif
 777
 778
 779 struct hw *
 780 hw_tree_create (SIM_DESC sd,
 781                 const char *family)
 782 {
 783   return hw_create (sd, NULL, family, family, NULL, NULL);
 784 }
 785
 786 void
 787 hw_tree_delete (struct hw *me)
 788 {
 789   /* Need to allow devices to disapear under our feet */
 790   while (hw_child (me) != NULL)
 791     {
 792       hw_tree_delete (hw_child (me));
 793     }
 794   hw_delete (me);
 795 }
 796
 797
 798 struct hw *
 799 hw_tree_parse (struct hw *current,
 800                const char *fmt,
 801                ...)
 802 {
 803     va_list ap;
 804     va_start (ap, fmt);
 805     current = hw_tree_vparse (current, fmt, ap);
 806     va_end (ap);
 807     return current;
 808 }
 809
 810 struct hw *
 811 hw_tree_vparse (struct hw *current,
 812                 const char *fmt,
 813                 va_list ap)
 814 {
 815   char device_specifier[1024];
 816   name_specifier spec;
 817
 818   /* format the path */
 819   vsprintf (device_specifier, fmt, ap);
 820   if (strlen (device_specifier) >= sizeof (device_specifier))
 821     hw_abort (NULL, "device_tree_add_deviced: buffer overflow\n");
 822
 823   /* construct the tree down to the final struct hw */
 824   current = split_fill_path (current, device_specifier, &spec);
 825
 826   /* is there an interrupt spec */
 827   if (spec.property == NULL
 828       && spec.value != NULL)
 829     {
 830       char *op = split_value (&spec);
 831       switch (op[0])
 832         {
 833         case '>':
 834           {
 835             char *my_port_name = split_value (&spec);
 836             int my_port;
 837             char *dest_port_name = split_value (&spec);
 838             int dest_port;
 839             name_specifier dest_spec;
 840             char *dest_hw_name = split_value (&spec);
 841             struct hw *dest;
 842             /* find my name */
 843             if (!hw_finished_p (current))
 844               hw_finish (current);
 845             my_port = hw_port_decode (current, my_port_name, output_port);
 846             /* find the dest device and port */
 847             dest = split_fill_path (current, dest_hw_name, &dest_spec);
 848             if (!hw_finished_p (dest))
 849               hw_finish (dest);
 850             dest_port = hw_port_decode (dest, dest_port_name,
 851                                         input_port);
 852             /* connect the two */
 853             hw_port_attach (current,
 854                             my_port,
 855                             dest,
 856                             dest_port,
 857                             permenant_object);
 858             break;
 859           }
 860         default:
 861           hw_abort (current, "unreconised interrupt spec %s\n", spec.value);
 862           break;
 863         }
 864     }
 865
 866   /* is there a property */
 867   if (spec.property != NULL)
 868     {
 869       if (strcmp (spec.value, "true") == 0)
 870         hw_add_boolean_property (current, spec.property, 1);
 871       else if (strcmp (spec.value, "false") == 0)
 872         hw_add_boolean_property (current, spec.property, 0);
 873       else
 874         {
 875           const struct hw_property *property;
 876           switch (spec.value[0])
 877             {
 878 #if NOT_YET
 879             case '*':
 880               {
 881                 parse_ihandle_property (current, spec.property, spec.value + 1);
 882                 break;
 883               }
 884 #endif
 885             case '[':
 886               {
 887                 unsigned8 words[1024];
 888                 char *curr = spec.value + 1;
 889                 int nr_words = 0;
 890                 while (1)
 891                   {
 892                     char *next;
 893                     words[nr_words] = H2BE_1 (strtoul (curr, &next, 0));
 894                     if (curr == next)
 895                       break;
 896                     curr = next;
 897                     nr_words += 1;
 898                   }
 899                 hw_add_array_property (current, spec.property,
 900                                        words, sizeof(words[0]) * nr_words);
 901                 break;
 902               }
 903             case '"':
 904               {
 905                 parse_string_property (current, spec.property, spec.value);
 906                 break;
 907               }
 908             case '!':
 909               {
 910                 spec.value++;
 911                 property = hw_tree_find_property (current, spec.value);
 912                 if (property == NULL)
 913                   hw_abort (current, "property %s not found\n", spec.value);
 914                 hw_add_duplicate_property (current,
 915                                            spec.property,
 916                                            property);
 917                 break;
 918               }
 919             default:
 920               {
 921                 if (strcmp (spec.property, "reg") == 0
 922                     || strcmp (spec.property, "assigned-addresses") == 0
 923                     || strcmp (spec.property, "alternate-reg") == 0)
 924                   {
 925                     parse_reg_property (current, spec.property, spec.value);
 926                   }
 927                 else if (strcmp (spec.property, "ranges") == 0)
 928                   {
 929                     parse_ranges_property (current, spec.property, spec.value);
 930                   }
 931                 else if (isdigit(spec.value[0])
 932                          || (spec.value[0] == '-' && isdigit(spec.value[1]))
 933                          || (spec.value[0] == '+' && isdigit(spec.value[1])))
 934                   {
 935                     parse_integer_property(current, spec.property, spec.value);
 936                   }
 937                 else
 938                   parse_string_property(current, spec.property, spec.value);
 939                 break;
 940               }
 941             }
 942         }
 943     }
 944   return current;
 945 }
 946
 947
 948 static void
 949 finish_hw_tree (struct hw *me,
 950                 void *data)
 951 {
 952   if (!hw_finished_p (me))
 953     hw_finish (me);
 954 }
 955
 956 void
 957 hw_tree_finish (struct hw *root)
 958 {
 959   hw_tree_traverse (root, finish_hw_tree, NULL, NULL);
 960 }
 961
 962
 963
 964 void
 965 hw_tree_traverse (struct hw *root,
 966                   hw_tree_traverse_function *prefix,
 967                   hw_tree_traverse_function *postfix,
 968                   void *data)
 969 {
 970   struct hw *child;
 971   if (prefix != NULL)
 972     prefix (root, data);
 973   for (child = hw_child (root);
 974        child != NULL;
 975        child = hw_sibling (child))
 976     {
 977       hw_tree_traverse (child, prefix, postfix, data);
 978     }
 979   if (postfix != NULL)
 980     postfix (root, data);
 981 }
 982
 983
 984 \f
 985 struct printer {
 986   hw_tree_print_callback *print;
 987   void *file;
 988 };
 989
 990 static void
 991 print_address (struct hw *bus,
 992                const hw_unit *phys,
 993                struct printer *p)
 994 {
 995   char unit[32];
 996   hw_unit_encode (bus, phys, unit, sizeof(unit));
 997   p->print (p->file, " %s", unit);
 998 }
 999
1000 static void
1001 print_size (struct hw *bus,
1002             const hw_unit *size,
1003             struct printer *p)
1004 {
1005   int i;
1006   for (i = 0; i < size->nr_cells; i++)
1007     if (size->cells[i] != 0)
1008       break;
1009   if (i < size->nr_cells) {
1010     p->print (p->file, " 0x%lx", (unsigned long) size->cells[i]);
1011     i++;
1012     for (; i < size->nr_cells; i++)
1013       p->print (p->file, ",0x%lx", (unsigned long) size->cells[i]);
1014   }
1015   else
1016     p->print (p->file, " 0");
1017 }
1018
1019 static void
1020 print_reg_property (struct hw *me,
1021                     const struct hw_property *property,
1022                     struct printer *p)
1023 {
1024   int reg_nr;
1025   reg_property_spec reg;
1026   for (reg_nr = 0;
1027        hw_find_reg_array_property (me, property->name, reg_nr, &reg);
1028        reg_nr++) {
1029     print_address (hw_parent (me), &reg.address, p);
1030     print_size (me, &reg.size, p);
1031   }
1032 }
1033
1034 static void
1035 print_ranges_property (struct hw *me,
1036                        const struct hw_property *property,
1037                        struct printer *p)
1038 {
1039   int range_nr;
1040   range_property_spec range;
1041   for (range_nr = 0;
1042        hw_find_range_array_property (me, property->name, range_nr, &range);
1043        range_nr++)
1044     {
1045       print_address (me, &range.child_address, p);
1046       print_address (hw_parent (me), &range.parent_address, p);
1047       print_size (me, &range.size, p);
1048     }
1049 }
1050
1051 static void
1052 print_string (struct hw *me,
1053               const char *string,
1054               struct printer *p)
1055 {
1056   p->print (p->file, " \"");
1057   while (*string != '\0') {
1058     switch (*string) {
1059     case '"':
1060       p->print (p->file, "\\\"");
1061       break;
1062     case '\\':
1063       p->print (p->file, "\\\\");
1064       break;
1065     default:
1066       p->print (p->file, "%c", *string);
1067       break;
1068     }
1069     string++;
1070   }
1071   p->print (p->file, "\"");
1072 }
1073
1074 static void
1075 print_string_array_property (struct hw *me,
1076                              const struct hw_property *property,
1077                              struct printer *p)
1078 {
1079   int nr;
1080   string_property_spec string;
1081   for (nr = 0;
1082        hw_find_string_array_property (me, property->name, nr, &string);
1083        nr++)
1084     {
1085       print_string (me, string, p);
1086     }
1087 }
1088
1089 static void
1090 print_properties (struct hw *me,
1091                   struct printer *p)
1092 {
1093   const struct hw_property *property;
1094   for (property = hw_find_property (me, NULL);
1095        property != NULL;
1096        property = hw_next_property (property))
1097     {
1098       if (hw_parent (me) == NULL)
1099         p->print (p->file, "/%s", property->name);
1100       else
1101         p->print (p->file, "%s/%s", hw_path (me), property->name);
1102       if (property->original != NULL)
1103         {
1104           p->print (p->file, " !");
1105           p->print (p->file, "%s/%s",
1106                      hw_path (property->original->owner),
1107                      property->original->name);
1108         }
1109       else
1110         {
1111           switch (property->type)
1112             {
1113             case array_property:
1114               {
1115                 if ((property->sizeof_array % sizeof (signed_cell)) == 0)
1116                   {
1117                     unsigned_cell *w = (unsigned_cell*) property->array;
1118                     int cell_nr;
1119                     for (cell_nr = 0;
1120                          cell_nr < (property->sizeof_array / sizeof (unsigned_cell));
1121                          cell_nr++)
1122                       {
1123                         p->print (p->file, " 0x%lx", (unsigned long) BE2H_cell (w[cell_nr]));
1124                       }
1125                   }
1126                 else
1127                   {
1128                     unsigned8 *w = (unsigned8*)property->array;
1129                     p->print (p->file, " [");
1130                     while ((char*)w - (char*)property->array < property->sizeof_array) {
1131                       p->print (p->file, " 0x%2x", BE2H_1 (*w));
1132                       w++;
1133                     }
1134                   }
1135                 break;
1136               }
1137             case boolean_property:
1138               {
1139                 int b = hw_find_boolean_property(me, property->name);
1140                 p->print (p->file, " %s", b ? "true"  : "false");
1141                 break;
1142               }
1143 #if NOT_YET
1144             case ihandle_property:
1145               {
1146                 if (property->array != NULL)
1147                   {
1148                     device_instance *instance = hw_find_ihandle_property (me, property->name);
1149                     p->print (p->file, " *%s", device_instance_path(instance));
1150                   }
1151                 else
1152                   {
1153                     /* not yet initialized, ask the device for the path */
1154                     ihandle_runtime_property_spec spec;
1155                     hw_find_ihandle_runtime_property (me, property->name, &spec);
1156                     p->print (p->file, " *%s", spec.full_path);
1157                   }
1158                 break;
1159               }
1160 #endif
1161             case integer_property:
1162               {
1163                 unsigned_word w = hw_find_integer_property (me, property->name);
1164                 p->print (p->file, " 0x%lx", (unsigned long)w);
1165                 break;
1166               }
1167             case range_array_property:
1168               {
1169                 print_ranges_property (me, property, p);
1170                 break;
1171               }
1172             case reg_array_property:
1173               {
1174                 print_reg_property (me, property, p);
1175                 break;
1176               }
1177             case string_property:
1178               {
1179                 const char *s = hw_find_string_property (me, property->name);
1180                 print_string (me, s, p);
1181                 break;
1182               }
1183             case string_array_property:
1184               {
1185                 print_string_array_property (me, property, p);
1186                 break;
1187               }
1188             }
1189         }
1190       p->print (p->file, "\n");
1191     }
1192 }
1193
1194 static void
1195 print_interrupts (struct hw *me,
1196                   int my_port,
1197                   struct hw *dest,
1198                   int dest_port,
1199                   void *data)
1200 {
1201   struct printer *p = data;
1202   char src[32];
1203   char dst[32];
1204   hw_port_encode (me, my_port, src, sizeof(src), output_port);
1205   hw_port_encode (dest, dest_port, dst, sizeof(dst), input_port);
1206   p->print (p->file,
1207             "%s > %s %s %s\n",
1208             hw_path (me),
1209             src, dst,
1210             hw_path (dest));
1211 }
1212
1213 static void
1214 print_device (struct hw *me,
1215               void *data)
1216 {
1217   struct printer *p = data;
1218   p->print (p->file, "%s\n", hw_path (me));
1219   print_properties (me, p);
1220   hw_port_traverse (me, print_interrupts, data);
1221 }
1222
1223 void
1224 hw_tree_print (struct hw *root,
1225                hw_tree_print_callback *print,
1226                void *file)
1227 {
1228   struct printer p;
1229   p.print = print;
1230   p.file = file;
1231   hw_tree_traverse (root,
1232                     print_device, NULL,
1233                     &p);
1234 }
1235
1236
1237 \f
1238 #if NOT_YET
1239 device_instance *
1240 tree_instance(struct hw *root,
1241               const char *device_specifier)
1242 {
1243   /* find the device node */
1244   struct hw *me;
1245   name_specifier spec;
1246   if (!split_device_specifier(root, device_specifier, &spec))
1247     return NULL;
1248   me = split_find_device(root, &spec);
1249   if (spec.name != NULL)
1250     return NULL;
1251   /* create the instance */
1252   return device_create_instance(me, device_specifier, spec.last_args);
1253 }
1254 #endif
1255
1256 struct hw *
1257 hw_tree_find_device (struct hw *root,
1258                      const char *path_to_device)
1259 {
1260   struct hw *node;
1261   name_specifier spec;
1262
1263   /* parse the path */
1264   split_device_specifier (root, path_to_device, &spec);
1265   if (spec.value != NULL)
1266     return NULL; /* something wierd */
1267
1268   /* now find it */
1269   node = split_find_device (root, &spec);
1270   if (spec.name != NULL)
1271     return NULL; /* not a leaf */
1272
1273   return node;
1274 }
1275
1276
1277 const struct hw_property *
1278 hw_tree_find_property (struct hw *root,
1279                        const char *path_to_property)
1280 {
1281   name_specifier spec;
1282   if (!split_property_specifier (root, path_to_property, &spec))
1283     hw_abort (root, "Invalid property path %s", path_to_property);
1284   root = split_find_device (root, &spec);
1285   if (spec.name != NULL)
1286     return NULL; /* not a leaf */
1287   return hw_find_property (root, spec.property);
1288 }
1289
1290 int
1291 hw_tree_find_boolean_property (struct hw *root,
1292                                const char *path_to_property)
1293 {
1294   name_specifier spec;
1295   if (!split_property_specifier (root, path_to_property, &spec))
1296     hw_abort (root, "Invalid property path %s", path_to_property);
1297   root = split_find_device (root, &spec);
1298   if (spec.name != NULL)
1299     hw_abort (root, "device \"%s\" not found (property \"%s\")",
1300               spec.name, path_to_property);
1301   return hw_find_boolean_property (root, spec.property);
1302 }
1303
1304 signed_cell
1305 hw_tree_find_integer_property (struct hw *root,
1306                                const char *path_to_property)
1307 {
1308   name_specifier spec;
1309   if (!split_property_specifier (root, path_to_property, &spec))
1310     hw_abort (root, "Invalid property path %s", path_to_property);
1311   root = split_find_device (root, &spec);
1312   if (spec.name != NULL)
1313     hw_abort (root, "device \"%s\" not found (property \"%s\")",
1314               spec.name, path_to_property);
1315   return hw_find_integer_property (root, spec.property);
1316 }
1317
1318 #if NOT_YET
1319 device_instance *
1320 hw_tree_find_ihandle_property (struct hw *root,
1321                                const char *path_to_property)
1322 {
1323   struct hw *root;
1324   name_specifier spec;
1325   if (!split_property_specifier (root, path_to_property, &spec))
1326     hw_abort (root, "Invalid property path %s", path_to_property);
1327   root = split_find_device (root, &spec);
1328   if (spec.name != NULL)
1329     hw_abort (root, "device \"%s\" not found (property \"%s\")",
1330               spec.name, path_to_property);
1331   return hw_find_ihandle_property (root, spec.property);
1332 }
1333 #endif
1334
1335 const char *
1336 hw_tree_find_string_property (struct hw *root,
1337                               const char *path_to_property)
1338 {
1339   name_specifier spec;
1340   if (!split_property_specifier (root, path_to_property, &spec))
1341     hw_abort (root, "Invalid property path %s", path_to_property);
1342   root = split_find_device (root, &spec);
1343   if (spec.name != NULL)
1344     hw_abort (root, "device \"%s\" not found (property \"%s\")",
1345               spec.name, path_to_property);
1346   return hw_find_string_property (root, spec.property);
1347 }