Symbols and the SSC

Symbols
What is a symbol? In terms of UOS, a symbol is a named value that is stored by the operating system. UOS Symbols serve several important functions. One of these functions is for the purpose of shells, which are scripting mechanisms and user-interfaces for UOS. Any decent scripting mechanism will need to store and retrieve values (sometimes called variables). The shell could keep track of its own symbols, but there are a couple of advantages to having the operating system manage them instead. First, it simplifies the implementation of shells. Second, using UOS symbols allows the symbols to be shared between different shells and easily queried by programs. Third, symbols are used to implement some UOS features such as logical devices and program option defaulting. Symbols are managed by the System Services Component (SSC), which we will discuss later in this article.

The SSC doesn't care what names are used for symbols, as long as they don't contain NUL characters (ASCII 0). However, all official UOS usage will follow the following rules (and for practical purposes, shells should also follow suit): All symbols should start with an alphabetic value (A-Z, or similar Unicode values for other languages). They should only consist of human-readable glyphs (nothing less than ASCII 32), and should not contain spaces, colons, slashes, or backslashes. Further, all UOS-specific symbols will contain a single dollar sign ($). A single dollar sign should not be used by applications in order to avoid a name collision with UOS symbols (multiple dollar signs are okay). Typically, UOS symbols will start with a three-letter prefix, followed by a dollar-sign, and then some alphanumeric characters. An example of this is the sys$system symbol that we mentioned in the previous article. UOS symbols are also case-insensitive. That is, SYS$SYSTEM is the same symbol as sys$system. This might cause a bit of a problem with some Unix shells, and we may talk about ways around this issue in the future.

In terms of the values of symbols, any data can be stored in them. There is no official limit to the size of the symbols' content, but large amounts of symbol data will use large amounts of memory. It is best to use files to store big data. Symbols serve the same purpose in shells as variables do in languages such as C++ and Pascal.

Symbols are stored in groups called "symbol tables". Within a given symbol table, each symbol must be uniquely named - there cannot be multiple symbols with the same name in the same table. Each process that is running has its own symbol table. Generally, processes do not share symbols with each other (although there are some exceptions to this). This is similar to the different local variables in different functions in a program. That is, the scope of the variables is limited to the code in which they are defined. There are some cases, though, where symbols can be shared between processes. For instance, there is a system symbol table that is accessible by any/all processes on the system. However, although symbols in this table can be read by any process, only certain users are allowed to add new symbols to it, delete them, or modify existing ones. One example of a symbol in the system symbol table is sys$system. There are other symbol tables. Here are their names and short descriptions of them:

Table	Description
LNM$CLUSTER	Cluster-wide symbols. We will discuss clusters in a future article.
LNM$SYSTEM	System-wide symbols.
LNM$GROUP	Group-wide symbols. We will discuss groups in the future.
LNM$JOB	Symbols for the job (all processes in tree). Each job has its own job process symbol.
LNM$PROCESS	Symbols for the process. Each process has its own process symbol table.

The above list of tables indicates the order of scoping (outermost at the top, innermost at the bottom). Note that the very name of the tables are symbols in themselves.

One consequence of the foregoing: a symbol defined for a process is used in place of a symbol of the same name that exists in more outer scope. That is, if a process defines sys$system, then the process symbol is used instead of the sys$system value from the system symbol table whenever that symbol is referenced. In other words, symbols in the process table override symbols of the same name in the job symbol table, which overrides symbols in the group symbol table, and so on. Although an application can specify which table to use when it comes to accessing/creating a symbol, the shells will use the aforementioned scoping rules by default.

Another use of symbols is for that of defaulting application options. This is something that we will discuss in detail in a future article. For now, I'll summarize it thus: a given application can use a symbol to determine the options to use when it is run. The user can explicitly override these options when they run the program, or they can define their own process symbol which will be used instead of the system default. This happens because the local symbol scope overrides the outer scope of the system symbol table.

Physical and Virtual devices
We discussed device names in previous articles. Devices with names like DISKA0 or TERMA1 indicate specific hardware devices. But there are also device names for virtual devices such as RAM disks and RAID disks. In the future, we will also discuss virtual terminal devices as well. We will refer to all of these devices as "physical devices", with the term "virtual device" used specifically for those devices which are not tied to an actual hardware device.

Logical devices
Indirection is a powerful and commonly used technique in computer science. In general, the idea is that instead of something existing at a specific location, that specific location contains an address of the actual object. We've already seen this with the installed.sys file that we talked about in the previous article. Rather than placing the UOS installation in a specific location that UOS knows about, we instead put the location of the installation in the installed.sys file and use it to find the directory. UOS knows where to find installed.sys, which tells it where to find the directory containing the booted installation. The following figure illustrates this:

One of the most important functions served by UOS symbols is that of logical devices, or more simply - just "logicals". Any UOS symbol that is suffixed with a colon and used in a filename specification is evaluated and replaced with its contents. This provides a means of redirection. This is, in fact, what sys$system is used for. It contains the physical device name, and path, for the system directory for the booted installation of UOS. For instance, if sys$system has a value of "DISKA0:\uos\uos1" and we reference "sys$system:\file.txt", it is translated to "DISKA0:\uos\uos1\file.txt". So, in essence, sys$system serves as a logical device. From the standpoint of UOS, it can be used in place of any physical device name.

Where would this feature be used in real life? Let's consider your typical Microsoft Windows system. Let's say that you install a new game called Cowcraft. Being a newer game, it takes about 50 Gb of your disk space. It installs to a specific folder on your C: drive. Over time, you install a bunch of other software and the free space on your C: drive disappears. Now you have to make room on your C: drive in order to install even more programs. Fortunately, you have a D: drive, which has a lot of free space. So, what do you do? You uninstall Cowcraft from C: and reinstall it on D:. Because it is a big game, this takes a fair amount of time. Repeat this for each program you need to move to D:. And let's hope you don't have to uninstall/reinstall it again when D: runs low on disk space. UOS provides a much easier way of dealing with this. In the UOS approach, the initial installation of Cowcraft defines a system logical called "cowcraft" that points to its installed location. If you need to move it, you simply copy it from its current location to a new location and change "cowcraft:" to point to the new location. There is no need to reinstall, because all references to the game (whether on your desktop, in the registry, in configuration files, or anywhere else) use Cowcraft: to find it. Further, and perhaps even more importantly, the data associated with the game can be assigned to a different logical, such as Cowcraftdata:, so that it can be moved independently of the program files themselves (and this is a good thing, considering that the data associated with the application may exceed the size of the application by several orders of magnitude). Changing the value of a logical is much simpler and faster than a reinstall.

Logicals can also contain references to other logicals, allowing the system administrator (or users) to create an entire hierarchy of redirection. Note that this can create a potential infinite loop as UOS tries to resolve a logical device reference. We will discuss this situation later in this article. But what happens if a logical name matches a physical device name? For instance, what if you define DISKA0: as a logical? How then, do you ever get to the actual physical device? Symbol names cannot start with an underscore, so UOS knows that any device name that is prefixed with an underscore references a physical device. Thus, _DISKA0: can always be used to reference the first physical store, even if DISKA0 has been (re)defined.

Finally, logicals can contain several paths. This is something that we will discuss later in this article and in the next article.

Link files also provide a means of redirection, as we discussed with installed.sys and default.sys. However, these two files are the only links that UOS makes use of. Logicals provide several advantages over links. For instance, links can only link to one specific place, whereas logicals can link to a list of target locations. Links can only link to another location on the same store, whereas logicals can link to any device. Maintaining link files to keep the file system structure consistent can be time-consuming. In fact, if it weren't for the sake of being Posix-compliance, we wouldn't bother supporting link files at all. One advantage to links over logicals is that the definition of the redirection is essentially "baked" into the file structure, which logicals are not. The Linux file system also provides links, which can be soft links or hard links. They both operate the same, and differ mostly in how they are implemented. We will talk more about links in the future.

Windows provides a form of logicals for some system folders. For instance %APPDATA% can be used in Windows explorer to refer to the application data folder. However, these cannot be used in file specifications outside of explorer, nor can they be overridden or redefined, and they cannot contain multiple paths. As is typical with Windows, it provides a half-baked (or, in this case, quarter-baked) implementation of what UOS does.

Multiply-scoped symbols are a powerful feature of UOS. However, it is often the case that such a powerful feature can lead to security issues. Consider the case of database server software that stores a file of access information in a directory pointed to by the logical SQLData:. If a user overrides the SQLData symbol to point to his own directory containing his own file of access information, when the database goes to authenticate a user, it could end up authenticating against a faux file and allowing unauthorized people to access data. So, although we generally want to allow the user the flexibility of overriding symbols with his local process table, applications need to consider this possible means of subversion - if it applies. Fortunately, UOS provides a means of easily avoiding this pitfall. Although the application could choose to read the value of the symbol directly from LNM$SYSTEM, it is easier (and more foolproof) to prefix such logicals with an underscore. "Wait!" you say. Doesn't an underscore prefix mean a physical device specification? Yes, it does. However, if the logical doesn't match a physical device (and something like "SQLData" never would) then UOS looks in LNM$SYSTEM for the translation of the logical name. So, using _SQLData: will use the value of SQLData from LNM$SYSTEM even if the user had SQLData defined in LNM$PROCESS. The only restriction here is that any system symbol with the same name as a physical device is essentially invisible when the underscore prefix is used. The solution is simple: don't use physical device names as system symbol names. Do use underscores to force use of the LNM$SYSTEM table for logicals which point to data that the user shouldn't be able to override. In most cases, this won't be an issue. But to build a secure operating system, we need to take such issues into consideration from the start.

I would be remiss if I didn't point out that we are diverging a bit from strict adherence to the VMS specification. VMS makes a distinction between symbols and logicals. They are treated as completely separate features. In fact the LNM$ prefix is a contraction for "Logical NaMes". UOS combines the two features into one because it simplifies things. And just because logicals are used differently doesn't mean that they should be implemented differently. UOS simply has symbols, and they can be used as logicals if so desired. There are some other minor differences from VMS as well, but I mentioned back at the start of these articles that we would occasionally not match VMS exactly.

The SSC
Each executive component contains the methods specific to its purpose. For instance, the HMC contains heap managment methods and the USC contains user and security-related methods. But there are some features that are used by multiple executive components. The System Services Component (SSC) is, essentially, the place for features that don't fit in another component and are used by multiple components. These "system services" should not be confused with the system services provided to application programs, which we will discuss in the future. In this article, we will only be looking at the symbol table handling portion of the SSC. Here's the class definition:

type TUOS_SSC = class( TUOS_System_Services )
                    private // Instance data...
                        _Kernel : TUOS_Kernel ;
                        _System_Symbols : TSymbol_Table ;
                        _Cluster_Symbols : TSymbol_Table ;
                        _FiP : TUOS_File_Processor ;
                        _USC : TUOS_User_Security ;

                        _Temp : TString ;
                        TempS : string ;

                    public // Utility routines...
                        function Cluster_Symbols : TSymbol_Table ;
                        function System_Symbols : TSymbol_Table ;
                        function USC : TUOS_User_Security ;
                        function FiP : TUOS_File_Processor ;
                        function Resolve_Table( LNTable, PID : cardinal ;
                            var N : string ) : TUOS_Symbol_Table ;
                        function Temp : TString ;

                    public // API...
                        function Is_Class( N : PChar ) : boolean ; override ;

                        procedure Set_Error( E : longint ) ;
                        procedure Set_Kernel( K : TUOS_Kernel ) ; override ;

                        function Set_Symbol( LNTable, PID : cardinal ;
                            Name : PChar ; Def : TUOS_String ) : boolean ;
                            override ;
                        function Get_Symbol( LNTable, PID : cardinal ;
                            Name : PChar ) : TUOS_String ; override ;
                        procedure Delete_Symbol( LNTable, PID : cardinal ;
                            Name : PChar ) ; override ;
                        function Resolve_Symbol( PID : cardinal ;
                            Name : PChar ) : TUOS_String ;
                            override ;
                end ; // TUOS_SSC

Here are the utility methods:

// Utility routines...

function TUOS_SSC.Temp : TString ;

begin
    if( _Temp = nil ) then
    begin
        _Temp := TString.Create ;
    end ;
    Result := _Temp ;
end ;


function TUOS_SSC.Cluster_Symbols : TSymbol_Table ;

begin
    if( _Cluster_Symbols = nil ) then
    begin
        _Cluster_Symbols := TSymbol_Table.Create ;
    end ;
    Result := _Cluster_Symbols ;
end ;


function TUOS_SSC.System_Symbols : TSymbol_Table ;

begin
    if( _System_Symbols = nil ) then
    begin
        _System_Symbols := TSymbol_Table.Create ;
    end ;
    Result := _System_Symbols ;
end ;


function TUOS_SSC.USC : TUOS_User_Security ;

begin
    if( _USC = nil ) then
    begin
        _USC := _Kernel.USC ;
    end ;
    Result := _USC ;
end ;


function TUOS_SSC.FiP : TUOS_File_Processor ;

begin
    if( _FiP = nil ) then
    begin
        _FiP := _Kernel.FiP ;
    end ;
    Result := _FiP ;
end ;

Here are the "standard" support methods used in all executive components:

// API...

function TUOS_SSC.Is_Class( N : PChar ) : boolean ;

var _N : string ;

begin
    _N := string( N ) ;
    Result := lowercase( _N ) = 'tuos_ssc' ;
end ;


procedure TUOS_SSC.Set_Error( E : longint ) ;

begin
    Set_Last_Error( Create_Error( E ) ) ;
end ;


procedure TUOS_SSC.Set_Kernel( K : TUOS_Kernel ) ;

begin
    _Kernel := K ;
end ;

Most of our methods need to determine which of the various symbol tables to use for a given operation. Rather than replicate the code in each place, we have a utility function that will determine which table to use and to do other validation. Here is that function:

function TUOS_SSC.Resolve_Table( LNTable, PID : cardinal ; var N : string ) : TUOS_Symbol_Table ;

begin
    Result := nil ; // Assume failure...
    if( length( N ) = 0 ) then
    begin
        Set_Error( UOSErr_Missing_Name ) ;
        exit ;
    end ;
    if( LNTable = LNM_SYSTEM ) then // System-level
    begin
        if( N[ 1 ] = '_' ) then
        begin
            N := copy( N, 2, length( N ) ) ;
        end ;
        if( length( N ) = 0 ) then
        begin
            Set_Error( UOSErr_Missing_Name ) ;
            exit ;
        end ;
    end ;
    if( N[ 1 ] = '_' ) then
    begin
        Set_Error( UOSErr_Invalid_Symbol_Name ) ;
        exit ;
    end ;

    // Determine which table...
    case LNTable of
        LNM_GROUP, LNM_JOB: // Group- and Job-specific (all processes in tree)
            Result := USC.Symbols( LNTable, PID, 0 ) ;
        LNM_SYSTEM: // System-specific
            Result := System_Symbols ;
        LNM_CLUSTER: // Cluster-specific
            Result := Cluster_Symbols ;
        else // Process-specific
            Result := USC.Symbols( LNM_PROCESS, PID, 0 ) ;
    end ; // case Table
end ;

Now let's look at the Set_Symbol method.

function TUOS_SSC.Set_Symbol( LNTable, PID : cardinal ; Name : PChar ;
    Def : TUOS_String ) : boolean ;

var N : string ;
    Table : TUOS_Symbol_Table ;

begin
    // Setup...
    Result := False ;
    N := string( Name ) ;
    Set_Last_Error( nil ) ;
    N := Edit( N, 8 or 128 ) ;
    Table := Resolve_Table( LNTable, PID, N ) ;
    if( Table = nil ) then
    begin
        exit ;
    end ;

    // Determine which table...
    case LNTable of
        LNM_GROUP, LNM_JOB: // Group- and Job-specific (all processes in tree)
            Table := USC.Symbols( LNTable, PID, 0 ) ;
        LNM_SYSTEM: // System-specific
            Table := System_Symbols ;
        LNM_CLUSTER: // Cluster-specific
            Table := Cluster_Symbols ;
        else // Process-specific
            Table := USC.Symbols( LNM_PROCESS, PID, 0 ) ;
    end ; // case Table

    // Assign value...
    Table.Set_Value( PChar( N ), Def.Contents, Def.Size ) ;
end ; // TUOS_SSC.Set_Symbol

Now that we have a way to set a value, we need a way to get a value.

function TUOS_SSC.Get_Symbol( LNTable, PID : cardinal ; Name : PChar ) : TUOS_String ;

var Len : integer ;
    N : string ;
    Table : TUOS_Symbol_Table ;

begin
    // Setup...
    Result := nil ;
    N := string( Name ) ;
    Set_Last_Error( nil ) ;
    N := Edit( N, 8 or 128 ) ;

    // Return value...
    case LNTable of
        LNM_JOB, LNM_GROUP, LNM_PROCESS, LNM_SYSTEM, LNM_CLUSTER:
            begin
                Table := Resolve_Table( LNTable, PID, N ) ;
            end ;
        else // Check all
            begin
                // Check process first...
                Result := Get_Symbol( LNM_PROCESS, PID, Name ) ;
                if( Result <> nil ) then
                begin
                    exit ;
                end ;

                // Check job second...
                Result := Get_Symbol( LNM_JOB, PID, Name ) ;
                if( Result <> nil ) then
                begin
                    exit ;
                end ;

                // Check groups third...
                Result := Get_Symbol( LNM_GROUP, PID, Name ) ;
                if( Result <> nil ) then
                begin
                    exit ;
                end ;

                // Check system fourth...
                Result := Get_Symbol( LNM_SYSTEM, PID, Name ) ;
                if( Result <> nil ) then
                begin
                    exit ;
                end ;

                // Finally check cluster...
                Result := Get_Symbol( LNM_CLUSTER, PID, Name ) ;
                exit ;
            end ;
    end ; // case Table

    if( Table = nil ) then // No corresponding table
    begin
        exit ;
    end ;
    if( Table.Exists( PChar( N ) ) ) then
    begin
        Temp.P := Table.Value( PChar( N ), Len ) ;
        _Temp.Len := Len ;
        Result := Temp ;
    end ;
end ; // TUOS_SSC.Get_Symbol

Now that we can create, modify, and read symbols, the other main operation we need is a way to delete a symbol from a table. The following function does this for us.

procedure TUOS_SSC.Delete_Symbol( LNTable, PID : cardinal ; Name : PChar ) ;

var N : string ;
    Table : TUOS_Symbol_Table ;

begin
    // Setup...
    N := string( Name ) ;
    Set_Last_Error( nil ) ;
    N := Edit( N, 8 or 128 ) ;
    Table := Resolve_Table( LNTable, PID, N ) ;
    if( Table = nil ) then
    begin
        exit ;
    end ;

    // Assign value...
    Table.Delete( PChar( N ) ) ;
end ; // TUOS_SSC.Delete_Symbol

The final function is the most complicated symbol-related code. This function is used to resolve the value of a symbol, looking for it in the symbol table hierarchy. More than that, it also handles logical redirection - including those with multiple paths.

function TUOS_SSC.Resolve_Symbol( PID : cardinal ; Name : PChar ) : TUOS_String ;

begin // TUOS_SSC.Resolve_Symbol
    // Setup...
    Result := nil ;
    N := string( Name ) ;
    Set_Last_Error( nil ) ;
    N := Edit( N, 8 or 128 ) ;
    if( length( N ) = 0 ) then
    begin
        Set_Error( UOSErr_Missing_Name ) ;
        exit ;
    end ;
    Device_Table := FiP.Device_Table ;

    // Determine starting table and max iterations...
    Max_Iterations := Cluster_Symbols.Count + System_Symbols.Count +
        Count_For( LNM_PROCESS ) + Count_For( LNM_GROUP ) + Count_For( LNM_JOB ) + 1 ;

    // Resolve the symbol
    TempS := N ;
    _Resolve( TempS ) ;
    Result := Temp ;
    Temp.P := PChar( TempS ) ;
    Temp.Len := length( TempS ) ;

    if( Max_Iterations < 0 ) then
    begin
        Set_Error( UOSErr_Infinite_Symbol_Recursion ) ;
        Result := nil ;
    end ;
end ; // TUOS_SSC.Resolve_Symbol

Here is the code for the local Count_For function:

    function Count_For( LNTable : cardinal ) : cardinal ;

    var Table : TUOS_Symbol_Table ;

    begin
        Result := 0 ;
        if( USC = nil ) then
        begin
            exit ;
        end ;
        Table := USC.Symbols( LNTable, PID, 0 ) ;
        if( Table <> nil ) then
        begin
            Result := Table.Count ;
        end ;
    end ;

Here is the code for _Resolve:

var Max_Iterations : integer ;
    N : string ;
    Device_Table : TUOS_Symbol_Table ;

    function _Resolve( var N : string ) : boolean ;

    var Dummy : integer ;
        Res : TUOS_String ;
        S, Suffix, Work : string ;

    begin
        // Simple case...
        Result := True ;
        if( pos( ':', N ) < 2 ) then // No colon, or starts with colon = no translation needed
        begin
            exit ;
        end ;

        // Recursion check...
        dec( Max_Iterations ) ;
        if( Max_Iterations < 0 ) then
        begin
            N := '' ;
            exit ;
        end ;

    // Parse and process...
    S := N ;
    N := '' ;
    while( length( S ) > 0 ) do
    begin
        Dummy := Quote_Pos( ';', S ) ;
        if( Dummy = 0 ) then // No more paths
        begin
            Work := S ;
            S := '' ;
        end else
        begin
            Work := copy( S, 1, Dummy ) ;
            S := copy( S, Dummy + 1, length( S ) ) ;
        end ;

Now we process the current path (in Work).

        if( Dummy < 2 ) then // No colon (or starts with colon)
        begin
            N := N + Work ;
        end else
        begin
            // Parse symbol and suffix...
            Suffix := copy( Work, Dummy + 1, length( Work ) ) ;
            setlength( Work, Dummy ) ;

            // Resolve symbol...
            if( not Device_Table.Exists( PChar( Work ) ) ) then // Not a device name
            begin
                Result := False ;

                if( Work[ 1 ] = '_' ) then // System symbol prefix
                begin
                    Work := copy( Work, 2, length( Work ) ) ;
                    Res := Get_Symbol( LNM_System, PID, PChar( Work ) ) ;
                    if( Res <> nil ) then
                    begin
                        Work := Res.Contents ;
                        Result := True ;
                        if( pos( ':', Work ) > 1 ) then
                        begin
                            _Resolve( Work ) ; // Further translation required
                            if( Work = '' ) then
                            begin
                                Suffix := '' ;
                            end ;
                        end ;
                    end else
                    begin
                        Work := '_' + Work ; // Restore underscore
                    end ;
                end else

If the underscore prefix is not used, we must resolve the symbol using the symbol table hierarchy.

            begin
                Res := Get_Symbol( LNM_All, PID, PChar( Work ) ) ;
                if( Res <> nil ) then
                begin
                    Work := Res.Contents ;
                    Result := True ;
                end ;
                if( not Result ) then
                begin
                    Result := Device_Table.Exists( PChar( '_' + Work ) ) ;
                    if( Result ) then
                    begin
                        Work := '_' + Work ;
                        N := N + Insert_Suffix( Work, Suffix ) ;
                        continue ;
                    end else
                    begin
                        Work := '' ;
                    end ;
                end ;
                if( not Result ) then
                begin
                    Suffix := '' ;
                end else
                if( pos( ':', Work ) > 0 ) then
                begin
                    _Resolve( Work ) ; // Further translation required
                    if( Work = '' ) then
                    begin
                        Suffix := '' ;
                    end ;
                end ;
            end ;
        end ; // if( not Device_Table.Exists( PChar( Work ) ) )

        // Build result...
        N := N + Insert_Suffix( Work, Suffix ) ;
        end ; // if( Dummy = 0 ) else
    end ; // while( length( S ) > 0 )
    Result := True ;
end ; // _Resolve

Here is the code for the Quote_Pos function:

function Quote_Pos( const SS, S : string ; Index : integer = 1 ) : integer ;

var Quote : char ;

begin
    // Setup...
    Result := 0 ; // Assume failure
    if( ( length( SS ) = 0 ) or ( length( S ) = 0 ) ) then
    begin
        exit ;
    end ;
    Quote := ' ' ;

    // Search for substring...
    while( Index <= length( S ) - length( SS ) + 1 ) do
    begin
        if( Quote <> ' ' ) then
        begin
            if( S[ Index ] = Quote ) then
            begin
                Quote := ' ' ; // Unquoted
            end ;
            inc( Index ) ;
            continue ;
        end else
        if( S[ Index ] = '"' ) then
        begin
            Quote := S[ Index ] ;
            inc( Index ) ;
            continue ;
        end ;
        if( copy( S, Index, length( SS ) ) = SS ) then
        begin
            Result := Index ;
            exit ;
        end ;
        inc( Index ) ;
    end ; // while...
end ; // Quote_Pos

Here is the code for the Insert_Suffix function:

function Insert_Suffix( const S, Suffix : string ) : string ;

var Dummy, Start : integer ;

begin
    if( length( Suffix ) = 0 ) then
    begin
        Result := S ;
        exit ;
    end ;

    Result := '' ;
    Dummy := Quote_Pos( ';', S ) ;
    Start := 1 ;
    while( Dummy <> 0 ) do
    begin
        Result := Result + copy( S, Start, Dummy - Start ) + Suffix ;
        Start := Dummy ;
        Dummy := Quote_Pos( ';', S, Dummy + 1 ) ;
    end ;
    Result := Result + copy( S, Start, length( S ) ) + Suffix ;
end ; // Insert_Suffix

In the next article, we will discuss the implementation of the File Processor component.

Copyright © 2017 by Alan Conroy. This article may be copied in whole or in part as long as this copyright is included.