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         go_string_unref (nexpr->name);
 819         nexpr->name = NULL;
 820
 821         if (nexpr->texpr != NULL)
 822                 expr_name_set_expr (nexpr, NULL);
 823
 824         if (nexpr->dependents != NULL) {
 825                 g_hash_table_destroy (nexpr->dependents);
 826                 nexpr->dependents  = NULL;
 827         }
 828
 829         nexpr->pos.wb      = NULL;
 830         nexpr->pos.sheet   = NULL;
 831
 832         g_free (nexpr);
 833 }
 834
 835 GType
 836 gnm_named_expr_get_type (void)
 837 {
 838         static GType t = 0;
 839
 840         if (t == 0) {
 841                 t = g_boxed_type_register_static ("GnmNamedExpr",
 842                          (GBoxedCopyFunc)expr_name_ref,
 843                          (GBoxedFreeFunc)expr_name_unref);
 844         }
 845         return t;
 846 }
 847
 848 /**
 849  * expr_name_remove:
 850  * @nexpr:
 851  *
 852  * Remove a @nexpr from its container and deactivate it.
 853  * NOTE : @nexpr may continue to exist if things still have references to it,
 854  * but they will evaluate to #REF!
 855  **/
 856 void
 857 expr_name_remove (GnmNamedExpr *nexpr)
 858 {
 859         g_return_if_fail (nexpr != NULL);
 860         g_return_if_fail (nexpr->scope != NULL);
 861
 862         if (gnm_debug_flag ("names")) {
 863                 g_printerr ("Removing name %s from its container%s\n",
 864                             nexpr->name->str,
 865                             nexpr->is_placeholder ? " as a placeholder" : "");
 866         }
 867
 868         g_hash_table_remove (
 869                 nexpr->is_placeholder ? nexpr->scope->placeholders : nexpr->scope->names,
 870                 nexpr->name);
 871 }
 872
 873 const char *
 874 expr_name_name (GnmNamedExpr const *nexpr)
 875 {
 876         g_return_val_if_fail (nexpr != NULL, NULL);
 877         return nexpr->name->str;
 878 }
 879
 880 /**
 881  * expr_name_set_name:
 882  * @nexpr: the named expression
 883  * @new_name: the new name of the expression
 884  *
 885  * returns: TRUE on error.
 886  */
 887 gboolean
 888 expr_name_set_name (GnmNamedExpr *nexpr,
 889                     const char *new_name)
 890 {
 891         const char *old_name;
 892         GHashTable *h;
 893         GOString fake_new_name;
 894
 895         g_return_val_if_fail (nexpr != NULL, TRUE);
 896         g_return_val_if_fail (nexpr->scope == NULL || new_name, TRUE);
 897
 898         old_name = nexpr->name->str;
 899         if (go_str_compare (new_name, old_name) == 0)
 900                 return FALSE;
 901
 902         fake_new_name.str = new_name;
 903 #if 0
 904         g_printerr ("Renaming %s to %s\n", old_name, new_name);
 905 #endif
 906         h = nexpr->scope
 907                 ? (nexpr->is_placeholder
 908                    ? nexpr->scope->placeholders
 909                    : nexpr->scope->names)
 910                 : NULL;
 911         if (h) {
 912                 if (new_name &&
 913                     (g_hash_table_lookup (nexpr->scope->placeholders,
 914                                           &fake_new_name) ||
 915                      g_hash_table_lookup (nexpr->scope->names,
 916                                           &fake_new_name))) {
 917                         /* The only error not to be blamed on the programmer is
 918                            already-in-use.  */
 919                         return TRUE;
 920                 }
 921
 922                 g_hash_table_steal (h, nexpr->name);
 923         }
 924
 925         go_string_unref (nexpr->name);
 926         nexpr->name = go_string_new (new_name);
 927
 928         if (h)
 929                 g_hash_table_insert (h, (gpointer)nexpr->name, nexpr);
 930
 931         return FALSE;
 932 }
 933
 934
 935 /**
 936  * expr_name_as_string:
 937  * @nexpr: A #GnmNamedExpr
 938  * @pp: (nullable): Position where name was defined.
 939  * @fmt: #GnmConventions describing how to render @nexpr
 940  *
 941  * Returns: (transfer full): The rendering of @nexpr given convention @fmt.
 942  */
 943 char *
 944 expr_name_as_string (GnmNamedExpr const *nexpr, GnmParsePos const *pp,
 945                      GnmConventions const *fmt)
 946 {
 947         if (pp == NULL)
 948                 pp = &nexpr->pos;
 949         return gnm_expr_top_as_string (nexpr->texpr, pp, fmt);
 950 }
 951
 952 /**
 953  * expr_name_eval:
 954  * @nexpr: A #GnmNamedExpr
 955  * @pos: Position where evaluation takes place
 956  * @flags: #GnmExprEvalFlags flags describing context.
 957  *
 958  * Returns: (transfer full): The resulting value.
 959  */
 960 GnmValue *
 961 expr_name_eval (GnmNamedExpr const *nexpr, GnmEvalPos const *pos,
 962                 GnmExprEvalFlags flags)
 963 {
 964         g_return_val_if_fail (pos, NULL);
 965
 966         if (!nexpr)
 967                 return value_new_error_NAME (pos);
 968
 969         return gnm_expr_top_eval (nexpr->texpr, pos, flags);
 970 }
 971
 972 /**
 973  * expr_name_downgrade_to_placeholder:
 974  * @nexpr:
 975  *
 976  * Takes a real non-placeholder name and converts it to being a placeholder.
 977  * unrefing its expression
 978  **/
 979 void
 980 expr_name_downgrade_to_placeholder (GnmNamedExpr *nexpr)
 981 {
 982         g_return_if_fail (nexpr != NULL);
 983
 984         expr_name_set_is_placeholder (nexpr, TRUE);
 985         expr_name_set_expr
 986                 (nexpr,
 987                  gnm_expr_top_new_constant (value_new_error_NAME (NULL)));
 988 }
 989
 990 /*******************************************************************
 991  * Manage things that depend on named expressions.
 992  */
 993 /**
 994  * expr_name_set_pos:
 995  * @nexpr: the named expression
 996  * @pp: the new position
 997  *
 998  * Returns a translated error string which the caller must free if something
 999  * goes wrong.
1000  **/
1001 char *
1002 expr_name_set_pos (GnmNamedExpr *nexpr, GnmParsePos const *pp)
1003 {
1004         GnmNamedExprCollection *old_scope, *new_scope;
1005
1006         g_return_val_if_fail (nexpr != NULL, NULL);
1007         g_return_val_if_fail (pp != NULL, NULL);
1008
1009         old_scope = nexpr->scope;
1010         new_scope = pp->sheet ? pp->sheet->names : pp->wb->names;
1011
1012         if (old_scope != new_scope &&
1013             (g_hash_table_lookup (new_scope->placeholders, nexpr->name) ||
1014              g_hash_table_lookup (new_scope->names, nexpr->name))) {
1015                 const char *fmt = pp->sheet
1016                         ? _("'%s' is already defined in sheet")
1017                         : _("'%s' is already defined in workbook");
1018                 return g_strdup_printf (fmt, nexpr->name);
1019         }
1020
1021         if (old_scope)
1022                 g_hash_table_steal
1023                         (nexpr->is_placeholder ? old_scope->placeholders : old_scope->names,
1024                          nexpr->name);
1025
1026         nexpr->pos = *pp;
1027         gnm_named_expr_collection_insert (new_scope, nexpr);
1028         return NULL;
1029 }
1030
1031 /**
1032  * expr_name_set_expr:
1033  * @nexpr: #GnmNamedExpr to change
1034  * @texpr: (transfer full) (nullable): the new contents
1035  *
1036  * Set the content of @nexpr to @texpr.
1037  **/
1038 void
1039 expr_name_set_expr (GnmNamedExpr *nexpr, GnmExprTop const *texpr)
1040 {
1041         GSList *good = NULL;
1042
1043         g_return_if_fail (nexpr != NULL);
1044
1045         if (texpr == nexpr->texpr)
1046                 return;
1047         if (nexpr->texpr != NULL) {
1048                 GSList *deps = NULL, *junk = NULL;
1049
1050                 deps = expr_name_unlink_deps (nexpr);
1051                 expr_name_handle_references (nexpr, FALSE);
1052                 gnm_expr_top_unref (nexpr->texpr);
1053
1054                 /*
1055                  * We do not want to relink deps for sheets that are going
1056                  * away.  This speeds up exit for workbooks with lots of
1057                  * names defined.
1058                  */
1059                 while (deps) {
1060                         GSList *next = deps->next;
1061                         GnmDependent *dep = deps->data;
1062
1063                         if (dep->sheet && dep->sheet->being_invalidated)
1064                                 deps->next = junk, junk = deps;
1065                         else
1066                                 deps->next = good, good = deps;
1067
1068                         deps = next;
1069                 }
1070
1071                 g_slist_free (junk);
1072         }
1073         nexpr->texpr = texpr;
1074         dependents_link (good);
1075         g_slist_free (good);
1076
1077         if (texpr != NULL)
1078                 expr_name_handle_references (nexpr, TRUE);
1079
1080         expr_name_queue_deps (nexpr);
1081 }
1082
1083 void
1084 expr_name_add_dep (GnmNamedExpr *nexpr, GnmDependent *dep)
1085 {
1086         if (nexpr->dependents == NULL)
1087                 nexpr->dependents = g_hash_table_new (g_direct_hash,
1088                                                       g_direct_equal);
1089
1090         g_hash_table_insert (nexpr->dependents, dep, dep);
1091 }
1092
1093 void
1094 expr_name_remove_dep (GnmNamedExpr *nexpr, GnmDependent *dep)
1095 {
1096         g_return_if_fail (nexpr->dependents != NULL);
1097
1098         g_hash_table_remove (nexpr->dependents, dep);
1099 }
1100
1101 /**
1102  * expr_name_is_placeholder:
1103  * @ne:
1104  *
1105  * Returns TRUE if @ne is a placeholder for an unknown name
1106  **/
1107 gboolean
1108 expr_name_is_placeholder (GnmNamedExpr const *nexpr)
1109 {
1110         g_return_val_if_fail (nexpr != NULL, FALSE);
1111
1112         return (nexpr->texpr &&
1113                 gnm_expr_top_is_err (nexpr->texpr, GNM_ERROR_NAME));
1114 }
1115
1116 void
1117 expr_name_set_is_placeholder (GnmNamedExpr *nexpr, gboolean is_placeholder)
1118 {
1119         g_return_if_fail (nexpr != NULL);
1120
1121         is_placeholder = !!is_placeholder;
1122         if (nexpr->is_placeholder == is_placeholder)
1123                 return;
1124         nexpr->is_placeholder = is_placeholder;
1125
1126         if (nexpr->scope) {
1127                 g_hash_table_steal (is_placeholder
1128                                     ? nexpr->scope->names
1129                                     : nexpr->scope->placeholders,
1130                                     nexpr->name);
1131                 gnm_named_expr_collection_insert (nexpr->scope, nexpr);
1132         }
1133 }
1134
1135 gboolean
1136 expr_name_is_active (GnmNamedExpr const *nexpr)
1137 {
1138         g_return_val_if_fail (nexpr != NULL, FALSE);
1139         return nexpr->scope != NULL;
1140 }
1141
1142 struct cb_expr_name_in_use {
1143         GnmNamedExpr *nexpr;
1144         gboolean in_use;
1145 };
1146
1147 static void
1148 cb_expr_name_in_use (G_GNUC_UNUSED gconstpointer key,
1149                      GnmNamedExpr *nexpr,
1150                      struct cb_expr_name_in_use *pdata)
1151 {
1152         if (!pdata->in_use) {
1153                 struct cb_name_loop_check args;
1154
1155                 args.name = NULL;
1156                 args.nexpr = pdata->nexpr;
1157                 args.stop_at_name = TRUE;
1158                 args.res = FALSE;
1159                 gnm_expr_walk (nexpr->texpr->expr, cb_name_loop_check, &args);
1160                 pdata->in_use = args.res;
1161         }
1162 }
1163
1164 /**
1165  * expr_name_in_use:
1166  * @nexpr: A named expression.
1167  *
1168  * Returns: TRUE, if the named expression appears to be in use.  This is an
1169  * approximation only, as we only look at the workbook in which the name is
1170  * defined.
1171  */
1172
1173 gboolean
1174 expr_name_in_use (GnmNamedExpr *nexpr)
1175 {
1176         Workbook *wb;
1177         struct cb_expr_name_in_use data;
1178
1179         if (nexpr->dependents != NULL &&
1180             g_hash_table_size (nexpr->dependents) != 0)
1181                 return TRUE;
1182
1183         data.nexpr = nexpr;
1184         data.in_use = FALSE;
1185
1186         wb = nexpr->pos.sheet ? nexpr->pos.sheet->workbook : nexpr->pos.wb;
1187         workbook_foreach_name (wb, FALSE,
1188                                (GHFunc)cb_expr_name_in_use,
1189                                &data);
1190
1191         return data.in_use;
1192 }
1193
1194
1195 int
1196 expr_name_cmp_by_name (GnmNamedExpr const *a, GnmNamedExpr const *b)
1197 {
1198         Sheet const *sheeta = a->pos.sheet;
1199         Sheet const *sheetb = b->pos.sheet;
1200         int res = 0;
1201
1202         if (sheeta != sheetb) {
1203                 /* Locals after non-locals.  */
1204                 if (!sheeta || !sheetb)
1205                         return (!sheeta) - (!sheetb);
1206
1207                 /* By non-local sheet order.  */
1208                 res = g_utf8_collate (sheeta->name_case_insensitive,
1209                                       sheetb->name_case_insensitive);
1210         }
1211
1212         if (res == 0)   /* By name.  */
1213                 res = go_utf8_collate_casefold (a->name->str, b->name->str);
1214
1215         return res;
1216 }
1217
1218 /**
1219  * sheet_names_check:
1220  * @sheet: #Sheet
1221  * @r: #GnmRange
1222  *
1223  * Returns: (transfer none) (nullable): The name of a #GnmNamedExpr if
1224  * @sheet!@r is the target of a named range.
1225  *
1226  * Preference is given to workbook scope over sheet.
1227  **/
1228 char const *
1229 sheet_names_check (Sheet const *sheet, GnmRange const *r)
1230 {
1231         GnmNamedExpr *nexpr;
1232         GnmRange tmp;
1233
1234         g_return_val_if_fail (IS_SHEET (sheet), NULL);
1235         g_return_val_if_fail (r != NULL, NULL);
1236
1237         tmp = *r;
1238         range_normalize (&tmp);
1239         nexpr = gnm_named_expr_collection_check (sheet->names, sheet, &tmp);
1240         if (nexpr == NULL) {
1241                 nexpr = gnm_named_expr_collection_check (sheet->workbook->names, sheet, &tmp);
1242                 /* The global name is not accessible if there is a local name (#306685) */
1243                 if (nexpr != NULL &&
1244                     gnm_named_expr_collection_lookup (sheet->names, nexpr->name->str) != NULL)
1245                         return NULL;
1246         }
1247
1248         return (nexpr != NULL) ? nexpr->name->str : NULL;
1249 }
1250
1251
1252 /**
1253  * expr_name_perm_add:
1254  * @name:               name
1255  * @texpr:              string to be the value of the name
1256  * @is_editable:        whether this is a predefined action
1257  *
1258  * This is a wrapper around expr_name_add to set this as permanent name.
1259  *
1260  *
1261  **/
1262 void
1263 expr_name_perm_add (Sheet *sheet, char const *name,
1264                     GnmExprTop const *value,
1265                     gboolean is_editable)
1266 {
1267         GnmNamedExpr *res;
1268         GnmParsePos pp;
1269
1270         parse_pos_init_sheet (&pp, sheet);
1271         res = expr_name_add (&pp, name, value, NULL, TRUE, NULL);
1272         if (res) {
1273                 res->is_permanent = TRUE;
1274                 res->is_editable = is_editable;
1275         }
1276 }
1277
1278 /* ------------------------------------------------------------------------- */
1279
1280 static void
1281 expr_name_set_expr_ref (GnmNamedExpr *nexpr, GnmExprTop const *texpr)
1282 {
1283         gnm_expr_top_ref (texpr);
1284         expr_name_set_expr (nexpr, texpr);
1285 }
1286
1287 /**
1288  * expr_name_set_expr_undo_new:
1289  * @nexpr: #GnmNamedExpr
1290  *
1291  * Returns: (transfer full):
1292  **/
1293 GOUndo *
1294 expr_name_set_expr_undo_new (GnmNamedExpr *ne)
1295 {
1296         expr_name_ref (ne);
1297         gnm_expr_top_ref (ne->texpr);
1298
1299         return go_undo_binary_new (ne, (gpointer)ne->texpr,
1300                                    (GOUndoBinaryFunc)expr_name_set_expr_ref,
1301                                    (GFreeFunc)expr_name_unref,
1302                                    (GFreeFunc)gnm_expr_top_unref);
1303 }
1304
1305 /* ------------------------------------------------------------------------- */