Local Labels in C

Anyone who has written programs in the C programming language is required to be familiar with the "go to" and "labels" used in C to navigate between functions. "Local labels" is a C extension offered by GCC.

Conventional Labels vs Local Labels

In C, standard labels have a function scope. A local label, however, can be limited to an inner nested block. Since standard Labels can only be declared once in a function, local labels are used instead.

When a label is contained within a macro and the macro is expanded numerous times in a function, the label may appear more than once in the function. For instance, suppose that the definition of the macro fun Macro() includes leap statements (go to statements) inside the block and that the function foo () repeatedly calls fun Macro. Using local labels can help you avoid the issue.

Following is a local label's declaration:

_label_label;

Local label declarations must appear before any regular declarations or statements at the start of the block.

The macro IS STR EMPTY() is enlarged numerous times in the C sample that follows. Since local labels have block scope and every expansion of a macro creates a new do while block, the programme compiles and runs without error.

#include <stdio.h>
#include <string.h>
//macro-function utilising local labels
#define IS_STR_EMPTY(str)                                       
do {                                                            
        __label__  empty, not_empty, exit;                      
        if (strlen(str))                                        
                gotonot_empty;                                 
        else                                                    
                goto empty;                                     
                                                             
      not_empty:                                              
                printf("string  = %s\n", str);           
     gotoexit;                                      
        empty:                                                  
                printf("string is empty\n");                    
        exit: ;                                                 
} while(0);                                                     
intmain()
{
        charstring[20] = {'\0'};
        //Send a blank string to the macro function
        IS_STR_EMPTY(string)
        //Non-empty string sent to the macro function
        strcpy(string, "my name is khan");
        IS_STR_EMPTY(string);
        return 0;
}          

Output:

Local Labels Declaration

The label declaration only specifies the label name; the label itself is not defined. This must be done using label: within the statements of the statement expression, as per standard procedure.

The label itself is not defined; only the label name is specified in the label declaration. This must be done using label: within the assertions of the statement expression, as is customary.

Labels as values

With the unary operator "&&," you can obtain the address of a label declared in the current function (or a contained function). The field's type is *void. As a constant, this value is usable anywhere that sort of constant is allowed. For instance:

    Void *ptr;
    ...
    Ptr=&&foo;

You must be able to jump to one to use these values. The calculated goto statement(1), goto *exp; is used to accomplish this. For instance,

goto *ptr;

Any void * expression is acceptable.

Initiating a static array to act as a jump table using these constants is one use for them:

Static void *array [] = { &&foo, &&bar, &&hack);

Then you can choose a label that has indexing, as in:

Goto *array [i];

The function of such an array of label values is very similar to that of the switch statement. If a switch statement is appropriate for the circumstance, use it instead of an array because it is cleaner.

Label values can also be used in a threaded code interpreter. The threaded code can save the labels within the interpreter function for blazing-fast dispatching.

This method enables you to go to distinct function-specific code. That will cause very unexpected things to occur. The best approach to prevent this is to never send the label address as an input and only save it in automatic variables.

Nested functions

A function defined inside another function is referred to as nested function. (GNU C++ does not support nested functions.) The name of the nested function is unique to the block in which it is defined. All the variables of the contained function that are visible at the time of its definition are accessible to the nested function. The term for this is lexical scoping.

Nested function declarations are allowed within functions in any block, prior to the block's initial statement, just as variable definitions are

By storing its location or providing it to another function, it is possible to call the nested function from beyond the scope of its name:

If the label was explicitly defined in the contained function, a nested function may jump to one that was inherited from it (see section Locally Declared Labels). Such a leap exits the nested function that performed the goto as well as any intermediary functions and immediately returns to the contained function.There is always internal linking in nested functions. It is incorrect to declare one using extern. Use auto if you need to declare a nested function before it is defined.