src/expr-name.c

   1 /* vim: set sw=8: -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * expr-name.c: Supported named expressions
   4  *
   5  * Author:
   6  *    Jody Goldberg <jody@gnome.org>
   7  *
   8  * Based on work by:
   9  *    Michael Meeks <michael@ximian.com>
  10  */
  11
  12 #include <gnumeric-config.h>
  13 #include <glib/gi18n-lib.h>
  14 #include <string.h>
  15 #include "gnumeric.h"
  16 #include "expr-name.h"
  17
  18 #include "dependent.h"
  19 #include "value.h"
  20 #include "workbook-priv.h"
  21 #include "expr.h"
  22 #include "sheet.h"
  23 #include "ranges.h"
  24 #include "gutils.h"
  25 #include "sheet-style.h"
  26
  27 #include <goffice/goffice.h>
  28
  29
  30 static gboolean
  31 expr_name_validate_r1c1 (const char *name)
  32 {
  33         const char *p = name;
  34         gint i;
  35
  36         if (p[0] != 'R' && p[0] != 'r')
  37                 return TRUE;
  38         p++;
  39         /* no need to worry about [] since they are not alphanumeric */
  40         for (i = 0; p[0] && g_ascii_isdigit (p[0]); p = g_utf8_next_char (p))
  41                 i++;
  42         if (i==0)
  43                 return TRUE;
  44         if (p[0] != 'C' && p[0] != 'c')
  45                 return TRUE;
  46         p++;
  47         for (i = 0; p[0] && g_ascii_isdigit (p[0]); p = g_utf8_next_char (p))
  48                 i++;
  49         if (i==0)
  50                 return TRUE;
  51         return (p[0] != '\0');
  52 }
  53
  54 static gboolean
  55 expr_name_validate_a1 (const char *name)
  56 {
  57         const char *p = name;
  58         gint i;
  59
  60         for (i = 0; *p && g_ascii_isalpha(p[0]);
  61              p = g_utf8_next_char (p))
  62                 i++;
  63         if (i==0 || i>4) /* We want to allow "total2010" and it   */
  64                          /* is unlikely to have more than  456976 */
  65                          /* columns  atm */
  66                 return TRUE;
  67         for (i = 0; *p && g_ascii_isdigit (p[0]);
  68              p = g_utf8_next_char (p))
  69                 i++;
  70         if (i==0)
  71                 return TRUE;
  72         return (*p != '\0');
  73 }
  74
  75 /**
  76  * expr_name_validate:
  77  * @name: tentative name
  78  *
  79  * returns %TRUE if the given name is valid, %FALSE otherwise.
  80  */
  81 gboolean
  82 expr_name_validate (const char *name)
  83 {
  84         const char *p;
  85         GnmValue *v;
  86
  87         g_return_val_if_fail (name != NULL, FALSE);
  88
  89         if (name[0] == 0)
  90                 return FALSE;
  91
  92         v = value_new_from_string (VALUE_BOOLEAN, name, NULL, TRUE);
  93         if (!v)
  94                 v = value_new_from_string (VALUE_BOOLEAN, name, NULL, FALSE);
  95         if (v) {
  96                 value_release (v);
  97                 return FALSE;
  98         }
  99
 100         /* Hmm...   Now what?  */
 101         if (!g_unichar_isalpha (g_utf8_get_char (name)) &&
 102             name[0] != '_')
 103                 return FALSE;
 104
 105         for (p = name; *p; p = g_utf8_next_char (p)) {
 106                 if (!g_unichar_isalnum (g_utf8_get_char (p)) &&
 107                     p[0] != '_')
 108                         return FALSE;
 109         }
 110
 111         /* Make sure it's not A1 etc.*/
 112         /* Note that we can't use our regular parsers */
 113         /* since we also have to avoid names that may become */
 114         /* sensible when the sheet size changes. */
 115         if (!expr_name_validate_a1 (name))
 116                 return FALSE;
 117
 118         /* What about R1C1?  */
 119         if (!expr_name_validate_r1c1 (name))
 120                 return FALSE;
 121
 122         return TRUE;
 123 }
 124
 125
 126 static void
 127 cb_nexpr_remove (GnmNamedExpr *nexpr)
 128 {
 129         g_return_if_fail (nexpr->scope != NULL);
 130
 131         nexpr->scope = NULL;
 132         expr_name_set_expr (nexpr, NULL);
 133         expr_name_unref (nexpr);
 134 }
 135
 136 static void
 137 cb_collect_name_deps (gpointer key, G_GNUC_UNUSED gpointer value,
 138                       gpointer user_data)
 139 {
 140         GSList **list = user_data;
 141         *list = g_slist_prepend (*list, key);
 142 }
 143
 144 static GSList *
 145 expr_name_unlink_deps (GnmNamedExpr *nexpr)
 146 {
 147         GSList *ptr, *deps = NULL;
 148
 149         if (nexpr->dependents == NULL)
 150                 return NULL;
 151
 152         g_hash_table_foreach (nexpr->dependents, cb_collect_name_deps, &deps);
 153
 154         /* pull them out */
 155         for (ptr = deps ; ptr != NULL ; ptr = ptr->next) {
 156                 GnmDependent *dep = ptr->data;
 157                 if (dependent_is_linked (dep))
 158                         dependent_unlink (dep);
 159         }
 160         return deps;
 161 }
 162
 163 static void
 164 expr_name_relink_deps (GnmNamedExpr *nexpr)
 165 {
 166         GSList *deps = NULL;
 167
 168         if (nexpr->dependents == NULL)
 169                 return;
 170
 171         g_hash_table_foreach (nexpr->dependents, cb_collect_name_deps, &deps);
 172         dependents_link (deps);
 173         g_slist_free (deps);
 174 }
 175
 176 static guint
 177 fake_go_string_hash (gconstpointer s_)
 178 {
 179         const GOString *s = s_;
 180         return g_str_hash (s->str);
 181 }
 182
 183 static gboolean
 184 fake_go_string_equal (gconstpointer a_, gconstpointer b_)
 185 {
 186         const GOString *a = a_;
 187         const GOString *b = b_;
 188         return g_str_equal (a->str, b->str);
 189 }
 190
 191
 192 struct _GnmNamedExprCollection {
 193         /* all the defined names */
 194         GHashTable *names;
 195
 196         /* placeholders for references to undefined names */
 197         GHashTable *placeholders;
 198
 199         /* <private> */
 200         unsigned ref_count;     /* boxed type */
 201 };
 202
 203 /**
 204  * gnm_named_expr_collection_new:
 205  *
 206  * Returns: (transfer full): the newly allocated #GnmNamedExprCollection.
 207  **/
 208 GnmNamedExprCollection *
 209 gnm_named_expr_collection_new (void)
 210 {
 211         GnmNamedExprCollection *res = g_new (GnmNamedExprCollection, 1);
 212
 213         res->names = g_hash_table_new_full
 214                 (fake_go_string_hash, fake_go_string_equal,
 215                  NULL, (GDestroyNotify) cb_nexpr_remove);
 216         res->placeholders = g_hash_table_new_full
 217                 (fake_go_string_hash, fake_go_string_equal,
 218                 NULL, (GDestroyNotify) cb_nexpr_remove);
 219         res->ref_count = 1;
 220
 221         return res;
 222 }
 223
 224 /**
 225  * gnm_named_expr_collection_free:
 226  * @names: The collection of names
 227  *
 228  * Frees names defined in the local scope.
 229  * NOTE : THIS DOES NOT INVALIDATE NAMES THAT REFER
 230  *        TO THIS SCOPE.
 231  *        eg
 232  *           in scope sheet2 we have a name that refers
 233  *           to sheet1.  That will remain!
 234  **/
 235 void
 236 gnm_named_expr_collection_free (GnmNamedExprCollection *names)
 237 {
 238         if (names != NULL && names->ref_count-- < 2) {
 239                 g_hash_table_destroy (names->names);
 240                 g_hash_table_destroy (names->placeholders);
 241                 g_free (names);
 242         }
 243 }
 244
 245 static GnmNamedExprCollection *
 246 gnm_named_expr_collection_ref (GnmNamedExprCollection *names)
 247 {
 248         names->ref_count++;
 249         return names;
 250 }
 251
 252 void
 253 gnm_named_expr_collection_dump (GnmNamedExprCollection *names, const char *id)
 254 {
 255         g_printerr ("Named collection %s\n", id);
 256         if (!names) {
 257                 g_printerr ("  Empty\n");
 258                 return;
 259         }
 260
 261         if (names->names && g_hash_table_size (names->names)) {
 262                 GHashTableIter hiter;
 263                 gpointer key, value;
 264
 265                 g_printerr ("  Defined names:\n");
 266                 g_hash_table_iter_init (&hiter, names->names);
 267                 while (g_hash_table_iter_next (&hiter, &key, &value)) {
 268                         const GOString *name = key;
 269                         GnmNamedExpr const *nexpr = value;
 270                         g_printerr ("    [%s] =>\n", name->str);
 271                         if (name != nexpr->name)
 272                                 g_printerr ("      Weird keys: %p vs %p\n",
 273                                             name, nexpr->name);
 274                 }
 275         }
 276
 277         if (names->placeholders && g_hash_table_size (names->placeholders)) {
 278                 GHashTableIter hiter;
 279                 gpointer key, value;
 280
 281                 g_printerr ("  Defined placeholders:\n");
 282                 g_hash_table_iter_init (&hiter, names->placeholders);
 283                 while (g_hash_table_iter_next (&hiter, &key, &value)) {
 284                         const GOString *name = key;
 285                         GnmNamedExpr const *nexpr = value;
 286                         g_printerr ("    [%s] =>\n", name->str);
 287                         if (name != nexpr->name)
 288                                 g_printerr ("      Weird keys: %p vs %p\n",
 289                                             name, nexpr->name);
 290                 }
 291         }
 292 }
 293
 294 gboolean
 295 gnm_named_expr_collection_sanity_check (GnmNamedExprCollection *names,
 296                                         const char *id)
 297 {
 298         gboolean err = FALSE;
 299         g_printerr ("Checking sanity for container %s\n", id);
 300         if (names->names) {
 301                 GHashTableIter hiter;
 302                 gpointer key, value;
 303
 304                 g_hash_table_iter_init (&hiter, names->names);
 305                 while (g_hash_table_iter_next (&hiter, &key, &value)) {
 306                         const GOString *name = key;
 307                         GnmNamedExpr const *nexpr = value;
 308                         if (name != nexpr->name) {
 309                                 err = TRUE;
 310                                 g_printerr ("Container %s has strange defined name\n",
 311                                             id);
 312                                 g_printerr ("  key is %p [%s]\n",
 313                                             name, name->str);
 314                                 g_printerr ("  target's name is %p [%s]\n",
 315                                             nexpr->name, nexpr->name->str);
 316                         }
 317                 }
 318         }
 319         return err;
 320 }
 321
 322 GType
 323 gnm_named_expr_collection_get_type (void)
 324 {
 325         static GType t = 0;
 326
 327         if (t == 0) {
 328                 t = g_boxed_type_register_static ("GnmNamedExprCollection",
 329                          (GBoxedCopyFunc)gnm_named_expr_collection_ref,
 330                          (GBoxedFreeFunc)gnm_named_expr_collection_free);
 331         }
 332         return t;
 333 }
 334
 335 static void
 336 cb_unlink_all_names (G_GNUC_UNUSED gpointer key,
 337                      gpointer value,
 338                      G_GNUC_UNUSED gpointer user_data)
 339 {
 340         GnmNamedExpr *nexpr = value;
 341         GSList *deps = expr_name_unlink_deps (nexpr);
 342         g_slist_free (deps);
 343 }
 344
 345 void
 346 gnm_named_expr_collection_unlink (GnmNamedExprCollection *names)
 347 {
 348         if (!names)
 349                 return;
 350
 351         g_hash_table_foreach (names->names,
 352                               cb_unlink_all_names,
 353                               NULL);
 354 }
 355
 356 static void
 357 cb_relink_all_names (G_GNUC_UNUSED gpointer key,
 358                      gpointer value,
 359                      G_GNUC_UNUSED gpointer user_data)
 360 {
 361         GnmNamedExpr *nexpr = value;
 362         expr_name_relink_deps (nexpr);
 363 }
 364
 365 void
 366 gnm_named_expr_collection_relink (GnmNamedExprCollection *names)
 367 {
 368         if (!names)
 369                 return;
 370
 371         g_hash_table_foreach (names->names,
 372                               cb_relink_all_names,
 373                               NULL);
 374 }
 375
 376 GnmNamedExpr *
 377 gnm_named_expr_collection_lookup (GnmNamedExprCollection const *scope,
 378                                   char const *name)
 379 {
 380         if (scope != NULL) {
 381                 GOString fake_name;
 382                 GnmNamedExpr *nexpr;
 383
 384                 fake_name.str = name;
 385                 nexpr = g_hash_table_lookup (scope->names, &fake_name);
 386                 if (nexpr == NULL)
 387                         nexpr = g_hash_table_lookup (scope->placeholders,
 388                                                      &fake_name);
 389                 return nexpr;
 390         } else
 391                 return NULL;
 392 }
 393
 394 static void
 395 cb_list_names (G_GNUC_UNUSED gpointer key,
 396                gpointer value,
 397                gpointer user_data)
 398 {
 399         GSList **pres = user_data;
 400         GO_SLIST_PREPEND (*pres, value);
 401 }
 402
 403 /**
 404  * gnm_named_expr_collection_list:
 405  * @scope: #GnmNamedExprCollection
 406  *
 407  * Returns: (element-type GnmNamedExpr) (transfer container):
 408  **/
 409 GSList *
 410 gnm_named_expr_collection_list (GnmNamedExprCollection const *scope)
 411 {
 412         GSList *res = NULL;
 413         if (scope) {
 414                 g_hash_table_foreach (scope->names,
 415                                       cb_list_names,
 416                                       &res);
 417         }
 418         return res;
 419 }
 420
 421 static void
 422 gnm_named_expr_collection_insert (GnmNamedExprCollection *scope,
 423                                   GnmNamedExpr *nexpr)
 424 {
 425         if (gnm_debug_flag ("names")) {
 426                 char *scope_name = nexpr->pos.sheet
 427                         ? g_strdup_printf ("sheet %s", nexpr->pos.sheet->name_quoted)
 428                         : g_strdup ("workbook");
 429                 g_printerr ("Inserting name %s into its %s container%s\n",
 430                             nexpr->name->str,
 431                             scope_name,
 432                             nexpr->is_placeholder ? " as a placeholder" : "");
 433                 g_free (scope_name);
 434         }
 435
 436         /* name can be active at this point, eg we are converting a
 437          * placeholder, or changing a scope */
 438         nexpr->scope = scope;
 439         g_hash_table_replace
 440                 (nexpr->is_placeholder ? scope->placeholders : scope->names,
 441                  (gpointer)nexpr->name, nexpr);
 442 }
 443
 444 typedef struct {
 445         Sheet const *sheet;
 446         GnmRange const *r;
 447         GnmNamedExpr *res;
 448 } CheckName;
 449
 450 static void
 451 cb_check_name (G_GNUC_UNUSED gpointer key, GnmNamedExpr *nexpr,
 452                CheckName *user)
 453 {
 454         GnmValue *v;
 455
 456         if (nexpr->scope == NULL || nexpr->is_hidden || !nexpr->texpr)
 457                 return;
 458
 459         v = gnm_expr_top_get_range (nexpr->texpr);
 460         if (v != NULL) {
 461                 if (VALUE_IS_CELLRANGE (v)) {
 462                         GnmRangeRef const *ref = &v->v_range.cell;
 463                         if (!ref->a.col_relative &&
 464                             !ref->b.col_relative &&
 465                             !ref->a.row_relative &&
 466                             !ref->b.row_relative &&
 467                             eval_sheet (ref->a.sheet, user->sheet) == user->sheet &&
 468                             eval_sheet (ref->b.sheet, user->sheet) == user->sheet &&
 469                             MIN (ref->a.col, ref->b.col) == user->r->start.col &&
 470                             MAX (ref->a.col, ref->b.col) == user->r->end.col &&
 471                             MIN (ref->a.row, ref->b.row) == user->r->start.row &&
 472                             MAX (ref->a.row, ref->b.row) == user->r->end.row)
 473                                 user->res = nexpr;
 474                 }
 475                 value_release (v);
 476         }
 477 }
 478
 479 static GnmNamedExpr *
 480 gnm_named_expr_collection_check (GnmNamedExprCollection *scope,
 481                                  Sheet const *sheet, GnmRange const *r)
 482 {
 483         CheckName user;
 484
 485         if (scope == NULL)
 486                 return NULL;
 487
 488         user.sheet = sheet;
 489         user.r     = r;
 490         user.res   = NULL;
 491
 492         g_hash_table_foreach (scope->names, (GHFunc)cb_check_name, &user);
 493         return user.res;
 494 }
 495
 496 /**
 497  * gnm_named_expr_collection_foreach:
 498  * @names: #GnmNamedExprCollection
 499  * @func: (scope call):
 500  * @data: user data.
 501  *
 502  * Iterate over all names, including placeholders.
 503  **/
 504 void
 505 gnm_named_expr_collection_foreach (GnmNamedExprCollection *names,
 506                                    GHFunc func,
 507                                    gpointer data)
 508 {
 509         g_hash_table_foreach (names->names, func, data);
 510         g_hash_table_foreach (names->placeholders, func, data);
 511 }
 512
 513 /******************************************************************************/
 514
 515 /**
 516  * expr_name_handle_references:
 517  *
 518  * Register or unregister a name with
 519  * all of the sheets it explicitly references.  This is necessary
 520  * because names are not dependents, and if they reference a deleted
 521  * sheet we will not notice.
 522  */
 523 static void
 524 expr_name_handle_references (GnmNamedExpr *nexpr, gboolean add)
 525 {
 526         GSList *sheets, *ptr;
 527
 528         sheets = gnm_expr_top_referenced_sheets (nexpr->texpr);
 529
 530         for (ptr = sheets ; ptr != NULL ; ptr = ptr->next) {
 531                 Sheet *sheet = ptr->data;
 532                 GnmNamedExpr *found;
 533
 534                 /* Implicit reference.  */
 535                 if (!sheet)
 536                         continue;
 537
 538                 /* No need to do anything during destruction */
 539                 if (sheet->deps == NULL)
 540                         continue;
 541
 542                 found = g_hash_table_lookup (sheet->deps->referencing_names, nexpr);
 543                 if (add) {
 544                         if (found == NULL)  {
 545                                 g_hash_table_insert (sheet->deps->referencing_names, nexpr, nexpr);
 546                         } else {
 547                                 g_warning ("Name being registered multiple times ?");
 548                         }
 549                 } else {
 550                         if (found == NULL)  {
 551                                 g_warning ("Unregistered name being removed?");
 552                         } else {
 553                                 g_hash_table_remove (sheet->deps->referencing_names, nexpr);
 554                         }
 555                 }
 556         }
 557         g_slist_free (sheets);
 558 }
 559
 560
 561 /**
 562  * expr_name_lookup:
 563  * @pos: #GnmParsePos identifying a #Sheet or a #Workbook.
 564  * @name: name of #GnmNamedExpr to look up.
 565  *
 566  * Return: (transfer none) (nullable): #GnmNamedExpr named @name in the scope
 567  * given by @pos; %NULL if no such #GnmNamedExpr exists.
 568  */
 569 GnmNamedExpr *
 570 expr_name_lookup (GnmParsePos const *pp, char const *name)
 571 {
 572         GnmNamedExpr *res = NULL;
 573         Sheet const *sheet = NULL;
 574         Workbook const *wb = NULL;
 575
 576         g_return_val_if_fail (name != NULL, NULL);
 577
 578         if (pp != NULL) {
 579                 sheet = pp->sheet;
 580                 wb = (sheet != NULL) ? sheet->workbook : pp->wb;
 581         }
 582
 583         if (sheet != NULL && sheet->names != NULL)
 584                 res = gnm_named_expr_collection_lookup (sheet->names, name);
 585         if (res == NULL && wb != NULL && wb->names != NULL)
 586                 res = gnm_named_expr_collection_lookup (wb->names, name);
 587         return res;
 588 }
 589
 590 /**
 591  * expr_name_new:
 592  * @name:
 593  *
 594  * Creates a new name without linking it into any container.
 595  **/
 596 GnmNamedExpr *
 597 expr_name_new (char const *name)
 598 {
 599         GnmNamedExpr *nexpr;
 600
 601         g_return_val_if_fail (name != NULL, NULL);
 602
 603         nexpr = g_new0 (GnmNamedExpr,1);
 604
 605         nexpr->ref_count        = 1;
 606         nexpr->name             = go_string_new (name);
 607         nexpr->texpr            = NULL;
 608         nexpr->dependents       = NULL;
 609         nexpr->is_placeholder   = TRUE;
 610         nexpr->is_hidden        = FALSE;
 611         nexpr->is_permanent     = FALSE;
 612         nexpr->is_editable      = TRUE;
 613         nexpr->scope = NULL;
 614
 615         if (gnm_debug_flag ("names"))
 616                 g_printerr ("Created new name %s\n", name);
 617
 618         return nexpr;
 619 }
 620
 621 struct cb_name_loop_check {
 622         /* One of these */
 623         char const *name;
 624         GnmNamedExpr *nexpr;
 625
 626         gboolean stop_at_name;
 627         gboolean res;
 628 };
 629
 630 static GnmExpr const *
 631 cb_name_loop_check (GnmExpr const *expr, GnmExprWalk *data)
 632 {
 633         struct cb_name_loop_check *args = data->user;
 634
 635         GnmNamedExpr const *nexpr2 = gnm_expr_get_name (expr);
 636         if (nexpr2) {
 637                 if ((args->name && !strcmp (nexpr2->name->str, args->name)) ||
 638                     args->nexpr == nexpr2 ||
 639                     (!args->stop_at_name && nexpr2->texpr &&
 640                      /* Is the following right?  It drops args->nexpr */
 641                      expr_name_check_for_loop (args->name, nexpr2->texpr))) {
 642                         args->res = TRUE;
 643                         data->stop = TRUE;
 644                 }
 645         }
 646
 647         return NULL;
 648 }
 649
 650 /**
 651  * expr_name_check_for_loop:
 652  * @name: tentative name
 653  * @texpr: tentative expression
 654  *
 655  * Returns: %TRUE if defining the tentative name would cause a circular
 656  * name reference.
 657  *
 658  * NOTE: if we already have a circular reference beforehand, we will come
 659  * to serious grief.
 660  */
 661 gboolean
 662 expr_name_check_for_loop (char const *name, GnmExprTop const *texpr)
 663 {
 664         struct cb_name_loop_check args;
 665
 666         g_return_val_if_fail (texpr != NULL, TRUE);
 667
 668         args.name = name;
 669         args.nexpr = NULL;
 670         args.stop_at_name = FALSE;
 671         args.res = FALSE;
 672         gnm_expr_walk (texpr->expr, cb_name_loop_check, &args);
 673         return args.res;
 674 }
 675
 676 static void
 677 expr_name_queue_deps (GnmNamedExpr *nexpr)
 678 {
 679         if (nexpr->dependents)
 680                 g_hash_table_foreach (nexpr->dependents,
 681                                       (GHFunc)dependent_queue_recalc,
 682                                       NULL);
 683 }
 684
 685 /**
 686  * expr_name_add:
 687  * @pp:
 688  * @name:
 689  * @texpr: if texpr == NULL then create a placeholder with value #NAME?
 690  * @error_msg:
 691  * @link_to_container:
 692  *
 693  * Absorbs the reference to @texpr.
 694  * If @error_msg is non NULL it may hold a pointer to a translated descriptive
 695  * string.  NOTE : caller is responsible for freeing the error message.
 696  *
 697  * The reference semantics of the new expression are
 698  * 1) new names with @link_to_container TRUE are referenced by the container.
 699  *    The caller DOES NOT OWN a reference to the result, and needs to add their
 700  *    own.
 701  * 2) if @link_to_container is FALSE the caller DOES OWN a reference, and
 702  *    can free the result by unrefing the name.
 703  **/
 704 GnmNamedExpr *
 705 expr_name_add (GnmParsePos const *pp, char const *name,
 706                GnmExprTop const *texpr, char **error_msg,
 707                gboolean link_to_container,
 708                GnmNamedExpr *stub)
 709 {
 710         GnmNamedExpr *nexpr = NULL;
 711         GnmNamedExprCollection *scope = NULL;
 712         GOString fake_name;
 713
 714         g_return_val_if_fail (pp != NULL, NULL);
 715         g_return_val_if_fail (pp->sheet != NULL || pp->wb != NULL, NULL);
 716         g_return_val_if_fail (name != NULL, NULL);
 717         g_return_val_if_fail (stub == NULL || stub->is_placeholder, NULL);
 718
 719         fake_name.str = name;
 720
 721         if (gnm_debug_flag ("names")) {
 722                 char *str = gnm_expr_top_as_string (texpr, pp, NULL);
 723                 g_printerr ("Adding Name=[%s] texpr=[%s] stub=[%s]\n",
 724                             name, str, stub ? expr_name_name (stub) : "-");
 725                 g_free (str);
 726         }
 727
 728         if (texpr != NULL &&
 729             (expr_name_check_for_loop (name, texpr) ||
 730              (stub && expr_name_check_for_loop (expr_name_name (stub), texpr)))) {
 731                 gnm_expr_top_unref (texpr);
 732                 if (error_msg)
 733                         *error_msg = g_strdup_printf (_("'%s' has a circular reference"), name);
 734                 return NULL;
 735         }
 736
 737         scope = (pp->sheet != NULL) ? pp->sheet->names : pp->wb->names;
 738         /* see if there was a place holder */
 739         nexpr = g_hash_table_lookup (scope->placeholders, &fake_name);
 740         if (nexpr != NULL) {
 741                 if (texpr == NULL) {
 742                         /* there was already a placeholder for this */
 743                         if (!link_to_container)
 744                                 expr_name_ref (nexpr);
 745                         return nexpr;
 746                 }
 747
 748                 /* convert the placeholder into a real name */
 749                 g_hash_table_steal (scope->placeholders, &fake_name);
 750                 nexpr->is_placeholder = FALSE;
 751         } else {
 752                 nexpr = g_hash_table_lookup (scope->names, &fake_name);
 753                 /* If this is a permanent name, we may be adding it */
 754                 /* on opening of a file, although */
 755                 /* the name is already in place. */
 756                 if (nexpr != NULL) {
 757                         if (nexpr->is_permanent)
 758                                 link_to_container = FALSE;
 759                         else {
 760                                 if (error_msg != NULL)
 761                                         *error_msg = (pp->sheet != NULL)
 762                                                 ? g_strdup_printf (_("'%s' is already defined in sheet"), name)
 763                                                 : g_strdup_printf (_("'%s' is already defined in workbook"), name);
 764
 765                                 gnm_expr_top_unref (texpr);
 766                                 return NULL;
 767                         }
 768                 }
 769         }
 770
 771         if (error_msg)
 772                 *error_msg = NULL;
 773
 774         if (nexpr == NULL) {
 775                 if (stub != NULL) {
 776                         nexpr = stub;
 777                         stub->is_placeholder = FALSE;
 778                         go_string_unref (stub->name);
 779                         stub->name = go_string_new (name);
 780                 } else {
 781                         nexpr = expr_name_new (name);
 782                         nexpr->is_placeholder = (texpr == NULL);
 783                 }
 784         }
 785         parse_pos_init (&nexpr->pos,
 786                 pp->wb, pp->sheet, pp->eval.col, pp->eval.row);
 787         if (texpr == NULL)
 788                 texpr = gnm_expr_top_new_constant
 789                         (value_new_error_NAME (NULL));
 790         expr_name_set_expr (nexpr, texpr);
 791         if (link_to_container)
 792                 gnm_named_expr_collection_insert (scope, nexpr);
 793
 794         return nexpr;
 795 }
 796
 797 GnmNamedExpr *
 798 expr_name_ref (GnmNamedExpr *nexpr)
 799 {
 800         g_return_val_if_fail (nexpr != NULL, NULL);
 801         nexpr->ref_count++;
 802         return nexpr;
 803 }
 804
 805 void
 806 expr_name_unref (GnmNamedExpr *nexpr)
 807 {
 808         g_return_if_fail (nexpr != NULL);
 809
 810         if (nexpr->ref_count-- > 1)
 811                 return;
 812
 813         if (gnm_debug_flag ("names"))
 814                 g_printerr ("Finalizing name %s\n", nexpr->name->str);
 815
 816         g_return_if_fail (nexpr->scope == NULL);
 817
 818         if (nexpr->name) {
 819                 go_string_unref (nexpr->name);
 820                 nexpr->name = NULL;
 821         }
 822
 823         if (nexpr->texpr != NULL)
 824                 expr_name_set_expr (nexpr, NULL);
 825
 826         if (nexpr->dependents != NULL) {
 827                 g_hash_table_destroy (nexpr->dependents);
 828                 nexpr->dependents  = NULL;
 829         }
 830
 831         nexpr->pos.wb      = NULL;
 832         nexpr->pos.sheet   = NULL;
 833
 834         g_free (nexpr);
 835 }
 836
 837 GType
 838 gnm_named_expr_get_type (void)
 839 {
 840         static GType t = 0;
 841
 842         if (t == 0) {
 843                 t = g_boxed_type_register_static ("GnmNamedExpr",
 844                          (GBoxedCopyFunc)expr_name_ref,
 845                          (GBoxedFreeFunc)expr_name_unref);
 846         }
 847         return t;
 848 }
 849
 850 /**
 851  * expr_name_remove:
 852  * @nexpr:
 853  *
 854  * Remove a @nexpr from its container and deactivate it.
 855  * NOTE : @nexpr may continue to exist if things still have references to it,
 856  * but they will evaluate to #REF!
 857  **/
 858 void
 859 expr_name_remove (GnmNamedExpr *nexpr)
 860 {
 861         g_return_if_fail (nexpr != NULL);
 862         g_return_if_fail (nexpr->scope != NULL);
 863
 864         if (gnm_debug_flag ("names")) {
 865                 g_printerr ("Removing name %s from its container%s\n",
 866                             nexpr->name->str,
 867                             nexpr->is_placeholder ? " as a placeholder" : "");
 868         }
 869
 870         g_hash_table_remove (
 871                 nexpr->is_placeholder ? nexpr->scope->placeholders : nexpr->scope->names,
 872                 nexpr->name);
 873 }
 874
 875 const char *
 876 expr_name_name (GnmNamedExpr const *nexpr)
 877 {
 878         g_return_val_if_fail (nexpr != NULL, NULL);
 879         return nexpr->name->str;
 880 }
 881
 882 /**
 883  * expr_name_set_name:
 884  * @nexpr: the named expression
 885  * @new_name: the new name of the expression
 886  *
 887  * returns: TRUE on error.
 888  */
 889 gboolean
 890 expr_name_set_name (GnmNamedExpr *nexpr,
 891                     const char *new_name)
 892 {
 893         const char *old_name;
 894         GHashTable *h;
 895         GOString fake_new_name;
 896
 897         g_return_val_if_fail (nexpr != NULL, TRUE);
 898         g_return_val_if_fail (nexpr->scope == NULL || new_name, TRUE);
 899
 900         old_name = nexpr->name->str;
 901         if (go_str_compare (new_name, old_name) == 0)
 902                 return FALSE;
 903
 904         fake_new_name.str = new_name;
 905 #if 0
 906         g_printerr ("Renaming %s to %s\n", old_name, new_name);
 907 #endif
 908         h = nexpr->scope
 909                 ? (nexpr->is_placeholder
 910                    ? nexpr->scope->placeholders
 911                    : nexpr->scope->names)
 912                 : NULL;
 913         if (h) {
 914                 if (new_name &&
 915                     (g_hash_table_lookup (nexpr->scope->placeholders,
 916                                           &fake_new_name) ||
 917                      g_hash_table_lookup (nexpr->scope->names,
 918                                           &fake_new_name))) {
 919                         /* The only error not to be blamed on the programmer is
 920                            already-in-use.  */
 921                         return TRUE;
 922                 }
 923
 924                 g_hash_table_steal (h, nexpr->name);
 925         }
 926
 927         go_string_unref (nexpr->name);
 928         nexpr->name = go_string_new (new_name);
 929
 930         if (h)
 931                 g_hash_table_insert (h, (gpointer)nexpr->name, nexpr);
 932
 933         return FALSE;
 934 }
 935
 936
 937 /**
 938  * expr_name_as_string:
 939  * @nexpr: A #GnmNamedExpr
 940  * @pp: (nullable): Position where name was defined.
 941  * @fmt: #GnmConventions describing how to render @nexpr
 942  *
 943  * Returns: (transfer full): The rendering of @nexpr given convention @fmt.
 944  */
 945 char *
 946 expr_name_as_string (GnmNamedExpr const *nexpr, GnmParsePos const *pp,
 947                      GnmConventions const *fmt)
 948 {
 949         if (pp == NULL)
 950                 pp = &nexpr->pos;
 951         return gnm_expr_top_as_string (nexpr->texpr, pp, fmt);
 952 }
 953
 954 /**
 955  * expr_name_eval:
 956  * @nexpr: A #GnmNamedExpr
 957  * @pos: Position where evaluation takes place
 958  * @flags: #GnmExprEvalFlags flags describing context.
 959  *
 960  * Returns: (transfer full): The resulting value.
 961  */
 962 GnmValue *
 963 expr_name_eval (GnmNamedExpr const *nexpr, GnmEvalPos const *pos,
 964                 GnmExprEvalFlags flags)
 965 {
 966         g_return_val_if_fail (pos, NULL);
 967
 968         if (!nexpr)
 969                 return value_new_error_NAME (pos);
 970
 971         return gnm_expr_top_eval (nexpr->texpr, pos, flags);
 972 }
 973
 974 /**
 975  * expr_name_downgrade_to_placeholder:
 976  * @nexpr:
 977  *
 978  * Takes a real non-placeholder name and converts it to being a placeholder.
 979  * unrefing its expression
 980  **/
 981 void
 982 expr_name_downgrade_to_placeholder (GnmNamedExpr *nexpr)
 983 {
 984         g_return_if_fail (nexpr != NULL);
 985
 986         expr_name_set_is_placeholder (nexpr, TRUE);
 987         expr_name_set_expr
 988                 (nexpr,
 989                  gnm_expr_top_new_constant (value_new_error_NAME (NULL)));
 990 }
 991
 992 /*******************************************************************
 993  * Manage things that depend on named expressions.
 994  */
 995 /**
 996  * expr_name_set_pos:
 997  * @nexpr: the named expression
 998  * @pp: the new position
 999  *
1000  * Returns a translated error string which the caller must free if something
1001  * goes wrong.
1002  **/
1003 char *
1004 expr_name_set_pos (GnmNamedExpr *nexpr, GnmParsePos const *pp)
1005 {
1006         GnmNamedExprCollection *old_scope, *new_scope;
1007
1008         g_return_val_if_fail (nexpr != NULL, NULL);
1009         g_return_val_if_fail (pp != NULL, NULL);
1010
1011         old_scope = nexpr->scope;
1012         new_scope = pp->sheet ? pp->sheet->names : pp->wb->names;
1013
1014         if (old_scope != new_scope &&
1015             (g_hash_table_lookup (new_scope->placeholders, nexpr->name) ||
1016              g_hash_table_lookup (new_scope->names, nexpr->name))) {
1017                 const char *fmt = pp->sheet
1018                         ? _("'%s' is already defined in sheet")
1019                         : _("'%s' is already defined in workbook");
1020                 return g_strdup_printf (fmt, nexpr->name);
1021         }
1022
1023         if (old_scope)
1024                 g_hash_table_steal
1025                         (nexpr->is_placeholder ? old_scope->placeholders : old_scope->names,
1026                          nexpr->name);
1027
1028         nexpr->pos = *pp;
1029         gnm_named_expr_collection_insert (new_scope, nexpr);
1030         return NULL;
1031 }
1032
1033 /**
1034  * expr_name_set_expr:
1035  * @nexpr: #GnmNamedExpr to change
1036  * @texpr: (transfer full) (nullable): the new contents
1037  *
1038  * Set the content of @nexpr to @texpr.
1039  **/
1040 void
1041 expr_name_set_expr (GnmNamedExpr *nexpr, GnmExprTop const *texpr)
1042 {
1043         GSList *good = NULL;
1044
1045         g_return_if_fail (nexpr != NULL);
1046
1047         if (texpr == nexpr->texpr)
1048                 return;
1049         if (nexpr->texpr != NULL) {
1050                 GSList *deps = NULL, *junk = NULL;
1051
1052                 deps = expr_name_unlink_deps (nexpr);
1053                 expr_name_handle_references (nexpr, FALSE);
1054                 gnm_expr_top_unref (nexpr->texpr);
1055
1056                 /*
1057                  * We do not want to relink deps for sheets that are going
1058                  * away.  This speeds up exit for workbooks with lots of
1059                  * names defined.
1060                  */
1061                 while (deps) {
1062                         GSList *next = deps->next;
1063                         GnmDependent *dep = deps->data;
1064
1065                         if (dep->sheet && dep->sheet->being_invalidated)
1066                                 deps->next = junk, junk = deps;
1067                         else
1068                                 deps->next = good, good = deps;
1069
1070                         deps = next;
1071                 }
1072
1073                 g_slist_free (junk);
1074         }
1075         nexpr->texpr = texpr;
1076         dependents_link (good);
1077         g_slist_free (good);
1078
1079         if (texpr != NULL)
1080                 expr_name_handle_references (nexpr, TRUE);
1081
1082         expr_name_queue_deps (nexpr);
1083 }
1084
1085 void
1086 expr_name_add_dep (GnmNamedExpr *nexpr, GnmDependent *dep)
1087 {
1088         if (nexpr->dependents == NULL)
1089                 nexpr->dependents = g_hash_table_new (g_direct_hash,
1090                                                       g_direct_equal);
1091
1092         g_hash_table_insert (nexpr->dependents, dep, dep);
1093 }
1094
1095 void
1096 expr_name_remove_dep (GnmNamedExpr *nexpr, GnmDependent *dep)
1097 {
1098         g_return_if_fail (nexpr->dependents != NULL);
1099
1100         g_hash_table_remove (nexpr->dependents, dep);
1101 }
1102
1103 /**
1104  * expr_name_is_placeholder:
1105  * @ne:
1106  *
1107  * Returns TRUE if @ne is a placeholder for an unknown name
1108  **/
1109 gboolean
1110 expr_name_is_placeholder (GnmNamedExpr const *nexpr)
1111 {
1112         g_return_val_if_fail (nexpr != NULL, FALSE);
1113
1114         return (nexpr->texpr &&
1115                 gnm_expr_top_is_err (nexpr->texpr, GNM_ERROR_NAME));
1116 }
1117
1118 void
1119 expr_name_set_is_placeholder (GnmNamedExpr *nexpr, gboolean is_placeholder)
1120 {
1121         g_return_if_fail (nexpr != NULL);
1122
1123         is_placeholder = !!is_placeholder;
1124         if (nexpr->is_placeholder == is_placeholder)
1125                 return;
1126         nexpr->is_placeholder = is_placeholder;
1127
1128         if (nexpr->scope) {
1129                 g_hash_table_steal (is_placeholder
1130                                     ? nexpr->scope->names
1131                                     : nexpr->scope->placeholders,
1132                                     nexpr->name);
1133                 gnm_named_expr_collection_insert (nexpr->scope, nexpr);
1134         }
1135 }
1136
1137 gboolean
1138 expr_name_is_active (GnmNamedExpr const *nexpr)
1139 {
1140         g_return_val_if_fail (nexpr != NULL, FALSE);
1141         return nexpr->scope != NULL;
1142 }
1143
1144 struct cb_expr_name_in_use {
1145         GnmNamedExpr *nexpr;
1146         gboolean in_use;
1147 };
1148
1149 static void
1150 cb_expr_name_in_use (G_GNUC_UNUSED gconstpointer key,
1151                      GnmNamedExpr *nexpr,
1152                      struct cb_expr_name_in_use *pdata)
1153 {
1154         if (!pdata->in_use) {
1155                 struct cb_name_loop_check args;
1156
1157                 args.name = NULL;
1158                 args.nexpr = pdata->nexpr;
1159                 args.stop_at_name = TRUE;
1160                 args.res = FALSE;
1161                 gnm_expr_walk (nexpr->texpr->expr, cb_name_loop_check, &args);
1162                 pdata->in_use = args.res;
1163         }
1164 }
1165
1166 /**
1167  * expr_name_in_use:
1168  * @nexpr: A named expression.
1169  *
1170  * Returns: TRUE, if the named expression appears to be in use.  This is an
1171  * approximation only, as we only look at the workbook in which the name is
1172  * defined.
1173  */
1174
1175 gboolean
1176 expr_name_in_use (GnmNamedExpr *nexpr)
1177 {
1178         Workbook *wb;
1179         struct cb_expr_name_in_use data;
1180
1181         if (nexpr->dependents != NULL &&
1182             g_hash_table_size (nexpr->dependents) != 0)
1183                 return TRUE;
1184
1185         data.nexpr = nexpr;
1186         data.in_use = FALSE;
1187
1188         wb = nexpr->pos.sheet ? nexpr->pos.sheet->workbook : nexpr->pos.wb;
1189         workbook_foreach_name (wb, FALSE,
1190                                (GHFunc)cb_expr_name_in_use,
1191                                &data);
1192
1193         return data.in_use;
1194 }
1195
1196
1197 int
1198 expr_name_cmp_by_name (GnmNamedExpr const *a, GnmNamedExpr const *b)
1199 {
1200         Sheet const *sheeta = a->pos.sheet;
1201         Sheet const *sheetb = b->pos.sheet;
1202         int res = 0;
1203
1204         if (sheeta != sheetb) {
1205                 /* Locals after non-locals.  */
1206                 if (!sheeta || !sheetb)
1207                         return (!sheeta) - (!sheetb);
1208
1209                 /* By non-local sheet order.  */
1210                 res = g_utf8_collate (sheeta->name_case_insensitive,
1211                                       sheetb->name_case_insensitive);
1212         }
1213
1214         if (res == 0)   /* By name.  */
1215                 res = go_utf8_collate_casefold (a->name->str, b->name->str);
1216
1217         return res;
1218 }
1219
1220 /**
1221  * sheet_names_check:
1222  * @sheet: #Sheet
1223  * @r: #GnmRange
1224  *
1225  * Returns: (transfer none) (nullable): The name of a #GnmNamedExpr if
1226  * @sheet!@r is the target of a named range.
1227  *
1228  * Preference is given to workbook scope over sheet.
1229  **/
1230 char const *
1231 sheet_names_check (Sheet const *sheet, GnmRange const *r)
1232 {
1233         GnmNamedExpr *nexpr;
1234         GnmRange tmp;
1235
1236         g_return_val_if_fail (IS_SHEET (sheet), NULL);
1237         g_return_val_if_fail (r != NULL, NULL);
1238
1239         tmp = *r;
1240         range_normalize (&tmp);
1241         nexpr = gnm_named_expr_collection_check (sheet->names, sheet, &tmp);
1242         if (nexpr == NULL) {
1243                 nexpr = gnm_named_expr_collection_check (sheet->workbook->names, sheet, &tmp);
1244                 /* The global name is not accessible if there is a local name (#306685) */
1245                 if (nexpr != NULL &&
1246                     gnm_named_expr_collection_lookup (sheet->names, nexpr->name->str) != NULL)
1247                         return NULL;
1248         }
1249
1250         return (nexpr != NULL) ? nexpr->name->str : NULL;
1251 }
1252
1253
1254 /**
1255  * expr_name_perm_add:
1256  * @name:               name
1257  * @texpr:              string to be the value of the name
1258  * @is_editable:        whether this is a predefined action
1259  *
1260  * This is a wrapper around expr_name_add to set this as permanent name.
1261  *
1262  *
1263  **/
1264 void
1265 expr_name_perm_add (Sheet *sheet, char const *name,
1266                     GnmExprTop const *value,
1267                     gboolean is_editable)
1268 {
1269         GnmNamedExpr *res;
1270         GnmParsePos pp;
1271
1272         parse_pos_init_sheet (&pp, sheet);
1273         res = expr_name_add (&pp, name, value, NULL, TRUE, NULL);
1274         if (res) {
1275                 res->is_permanent = TRUE;
1276                 res->is_editable = is_editable;
1277         }
1278 }
1279
1280 /* ------------------------------------------------------------------------- */
1281
1282 static void
1283 expr_name_set_expr_ref (GnmNamedExpr *nexpr, GnmExprTop const *texpr)
1284 {
1285         gnm_expr_top_ref (texpr);
1286         expr_name_set_expr (nexpr, texpr);
1287 }
1288
1289 /**
1290  * expr_name_set_expr_undo_new:
1291  * @nexpr: #GnmNamedExpr
1292  *
1293  * Returns: (transfer full):
1294  **/
1295 GOUndo *
1296 expr_name_set_expr_undo_new (GnmNamedExpr *ne)
1297 {
1298         expr_name_ref (ne);
1299         gnm_expr_top_ref (ne->texpr);
1300
1301         return go_undo_binary_new (ne, (gpointer)ne->texpr,
1302                                    (GOUndoBinaryFunc)expr_name_set_expr_ref,
1303                                    (GFreeFunc)expr_name_unref,
1304                                    (GFreeFunc)gnm_expr_top_unref);
1305 }
1306
1307 /* ------------------------------------------------------------------------- */