Fix conflicts when changing the number of instances from 1 to many or viceversa

[EmilioPeJu]

Some scripts depend on the BLOCK{number} naming convention and would break if there is only one instance for one target. @coretl, Do you have some specific script in mind we could focus on?

One approach is always using the instance number even for singleton blocks, but this could break backward compatibility or require the script to do extra checks for an old panda. Another approach is finding and fixing the cases in which BLOCK is not equivalent to BLOCK1. This last approach might also need some extra changes in the scripts because of the possible difference between the canonical names (returned by *CHANGES?) and the name used during field configuration.

There is some related discussion here.

[coretl]

This is Malcolm (still in use for the next 3 years):
https://github.com/DiamondLightSource/pymalcolm/blob/264ec4a319092a545853f41f89ddf1d21da56504/malcolm/modules/pandablocks/controllers/pandamanagercontroller.py#L165-L172

This is PandABlocks-ioc (still in use for the next 1 year):
https://github.com/PandABlocks/PandABlocks-ioc/blob/c1e8056abf3f680fa3840493eb4ac6ca2be31313/src/pandablocks_ioc/ioc.py#L1976-L1982

This is fastcs-PandABlocks (what we are moving to everywhere):
https://github.com/PandABlocks/fastcs-PandABlocks/blob/f2bf17e1f67aba2d93f1a0ce04b47bf3f159528c/src/fastcs_pandablocks/panda/blocks/blocks.py#L163-L170

All of them look at number in *BLOCKS, then says "if number is 1 then expect the value from *CHANGES to come in without the number".

I suggest we:

• Add the "singleton" option to the TCP server
• If this is set then send the number of blocks as 1, otherwise if there is a single block then send +1 (there is one, but there could be more in the future, so leave the trailing numbers)
• Leave the output of *CHANGES as it is
• Make sure you can do BLOCK.FIELD= and BLOCK1.FIELD= and BLOCK.FIELD? and BLOCK1.FIELD? whether BLOCK is a singleton or not
• Add support to Malcolm and fastcs-PandABlocks for number of blocks 01 and BLOCK1 or BLOCK entries in *CHANGES, and use this to work out whether the canonical name is BLOCK or BLOCK1
• In a year's time then we switch *CHANGES over to always put the number in

[Araneidae]

This was my first stab at implementing singleton support:

diff --git a/server/database.c b/server/database.c
index 7c53dae..0defe4c 100644
--- a/server/database.c
+++ b/server/database.c
@@ -67,14 +67,16 @@ static error__t config_parse_normal_header(
     /* Parse input of form <name> [ "[" <count> "]" ]. */
     char block_name[MAX_NAME_LENGTH];
     unsigned int count = 1;
+    bool singleton = true;
     struct block *block;
     return
         parse_block_name(line, block_name, sizeof(block_name))  ?:
         IF(read_char(line, '['),
+            DO(singleton = false)  ?:
             parse_uint(line, &count)  ?:
             parse_char(line, ']'))  ?:
 
-        create_block(&block, block_name, count)  ?:
+        create_block(&block, block_name, count, singleton)  ?:
         DO(*parser = (struct indent_parser) {
             .context = block,
             .parse_line = config_parse_field_line });
diff --git a/server/fields.c b/server/fields.c
index 773400f..c4afb2f 100644
--- a/server/fields.c
+++ b/server/fields.c
@@ -39,6 +39,7 @@
 struct block {
     char *name;                 // Block name
     unsigned int count;         // Number of instances of this block
+    bool singleton;             // If set number is not part of block name
     unsigned int base;          // Block register base
     struct hash_table *fields;  // Map from field name to fields
     char *description;          // User readable description
@@ -299,7 +300,7 @@ size_t format_field_name(
     unsigned int number, char suffix)
 {
     size_t result;
-    if (field->block->count == 1)
+    if (field->block->singleton)
         result = (size_t) snprintf(string, length, "%s.%s",
             field->block->name, field->name);
     else
@@ -607,12 +608,13 @@ static const struct class_methods *classes_table[] = {
 
 
 error__t create_block(
-    struct block **block, const char *name, unsigned int count)
+    struct block **block, const char *name, unsigned int count, bool singleton)
 {
     *block = malloc(sizeof(struct block));
     **block = (struct block) {
         .name = strdup(name),
         .count = count,
+        .singleton = singleton,
         .base = UNASSIGNED_REGISTER,
         .fields = hash_table_create(false),
     };
diff --git a/server/fields.h b/server/fields.h
index ea66005..39109bc 100644
--- a/server/fields.h
+++ b/server/fields.h
@@ -185,7 +185,7 @@ const struct enumeration *get_field_enumeration(const struct field *field);
  * register base must be given.  Once this has been created the subsiduary
  * fields can be created. */
 error__t create_block(
-    struct block **block, const char *name, unsigned int count);
+    struct block **block, const char *name, unsigned int count, bool singleton);
 
 /* Sets base address for block. */
 error__t parse_block_set_register(const char **line, struct block *block);

I suspect this is only touching the surface of this issue.