Note on FORTRAN and C Versions

This document covers the FORTRAN version of the interfaces of this subsystem. CSPICE provides f2c translated equivalents for all, and native C wrappers for some of them. If you wish to use the C versions of the interfaces described in this document, refer to the CSPICE Required Reading, cspice.req, for more information on naming conventions, locations, and usage of the f2c'ed routines and native C wrappers.

Scanning Routines in SPICELIB

Fortran offers a single intrinsic function for locating substrings within a string: INDEX. Given an arbitrary character string and a target string,

   LOC = INDEX ( STRING, TARGET )

   ( STRING(LOC : LOC+LEN(TARGET)-1)  .EQ.  TARGET )

   INDEX ( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'GHI' )

   INDEX ( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', '123'  )
   INDEX ( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'ghi'  )
   INDEX ( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'GHI ' )
   INDEX ( 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', ' GHI' )

-- begin a search at any location within the string.

-- search in two directions: forward (left to right), and reverse (right to left).

-- search for a multi-character substring; or for any character contained in an arbitrary collection; or for any character NOT contained in an arbitrary collection.

   POS    ( STR, SUBSTR, START )
   CPOS   ( STR, CHARS,  START )
   NCPOS  ( STR, CHARS,  START )
   POSR   ( STR, SUBSTR, START )
   CPOSR  ( STR, CHARS,  START )
   NCPOSR ( STR, CHARS,  START )

Substring searches

POS is just like INDEX, but takes a third argument: the location in the string at which the search is to begin. Beginning the search at location 1 makes the two functions identical. The extra argument becomes important when you need to search a single string for several occurrences of a substring.

Compare the following code fragments, which locate successive occurrences of the substring `//' within a string, first using INDEX:

   LOC = INDEX ( STRING, '//' )
 
   DO WHILE ( LOC .NE. 0 )
       .
       .
 
      IF ( LEN ( STRING )  .LE.  LOC + 2 ) THEN
         LOC = 0
      ELSE
         LOC = LOC + 2 + INDEX ( STRING(LOC+2: ), '//' )
      END IF
   END DO

   LOC = POS ( STRING, '//', 1 )
 
   DO WHILE ( LOC .NE. 0 )
       .
       .
 
      LOC = POS ( STRING, '//', LOC + 2 )
   END DO

Character searches

CPOS is different. Instead of looking for the complete target string, it looks for any one of the individual characters that make up the target string. For example,

   POS ( '(a (b c) (d e) () (f (g (h))))', '()', 1 )
                         ^

   CPOS ( '(a (b c) (d e) () (f (g (h))))', '()', 1 )
           ^

A third function, NCPOS, looks for characters that are NOT included in the collection. Thus,

   NCPOS ( '(a (b c) (d e) () (f (g (h))))', '()', 1 )
             ^

This is useful for finding unwanted characters. For example, suppose you wish to replace each character in a string that is not part of the Fortran standard character set,

   CHARACTER*(*)        LET
   PARAMETER          ( LET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' )
 
   CHARACTER*(*)        DIG
   PARAMETER          ( DIG = '0123456789' )
 
   CHARACTER*(*)        SPEC
   PARAMETER          ( SPEC = ' =+-*/(),.$'':' )

   LOC = NCPOS ( STRING, LET // DIG // SPEC, 1 )
 
   DO WHILE ( LOC .GT. 0 )
      STRING(LOC:LOC) = ' '
 
      LOC = NCPOS ( STRING, LET // DIG // SPEC, LOC )
   END DO

   NCPOS ( STR, 'ABC', BEGIN )
   NCPOS ( STR, 'ACB', BEGIN )
   NCPOS ( STR, 'BAC', BEGIN )
   NCPOS ( STR, 'BCA', BEGIN )
   NCPOS ( STR, 'CAB', BEGIN )
   NCPOS ( STR, 'CBA', BEGIN )

Searching in reverse

POS, CPOS, and NCPOS find the first occurrence of something at or after some position, searching forward (from left to right). Each of these routines has a counterpart, which searches in reverse (frome right to left). For example, where

   POS ( 'do re mi fa so la ti do', 'do', 10 )
                               ^

   POSR ( 'do re mi fa so la ti do', 'do', 10 )
           ^

Notes

Like INDEX, these functions

-- are not case-sensitive;

-- do not ignore leading or trailing spaces; and

-- indicate an unsuccessful search by returning zero.

-- If START is zero or negative, a forward search begins at 1 (since this location follows START), while a reverse search terminates immediately (since there is nothing to search before START).

-- If START is greater than the length of the string, a forward search terminates immediately (since there is nothing to search after START), while a reverse search begins at the end of the string (since this location precedes START).

Summary

The following table summarizes the scanning routines in SPICELIB.

POS Forward Substring.
CPOS Forward Character in collection.
NCPOS Forward Character NOT in collection.
POSR Reverse Substring.
CPOSR Reverse Character in collection.
NCPOSR