*DECK FFSULOC 
USETEXT TEXTFFS                      # FS  SYSTEM DEFINITIONS         # 
FUNC FFSULOC (STRING, (CHARACTER), (START$POS), (CHAR$SET))  I; 
*CALL COPYRITE
# TITLE FFSULOC - LOCATE CHARACTER.                                   # 
  
      BEGIN  # FFSULOC #
  
# 
**    FFSULOC - LOCATE CHARACTER. 
* 
*     'FFSULOC' LOCATES THE POSITION IN A STRING WHERE A CHARACTER
*     LIES. 
* 
*     FUNC FFSULOC (STRING, CHARACTER, START$POS, CHAR$SET)  I
* 
*     ENTRY (STRING)    = ARRAY CONTAINING THE STRING TERMINATED BY A 
*                         ZERO-BYTE.
*           (CHARACTER) = CHARACTER TO SEARCH FOR (TWO BYTES ARE
*                         ALLOCATED FOR THE CASE OF A 6/12 ASCII
*                         SPECIAL CHARACTER). 
*           (START$POS) = CHARACTER POSITION FROM WHICH TO START
*                         SEARCHING (STARTING FROM ZERO). 
*           (CHAR$SET) =  CHARACTER SET: STR$DIS FOR DISPLAY CODE,
*                                        STR$612 FOR 6/12 ASCII.
* 
*     EXIT  (FFSULOC)   = THE CHARACTER POSITION IN THE STRING WHERE
*                         THE CHARACTER WAS FOUND (STARTING FROM 0).
*                         -1 IS RETURNED IF NOT FOUND.
* 
*     DESCRIPTION.
* 
*     IF CHARACTER IS A SPECIAL 6/12 ASCII CHARACTER
*     THEN
*       SET SPECIAL_CHAR FLAG TO TRUE.
*     ELSE
*       SET SPECIAL_CHAR FLAG TO FALSE. 
*     SET FOUND TO FALSE. 
*     SET COUNT TO 0. 
*     SET POSITION TO ACTUAL POSITION OF START$POS. 
*     LOOP WHILE (NOT FOUND) AND
*                (NOT END OF STRING)
*     DO
*       IF ((NOT SPECIAL_CHAR) AND
*           (CURRENT CHARACTER MATCHES CHARACTER)) OR 
*          ((SPECIAL_CHAR) AND
*           (BOTH BYTES OF CURRENT CHARACTER AND CHARACTER MATCH))
*       THEN
*         SET FOUND TO TRUE.
*       ELSE
*          IF CURRENT CHARACTER IS A SPECIAL 6/12 ASCII CHARACTER 
*          THEN 
*            INCREMENT POSITION BY 2. 
*          ELSE 
*            INCREMENT POSITION BY 1. 
*          INCREMENT COUNT BY 1.
*     END LOOP
*     IF FOUND
*     THEN
*       SET FFSULOC TO START$POS + COUNT. 
*     ELSE
*       SET FFSULOC TO -1.
*     RETURN. 
# 
  
      ARRAY  STRING    [0:0] S(1);  # ARRAY CONTAINING THE STRING     # 
        BEGIN                       # TERMINATED BY A ZERO-BYTE.      # 
        ITEM  STR     C(00,00,10);
        END 
  
      ITEM   CHARACTER  C(2);       # CHARACTER TO SEARCH FOR (TWO
                                      BYTES ARE ALLOCATED FOR THE 
                                      CASE OF A 6/12 ASCII SPECIAL
                                      CHARACTER).                     # 
  
      ITEM   START$POS  U;          # CHARACTER POSITION FROM WHICH TO
                                      START SEARCHING (STARTING FROM
                                      ZERO).                          # 
  
      ITEM   CHAR$SET   U;          # CHARACTER SET:  
                                      STR$DIS FOR DISPLAY CODE
                                      STR$612 FOR 6/12 ASCII.         # 
  
      XREF
        BEGIN 
        FUNC FFSUISC B;  # IS SPECIAL CHARACTER                       # 
        FUNC FFSULAP I;  # LOCATE ACTUAL POSITION                     # 
        FUNC FFSULEN I;  # STRING LENGTH                              # 
        PROC FFSULWC;    # LOCATE WORD AND CHARACTER POSITIONS        # 
        END 
  
      ITEM COUNT     I;  # RUNNING CHARACTER COUNT                    # 
      ITEM FOUND     B;  # TRUE IF A MATCH WAS FOUND                  # 
      ITEM LENGTH    I;  # LENGTH OF INPUT STRING                     # 
      ITEM LOOP      I;  # LOOP INDEX                                 # 
      ITEM POSITION  I;  # ACTUAL CHARACTER POSITION IN STRING        # 
      ITEM REMAIN    I;  # NUMBER OF CHARACTERS REMAINING IN THE
                           STRING CURRENT WORD                        # 
      ITEM SPEC$CHAR B;  # TRUE IF CHARACTER IS A SPECIAL 6/12 CHAR   # 
      ITEM WDCHAR    I;  # CURRENT CHARACTER POSITION IN THE STRING 
                           CURRENT WORD                               # 
      ITEM WORD      I;  # CURRENT WORD OF THE STRING                 # 
                                                         CONTROL EJECT; 
# 
*     IF CHARACTER IS A SPECIAL 6/12 ASCII CHARACTER
*     THEN
*       SET SPECIAL_CHAR FLAG TO TRUE.
*     ELSE
*       SET SPECIAL_CHAR FLAG TO FALSE. 
# 
  
      IF FFSUISC (CHARACTER, 0, 0, CHAR$SET)
      THEN
        BEGIN 
        SPEC$CHAR = TRUE; 
        END  # IF # 
  
      ELSE
        BEGIN 
        SPEC$CHAR = FALSE;
        END  # ELSE # 
  
# 
*     SET FOUND TO FALSE. 
*     SET COUNT TO 0. 
# 
  
      FOUND = FALSE;
      COUNT = 0;
  
# 
*     SET POSITION TO ACTUAL POSITION OF START$POS. 
*     LOOP WHILE (NOT FOUND) AND
*                (NOT END OF STRING)
*     DO
# 
  
      LENGTH = FFSULEN (STRING, STR$DIS); 
      POSITION = FFSULAP (STRING, START$POS, CHAR$SET); 
      FFSULWC (POSITION, WORD, WDCHAR, REMAIN); 
      CONTROL SLOWLOOP; 
      FOR LOOP=LOOP 
        WHILE (NOT FOUND) AND 
              (POSITION LS LENGTH)
      DO
        BEGIN 
  
# 
*       IF ((NOT SPECIAL_CHAR) AND
*           (CURRENT CHARACTER MATCHES CHARACTER)) OR 
*          ((SPECIAL_CHAR) AND
*           (BOTH BYTES OF CURRENT CHARACTER AND CHARACTER MATCH))
*       THEN
*         SET FOUND TO TRUE.
# 
  
        IF ((NOT SPEC$CHAR) AND 
            (C<WDCHAR, 1> STR [WORD] EQ C<0, 1> CHARACTER)) OR
           ((SPEC$CHAR) AND 
            (C<WDCHAR, 2> STR [WORD] EQ C<0, 2> CHARACTER)) 
        THEN
          BEGIN 
          FOUND = TRUE; 
          END  # IF MATCH # 
  
# 
*       ELSE
*          IF CURRENT CHARACTER IS A SPECIAL 6/12 ASCII CHARACTER 
*          THEN 
*            INCREMENT POSITION BY 2. 
*          ELSE 
*            INCREMENT POSITION BY 1. 
*          INCREMENT COUNT BY 1.
# 
  
        ELSE
          BEGIN 
          IF FFSUISC (STRING, WORD, WDCHAR, CHAR$SET) 
          THEN
            BEGIN 
            POSITION = POSITION + 2;
            END  # IF # 
  
          ELSE
            BEGIN 
            POSITION = POSITION + 1;
            END  # ELSE # 
  
          FFSULWC (POSITION, WORD, WDCHAR, REMAIN); 
          COUNT = COUNT + 1;
  
          END  # IF MATCH ELSE #
  
        END  # LOOP # 
  
# 
*     IF FOUND
*     THEN
*       SET FFSULOC TO START$POS + COUNT. 
*     ELSE
*       SET FFSULOC TO -1.
# 
  
      IF FOUND
      THEN
        BEGIN 
        FFSULOC = START$POS + COUNT;
        END  # IF # 
  
      ELSE
        BEGIN 
        FFSULOC = -1; 
        END  # ELSE # 
  
# 
*     RETURN. 
# 
  
      RETURN; 
  
      END  # FFSULOC #
  
      TERM
