Changeset 3257


Ignore:
Timestamp:
Nov 15, 2018, 10:29:56 PM (6 years ago)
Author:
Andreas Schnellbacher
Message:
  • Additions for processing another than current position (to r3256).
  • Renamed procs and vars.
  • Cosmetic changes.
  • Added more useful procs.
Location:
trunk/src/netlabs/macros
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/src/netlabs/macros/assist.e

    r3256 r3257  
    7272; Included TeX extensions for the passist procedure by Petr Mikulik from his
    7373; PMCSTeX package.
    74 ; Added c_8 for german keyboards.
    75 
    76 ;
    77 ;    2006 changes: JBS
    78 ;
    79 ;    A major rework of the code
    80 ;       Bugs were fixed
    81 ;       More tokens are balanced, including the start and end points of multi-line comments
    82 ;       More modes supported (PASCAL, FORTRAN77, JAVA, WARPIN)
    83 ;       Added initial stages of support for ADA, CSS, PERL, PHP
    84 ;       Code was added to ensure tokens found within comments or literals were not matched
    85 ;       Better variable names and code documentation
    86 ;
     74
     75; 2006 changes: JBS
     76; A major rework of the code:
     77; o  Bugs were fixed.
     78; o  More tokens are balanced, including the start and end points of
     79;    multi-line comments.
     80; o  More modes supported (PASCAL, FORTRAN77, JAVA, WARPIN).
     81; o  Added initial stages of support for ADA, CSS, PERL, PHP.
     82; o  Code was added to ensure tokens found within comments or literals were
     83;    not matched.
     84; o  Better variable names and code documentation.
     85; o  Contains procs that return if a position is within a multi-line commemt,
     86;    single-line comment or literal.
     87
     88; After that:
     89; o  Commented out debug messages (minor speed improvement).
     90; o  Replaced searching in the MLC array (big speed improvement).
     91; o  Renamed procs and vars.
     92; o  Added more procs for use from outside.
     93; o  Added optional line and col parameters for querying another than
     94;    current position.
     95; o  Use the comment and literal procs now by tags and syntax expansion.
     96
     97; Ideas:
     98; o  Use attributes for marking MLCs and scan only that region that has
     99;    changed.
     100; o  Use attributes for tags and scan only that region that has changed.
    87101
    88102compile if not defined(SMALL)  -- If SMALL not defined, then being separately compiled.
    … …  
    107121
    108122const
    109    --  NOTE: The logic below relies on GOLD being defined with the left "brackets"
    110    --        in the odd positions and the right "brackets" in the even positions.
     123   --  NOTE: The logic below relies on GOLD being defined with the left
     124   --        "brackets" in the odd positions and the right "brackets" in
     125   --        the even positions.
    111126   GOLD = '(){}[]<>'  -- Parens, braces, brackets & angle brackets
    112127
    … …  
    126141                                            -- ever supports {, } and possibly other egrep metacharacters
    127142
    128    -- JBSQ: The following constants 'hard-code' the versions of NMAKE and FORTRAN77 for which
    129    --       passist works. Perhaps there is a better way that would allow this to be
    130    --       selected by the user?
     143   -- JBSQ: The following constants 'hard-code' the versions of NMAKE and
     144   --       FORTRAN77 for which passist works. Perhaps there is a better way
     145   --       that would allow this to be selected by the user?
    131146compile if not defined( USE_NMAKE32)
    132147   USE_NMAKE32       = 1   -- 0 means do not accept NMAKE32-specific directives
    … …  
    191206; nestlevel     = counter for nesting of matched tokens. On nestlevel = 0,
    192207;                 the matched token was found.
    193 ; ---------------------------------------------------------------------------
    194 
    195208defproc passist
    196209   call psave_pos( savepos)                 -- Save the cursor location
    … …  
    198211
    199212   StartLineNum = .line
    200    VerboseLevel = arg(1) -- 0 = quiet, 1 = normal
    201    fHighlight   = arg(2) -- 1 = highlighting of matching expression and scrolling
    202    MaxLines     = arg(3)
    203    MaxLoops     = arg(4)
     213   VerboseLevel = arg( 1) -- 0 = quiet, 1 = normal
     214   fHighlight   = arg( 2) -- 1 = highlighting of matching expression and scrolling
     215   MaxLines     = arg( 3)
     216   MaxLoops     = arg( 4)
    204217   if VerboseLevel <> 0 then
    205218      VerboseLevel = 1
    … …  
    214227      MaxLoops = ASSIST_DEFAULT_MAX_LOOPS
    215228   endif
    216    SearchLimitData = StartLineNum MaxLines MaxLoops  -- Use one arg for assist_search to save args
     229   SearchLimitData = StartLineNum MaxLines MaxLoops  -- Use one arg for AssistSearch to save args
    217230
    218231   case          = 'e'  -- respect case is default
    … …  
    239252
    240253   do once = 1 to 1
    241       assist_rc  = inside_comment2( CurMode, comment_data)
     254      assist_rc  = InsideComment2( CurMode, comment_data)
    242255      --#dprintf( "passist", "comment return:" assist_rc comment_data)
    243256      if assist_rc = ASSIST_RC_IN_MULTILINE_COMMENT then
    … …  
    260273      endif
    261274
    262       if inside_literal( CurMode) then
     275      if InsideLiteral( CurMode) then
    263276         assist_rc = ASSIST_RC_IN_LITERAL
    264277         leave
    … …  
    307320
    308321      -- get the word under cursor and return startcol and endcol
    309       -- stop at separators = arg(3)
    310       -- stop at double char separators = arg(4)
     322      -- stop at separators = arg( 3)
     323      -- stop at double char separators = arg( 4)
    311324      if not find_token( startcol, endcol,  seps, '/* */') then  -- JBSQ: Should /* */ be used for ALL modes?
    312325         assist_rc = ASSIST_RC_NOT_ON_A_TOKEN
    … …  
    413426                     .col = startcol
    414427                  else       -- move to end, so first Locate will hit this instance.
    415                      end_line
     428                     endline
    416429                  endif
    417430                  fIntermediate = (substr( lcword2, 2, 1) = 'l')
    … …  
    440453                     .col = length( part1) + 1
    441454                  else       -- move to end, so first Locate will hit this instance.
    442                      end_line
     455                     endline
    443456                  endif
    444457                  fIntermediate = (substr( lcword2, 2, 1) = 'l')
    … …  
    558571
    559572      -- Mode(s): C, JAVA JAVASCRIPT and RC -------------------------------------------------------
    560       elseif wordpos( Curmode, 'C JAVA RC JAVASCRIPT') > 0 then
     573      elseif wordpos( CurMode, 'C JAVA RC JAVASCRIPT') > 0 then
    561574
    562575         -- JBSQ: Was this "if" left out on purpose?
    … …  
    565578            if wordpos( id, 'if ifdef ifndef endif else elif') > 0 then -- Check for "#   if", etc.
    566579               .col = startcol
    567                if next_nonblank_noncomment_nonliteral( mode, '-R') = '#' then
     580               if NextCodeChar( Mode, .line, .col, '-R') = '#' then
    568581                  id = '#'id
    569582                  startcol = .col
    … …  
    577590
    578591         ---- Directive(s): #if #ifdef #ifndef #endif #else #elif
    579          elseif wordpos(id, '#if #ifdef #ifndef #endif #else #elif') then
     592         elseif wordpos( id, '#if #ifdef #ifndef #endif #else #elif') then
    580593            if CurMode <> 'JAVA' and CurMode <> 'JAVASCRIPT' then
    581594               search = '\#[ \t]*\c((if((n?def)?))|endif)([ \t]|$)'
    … …  
    609622               clen      = 1
    610623               nestlevel = -1   -- -1 = stop on first 'hit'
    611                assist_rc = assist_search( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
     624               assist_rc = AssistSearch( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
    612625               if assist_rc then
    613626                  assist_rc = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    … …  
    635648               clen      = 1
    636649               nestlevel = 0
    637                assist_rc = assist_search( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
     650               assist_rc = AssistSearch( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
    638651               if assist_rc then                -- no conditional??
    639652                  assist_rc = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    640653               else
    641                   nextchar = next_nonblank_noncomment_nonliteral( CurMode)
     654                  nextchar = NextCodeChar( CurMode)
    642655                  if not nextchar then
    643656                     assist_rc = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    … …  
    661674            endif
    662675/*
    663    JBSQ: The following code should work for break/continue statements within nested do and for loops
    664    which have braces.  Problems arise if there are DOs or FORs without braces between the
    665    break/continue and the enclosing loop.  Also problems arise if the enclosing loop is a
    666    while loop.
     676   JBSQ: The following code should work for break/continue statements within
     677   nested do and for loops which have braces.  Problems arise if there are
     678   DOs or FORs without braces between the break/continue and the enclosing
     679   loop.  Also problems arise if the enclosing loop is a while loop.
    667680
    668681   The solution, if it is worth it, is to code the entire search here so that these different
    … …  
    712725            else
    713726               -- This code seems to handle matching the beginning and end of
    714                --    a) functions when the cursor is on a token preceding the parameter list
     727               --    a) functions when the cursor is on a token preceding the
     728               --       parameter list
    715729               --    b) 'if' when the 'if' has following braces
    716730               --    c) 'for' when the 'for' has following braces
    … …  
    719733               --        e.g. catch (    ) { ... }
    720734
    721                -- JBSQ: Check for next_nonblank_noncomemnt_nonliteral(CurMode) = '(' first?
    722                -- (This would force the cursor to actually be on the function name.
    723                -- The current code allows the cursor on any nonblank, noncomment,
    724                -- nonliteral character preceding the parameter list.)
     735               -- JBSQ: Check for NextCodeChar( CurMode) = '(' first?
     736               -- (This would force the cursor to actually be on the function
     737               -- name. The current code allows the cursor on any nonblank,
     738               -- noncomment, nonliteral character preceding the parameter
     739               -- list.)
    725740               setsearch 'xcom l /[()]/xe+F'     -- find the ending ')' or ;
    726741               clist     = '{'
    … …  
    729744               clen      = 1
    730745               nestlevel = 0
    731                assist_rc = assist_search( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
     746               assist_rc = AssistSearch( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
    732747               --#dprintf( 'passist', 'last chance c,... srch_rc line col' assist_rc .line .col)
    733748               if not assist_rc and substr( textline( .line), .col, 1) = ')' then -- no conditional??
    734749                  assist_rc = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    735                   nextchar = next_nonblank_noncomment_nonliteral( CurMode)
     750                  nextchar = NextCodeChar( CurMode)
    736751                  if nextchar then
    737752                     --#dprintf( "passist", "Generic token () {; search found: "nextchar)
    … …  
    773788         elseif id = 'else' then
    774789            .col = startcol
    775             pchar = next_nonblank_noncomment_nonliteral( CurMode, '-R')
     790            pchar = NextCodeChar( CurMode, .line, .col, '-R')
    776791            --#dprintf( "passist", 'Previous char:' pchar)
    777792            if lowcase( pchar) = 'd' then
    … …  
    961976         case = 'c'                      -- Case insensitive for all MAKE tokens
    962977         id = lowcase( id)
    963          -- Currently ALL balanceable MAKE tokens must be on a line with '!' in column 1
    964          -- and if there are any characters between the '!' and the token they must
    965          -- be whitespace.
     978         -- Currently ALL balanceable MAKE tokens must be on a line with
     979         -- '!' in column 1 and if there are any characters between the '!'
     980         -- and the token they must be whitespace.
    966981         if leftstr( line, 1) = '!' then
    967982            if startcol > 2 then         -- Are there characters between '!' and token?
    … …  
    10101025
    10111026      -- Mode(s): Pascal --------------------------------------------------------------------------
    1012       elseif Curmode = 'PASCAL' then
     1027      elseif CurMode = 'PASCAL' then
    10131028
    10141029         case = 'c'               -- case insensitive for PASCAL
    … …  
    10441059
    10451060         elseif wordpos( id, 'while for') then
    1046             -- check for begin before ';' (i.e a block loop instead of a single statement loop)
     1061            -- Check for begin before ';' (i.e a block loop instead of a
     1062            -- single statement loop)
    10471063            setsearch 'xcom l /[ \t]\cdo([ \t]|$)/x'case'c+F'  -- find the end of following 'do'
    10481064            clist     = 'd'
    … …  
    10501066            clen      = 1
    10511067            nestlevel = -1   -- -1 = stop on first 'hit'
    1052             assist_rc = assist_search( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
     1068            assist_rc = AssistSearch( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData)
    10531069            do once2 = 1 to 1
    10541070               if assist_rc then                -- no 'do'??
    … …  
    10571073               endif
    10581074               .col = .col + 2
    1059                nextchar = next_nonblank_noncomment_nonliteral( CurMode)
     1075               nextchar = NextCodeChar( CurMode)
    10601076               if not nextchar then
    10611077                  assist_rc = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    … …  
    10981114
    10991115      -- Mode(s): TEX -----------------------------------------------------------------------------
    1100       elseif Curmode = 'TEX' then
     1116      elseif CurMode = 'TEX' then
    11011117
    11021118      -- begin addition for TeX
    1103       -- NOTE: There is some special code for \begin and \end which depends on 'clist'
    1104       --       being set to 'be' or 'en'. If it becomes necessary to use these values
    1105       --       for 'clist' for other TEX tokens, then the special code for \begin and
    1106       --       end will break.
     1119      -- NOTE: There is some special code for \begin and \end which depends
     1120      --       on 'clist' being set to 'be' or 'en'. If it becomes necessary
     1121      --       to use these values for 'clist' for other TEX tokens, then the
     1122      --       special code for \begin and \end will break.
    11071123         coffset = 1                -- most TEX tokens use this offset
    11081124      -- //PM additions: balanceable tokens for (La)TeX
    … …  
    11251141            ---- LaTeX environment: \begin{...}, \end{...}
    11261142            .col = endcol
    1127             if next_nonblank_noncomment_nonliteral( CurMode) == '{' then
     1143            if NextCodeChar( CurMode) == '{' then
    11281144               --#dprintf( 'passist', 'TEX: found } at '.line .col)
    11291145               temp = substr( textline( .line), .col)
    … …  
    12111227      elseif (CurMode = 'FORTRAN77') then
    12121228
    1213          -- This code disregards the "token" and allows the cursor anywhere within
    1214          -- columns 7 ... 72
     1229         -- This code disregards the "token" and allows the cursor anywhere
     1230         -- within columns 7 ... 72
    12151231         if .col > 6 and .col < 73 then
    1216             statement = fortran77_extract_text( .line)
     1232            statement = Fortran77ExtractText( .line)
    12171233            do i = .line + 1 to .last
    12181234               temp = textline( i)
    … …  
    12201236                  leave
    12211237               elseif not pos( leftstr( temp, 1), 'C*') then
    1222                   statement = statement''fortran77_extract_text( i)
     1238                  statement = statement''Fortran77ExtractText( i)
    12231239               endif
    12241240            enddo
    1225             statement = fortran77_remove_spaces( statement)
     1241            statement = Fortran77RemoveSpaces( statement)
    12261242
    12271243            if leftstr( statement, 2) = 'DO' then
    … …  
    12521268                     --#dprintf( 'passist', 'F77 search rc: 'rc)
    12531269compile if 0
    1254 --DO/ENDDO is not FORTRAN77 but the code (esp. the regex search string) for future use
     1270                  -- DO/ENDDO is not FORTRAN77 but the code (esp. the regex
     1271                  -- search string) for future use
    12551272                  else            -- DO var = xx,limit      loop
    12561273                     search = '^[ 0-9][ 0-9][ 0-9][ 0-9][ 0-9].[ ]*\c((D[ ]*O[ ]*[A-Z][A-Z0-9]*[ ]*=.+,)|(E[ ]*N[ ]*D[ ]*D[ ]*O))'
    … …  
    12651282
    12661283compile if 0
    1267 --DO/ENDDO is not FORTRAN77 but the code (esp. the regex search string) for future use
     1284            -- DO/ENDDO is not FORTRAN77 but the code (esp. the regex search
     1285            -- string) for future use
    12681286            elseif statement = 'ENDDO' then
    12691287               search = '^[ 0-9][ 0-9][ 0-9][ 0-9][ 0-9].[ ]*\c((D[ ]*O[ ]*[A-Z][A-Z0-9]*[ ]*=.+,)|(E[ ]*N[ ]*D[ ]*D[ ]*O))'
    … …  
    12741292
    12751293compile if 0
    1276 ; - FORTRAN77 support (beyond the generic ()[]{} matching and do <label> ...) is disabled.
    1277 ; - The code below tries to match "Block" IFs (i.e. IF(<condiiton>)THEN ... ENDIF)
    1278 ; - But FORTRAN allows statements to be contiued. This means that for "IF (confition) THEN"
    1279 ; the IF and the THEN might be on different lines.
    1280 ; - For long conditions the use of continuations can make stylistic sense. For example:
    1281 ;           IF( CARDS(I)(2:2) .EQ. 'J'
    1282 ;      1   .OR. CARDS(I)(2:2) .EQ. 'Q'
    1283 ;      2   .OR. CARDS(I)(2:2) .EQ. 'K' )THEN
    1284 ; - Unless grep searches start supporting searches across multiple lines, the only way to
    1285 ; implement matching with this kind of code is
    1286 ; 1) Create a temporary file
    1287 ; 2) Rewrite the original file in to the temp file, "merging" the continuation lines in the process
    1288 ; 3) Somehow keep track of which columns of the merged lines came from which lines and columns of the original file
    1289 ; 4) Perform a search on the temp file
    1290 ; 5) Use the data from #3 to map the location of the "found" string back into the original file
    1291 ; 6) Discard the temp file
    1292 ; - At this time the effort need to make this work was deemed not worth the "value" of matching
    1293 ; "Block" IFs in FORTRAN.
     1294            -- o  FORTRAN77 support (beyond the generic ()[]{}-matching and
     1295            --    do <label> ...) is disabled.
     1296            -- o  The code below tries to match "Block" IFs (i.e.
     1297            --    IF(<condiiton>)THEN ... ENDIF)
     1298            -- o  But FORTRAN allows statements to be contiued. This means
     1299            --    that for "IF (confition) THEN" the IF and the THEN might
     1300            --    be on different lines.
     1301            -- o  For long conditions, the use of continuations can make
     1302            --    stylistic sense. For example:
     1303            --         IF( CARDS(I)(2:2) .EQ. 'J'
     1304            --    1   .OR. CARDS(I)(2:2) .EQ. 'Q'
     1305            --    2   .OR. CARDS(I)(2:2) .EQ. 'K' )THEN
     1306            -- o  Unless grep searches start supporting searches across
     1307            --    multiple lines, the only way to implement matching with
     1308            --    this kind of code is
     1309            --    1) Create a temporary file
     1310            --    2) Rewrite the original file in to the temp file, "merging"
     1311            --       the continuation lines in the process
     1312            --    3) Somehow keep track of which columns of the merged lines
     1313            --       came from which lines and columns of the original file
     1314            --    4) Perform a search on the temp file
     1315            --    5) Use the data from #3 to map the location of the "found"
     1316            --       string back into the original file
     1317            --    6) Discard the temp file
     1318            -- o  At this time the effort need to make this work was deemed
     1319            --    not worth the "value" of matching
     1320
     1321            -- "Block" IFs in FORTRAN.
    12941322            elseif leftstr( statement, 3) = 'IF(' then
    12951323               if pos( ')THEN', statement) then       -- Assume ')THEN' is NOT in a literal?
    … …  
    13211349
    13221350compile if 0
    1323 ; FORTRAN77 does not require END of program/subroutine/function statements, nor is a PROGRAM statement require
     1351            -- FORTRAN77 does not require END of program/subroutine/function
     1352            -- statements, nor is a PROGRAM statement require
    13241353            elseif not pos( '=', statement) then  -- remaining matchable tokens require this
    13251354               function_pos = pos( 'FUNCTION', statement)
    … …  
    14081437      -- o  checks for too many processed lines and
    14091438      -- o  does additional search for the modes E and TEX.
    1410       assist_rc = assist_search( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData, tex_env, ECompileFlag)
     1439      assist_rc = AssistSearch( CurMode, clist, case, coffset, clen, nestlevel, SearchLimitData, tex_env, ECompileFlag)
    14111440   endif                                 -- if OK to search
    14121441
    … …  
    14481477         call ScrollAfterLocate( savepos, lpos, ScrollToTopBot, '-4 -4')
    14491478
    1450          -- At this time, GetPmInfo( EPMINFO_SEARCHPOS) has the value 0, not the col
    1451          -- after the last search. Additionally, the second search was executed, so
    1452          -- the position data of the first search has changed. Therefore submit the
    1453          -- data from after the starting seach to CircleIt as arg:
     1479         -- At this time, GetPmInfo( EPMINFO_SEARCHPOS) has the value 0, not
     1480         -- the col after the last search. Additionally, the second search
     1481         -- was executed, so the position data of the first search has
     1482         -- changed. Therefore submit the data from after the starting seach
     1483         -- to CircleIt as arg:
    14541484         call highlight_match( HighlightLine HighlightCol HighlightLen)
    14551485      endif
    … …  
    14661496
    14671497; ---------------------------------------------------------------------------
    1468 ;  assist_search: perform the actual search for the matching token (which is
    1469 ;     NOT located within a comment or literal).
    1470 ; ---------------------------------------------------------------------------
    1471 defproc assist_search( mode, clist, case, coffset, clen, nestlevel, SearchLimitData)
     1498; Performs the actual search for the matching token (which is NOT located
     1499; within a comment or literal).
     1500defproc AssistSearch( Mode, clist, case, coffset, clen, nestlevel, SearchLimitData)
    14721501   parse value SearchLimitData with StartLineNum MaxLines MaxLoops
    1473    tex_env      = arg(8)
    1474    ECompileFlag = arg(9)
     1502   tex_env      = arg( 8)
     1503   ECompileFlag = arg( 9)
    14751504   retval = 0
    14761505   getsearch ThisSearch
    … …  
    14891518      if lrc then
    14901519         retval = ASSIST_RC_NOT_ON_A_BALANCEABLE_TOKEN
    1491          --#dprintf( 'passist', 'assist_search: rc = 'lrc)
     1520         --#dprintf( 'passist', 'AssistSearch: rc = 'lrc)
    14921521         leave
    14931522      endif
    14941523
    14951524      --#dprintf( "passist", "Match at ".line",".col)
    1496       if inside_comment( mode) then
    1497          --#dprintf( 'passist', 'inside_comment')
     1525      if InsideComment( Mode) then
     1526         --#dprintf( 'passist', 'InsideComment')
    14981527         iterate
    14991528      endif
    1500       if inside_literal( mode) then
    1501          --#dprintf( 'passist', 'inside_literal')
     1529      if InsideLiteral( Mode) then
     1530         --#dprintf( 'passist', 'InsideLiteral')
    15021531         iterate
    15031532      endif
    15041533
    1505       if mode = 'E' & ECompileFlag <> 1 then
     1534      if Mode = 'E' & ECompileFlag <> 1 then
    15061535         -- if|endif (without compile)
    15071536         line     = textline( .line)
    … …  
    15521581   enddo
    15531582
    1554    if retval = 0 and mode == 'TEX' and (clist = 'be' or clist = 'en') then
     1583   if retval = 0 and Mode == 'TEX' and (clist = 'be' or clist = 'en') then
    15551584      call psave_pos( texsavepos)
    15561585      if clist = 'be' then
    … …  
    15591588         .col = .col + 5
    15601589      endif
    1561       nextchar = next_nonblank_noncomment_nonliteral( mode)
     1590      nextchar = NextCodeChar( Mode)
    15621591      --#dprintf( "passist", "TEX env: "tex_env" NextChar: "nextchar)
    15631592      if tex_env <> '' then
    … …  
    15821611
    15831612; ---------------------------------------------------------------------------
    1584 ;  inside_nocomment_literal: determine if the cursor is within a literal.
    1585 ;     This routine first determines if the cursor is within a comment (since
    1586 ;     literals within comments are not "real" literals).
    1587 ;     Return values:
    1588 ;        0:     the cursor is NOT within a literal.
    1589 ;        other: the cursor IS within a literal.
    1590 ; ---------------------------------------------------------------------------
    1591 defproc inside_nocomment_literal( mode)
     1613; Determines if the cursor is within a literal.
     1614; This routine first determines if the cursor is within a comment (since
     1615; literals within comments are not "real" literals).
     1616; Return values:
     1617;    0:     the cursor is NOT within a literal (may be within a comment).
     1618;    other: the cursor IS within a literal.
     1619defproc InsideNonCommentLiteral( Mode)
    15921620   CurLine = arg( 2)
    15931621   if CurLine = '' then
    … …  
    15991627   endif
    16001628   do once = 1 to 1
    1601       rc = inside_comment( mode, CurLine, CurCol)
     1629      rc = InsideComment( Mode, CurLine, CurCol)
    16021630      if rc = 0 then
    16031631         leave
    16041632      endif
    1605       rc = inside_literal( mode, CurLine, CurCol)
     1633      rc = InsideLiteral( Mode, CurLine, CurCol)
    16061634   enddo
    16071635   return rc
    16081636
    16091637; ---------------------------------------------------------------------------
    1610 ;  inside_comment_literal: determine if the cursor is within a comment or
    1611 ;     within a literal.
    1612 ;     Return values:
    1613 ;        0:     the cursor is NOT within a comment NOR within a literal.
    1614 ;        other: the cursor IS within a comment or within a literal.
    1615 ; ---------------------------------------------------------------------------
    1616 defproc inside_comment_literal( mode)
     1638; Determines if the cursor is within a comment or within a literal.
     1639; Return values:
     1640;    0:     the cursor is NOT within a comment NOR within a literal.
     1641;    other: the cursor IS within a comment or within a literal.
     1642defproc InsideCommentLiteral( Mode)
    16171643   CurLine = arg( 2)
    16181644   if CurLine = '' then
    … …  
    16241650   endif
    16251651   do once = 1 to 1
    1626       rc = inside_comment( mode, CurLine, CurCol)
     1652      rc = InsideComment( Mode, CurLine, CurCol)
    16271653      if rc <> 0 then
    16281654         leave
    16291655      endif
    1630       rc = inside_literal( mode, CurLine, CurCol)
     1656      rc = InsideLiteral( Mode, CurLine, CurCol)
    16311657   enddo
    16321658   return rc
    16331659
    16341660; ---------------------------------------------------------------------------
    1635 ;  inside_literal: determine if the cursor is within a literal. Unlike
    1636 ;     inside_comment_literal, this routine does not first determine if the cursor
    1637 ;     is within a comment. This is called by inside_comment_literal and can be
    1638 ;     called directly if the test for the presence of a comment is unneeded.
    1639 ;     Return values:
    1640 ;        0:     the cursor is NOT within a literal.
    1641 ;        other: the cursor IS within a literal.
    1642 ; ---------------------------------------------------------------------------
    1643 defproc inside_literal( mode)
     1661; Determines if the cursor is within a literal. Unlike InsideCommentLiteral,
     1662; this routine does not first determine if the cursor is within a comment.
     1663; This is called by InsideCommentLiteral and can be
     1664; called directly if the test for the presence of a comment is unneeded.
     1665; Return values:
     1666;    0:     the cursor is NOT within a literal.
     1667;    other: the cursor IS within a literal.
     1668defproc InsideLiteral( Mode)
    16441669   CurLine = arg( 2)
    16451670   if CurLine = '' then
    … …  
    16501675      CurCol = .col
    16511676   endif
    1652    --#dprintf( "lit2", "Entry: ".line .col)
     1677   --#dprintf( "lit2", "Entry: "CurLine CurCol)
    16531678   call psave_pos( savepos2)
    16541679   getsearch search_command2  -- Save caller's search command.
    1655    line = textline( .line )
     1680   line = textline( CurLine )
    16561681   retval = 0
    16571682   fexit  = 0
    1658    parse value GetLitChars( mode) with StartLitChars EndLitChars EscapeChars
     1683   parse value GetLitChars( Mode) with StartLitChars EndLitChars EscapeChars
    16591684   if StartLitChars then
    16601685      endpos = 0
    … …  
    16621687      do forever
    16631688         startpos = verify( line, StartLitChars, 'M', endpos + 1)  -- find first start-of-literal
    1664          --#dprintf( "lit2", "startpos curcol line: "startpos curcol line)
     1689         --#dprintf( "lit2", "startpos CurCol line: "startpos CurCol line)
    16651690         if not startpos then                                      -- if none, exit
    16661691            leave
    1667          elseif startpos >= curcol then                            -- if past cursor position, exit
     1692         elseif startpos >= CurCol then                            -- if past cursor position, exit
    16681693            leave
    16691694         endif
    … …  
    16771702            endpos  = verify( line, endq''escapechar, 'M', endpos + 1)  -- find next end-of-literal or escape char
    16781703            --#dprintf( "lit2", "startq startpos endq endpos escapechar: "startq startpos endq endpos escapechar)
    1679             if endpos >= curcol then         -- JBSQ: Don't care if literal is properly closed?
     1704            if endpos >= CurCol then         -- JBSQ: Don't care if literal is properly closed?
    16801705               retval = 1
    16811706               leave
    16821707            elseif not endpos then           -- No end "quote"??
    1683                --#dprintf( "lit2", "Unmatched start-of-literal character: "startq "at "curline","startpos)
     1708               --#dprintf( "lit2", "Unmatched start-of-literal character: "startq "at "CurLine","startpos)
    16841709               --retval = 1                    -- JBSQ: Return true on unmatched "quote"?
    16851710               -- Better don't count the rest of the line as literal and leave retval = 0.
    … …  
    16921717                     --#dprintf( "lit2", "Doubled-quote")
    16931718                     iterate
    1694                   else                       -- not escaped and endpos < curcol
     1719                  else                       -- not escaped and endpos < CurCol
    16951720                     leave                   --     literal starts and ends before cursor col
    16961721                  endif
    … …  
    17041729               --#dprintf( "lit2", "Escaped char")
    17051730               iterate
    1706             else  -- endpos > 0 and endpos < curcol, i.e. literal starts and ends before curcol
     1731            else  -- endpos > 0 and endpos < CurCol, i.e. literal starts and ends before CurCol
    17071732               leave
    17081733            endif
    … …  
    17211746
    17221747; ---------------------------------------------------------------------------
    1723 ;  GetLitChars: a routine which, given a mode, returns the start-of-literal,
    1724 ;     end-of-literal and escape characters for that mode. The return value
    1725 ;     is three "words". Each character of the first "word" is a start-of-literal
    1726 ;     character. The corresponding character in the second "word" is the
    1727 ;     corresponding end-of-literal character. The third "word is a list of the
    1728 ;     escape characters, if any, which allow a literal to include a start-of-literal,
    1729 ;     end-of-literal or itself in a literal.
    1730 ; ---------------------------------------------------------------------------
    1731 defproc GetLitChars( mode)
     1748; A routine which, given a mode, returns the start-of-literal, end-of-literal
     1749; and escape characters for that mode.
     1750; The return value is three "words":
     1751; o  Each character of the first "word" is a start-of-literal character.
     1752; o  The corresponding character in the second "word" is the corresponding
     1753;    end-of-literal character.
     1754; o  The third "word" is a list of the escape characters, if any, which
     1755;    allow a literal to include a start-of-literal, end-of-literal or itself
     1756;    in a literal.
     1757defproc GetLitChars( Mode)
    17321758   SingleQuote = "'"
    17331759   DoubleQuote = '"'
    … …  
    17371763   if 0 then
    17381764      -- placeholder
    1739    elseif mode = 'E' then
     1765   elseif Mode = 'E' then
    17401766      EscapeChars = StartLitChars
    1741    elseif mode = 'REXX' then
     1767   elseif Mode = 'REXX' then
    17421768      EscapeChars = StartLitChars
    1743    elseif mode = 'MAKE' or mode = 'RC' or mode = 'WARPIN' then
     1769   elseif Mode = 'MAKE' or Mode = 'RC' or Mode = 'WARPIN' then
    17441770      StartLitChars = DoubleQuote
    17451771      EndLitChars   = StartLitChars
    1746       if mode = 'RC'then
     1772      if Mode = 'RC'then
    17471773         EscapeChars = '\'
    17481774      else
    17491775         EscapeChars   = \0                 -- JBSQ: No escape chars for MAKE?
    17501776      endif
    1751    elseif mode = 'PERL' then
     1777   elseif Mode = 'PERL' then
    17521778      StartLitChars = StartLitChars'`'
    17531779      EndLitChars   = StartLitChars
    17541780      EscapeChars   = '\\\'
    1755 ;    elseif mode = 'ADA' then               -- JBSQ: ADA strings and chars are default: (" " and ' ')?
     1781;    elseif Mode = 'ADA' then               -- JBSQ: ADA strings and chars are default: (" " and ' ')?
    17561782;       StartLitChars = DoubleQuote'%'
    17571783;       EndLitChars   = StartLitChars
    17581784;       EscapeChars   = \0\0                -- JBSQ: Escape Chars?
    1759    elseif wordpos( mode, 'DEF PASCAL FORTRAN77') > 0 then
     1785   elseif wordpos( Mode, 'DEF PASCAL FORTRAN77') > 0 then
    17601786      StartLitChars = SingleQuote
    17611787      EndLitChars   = SingleQuote
    1762       if mode = 'DEF' then
     1788      if Mode = 'DEF' then
    17631789         EscapeChars   = \0
    17641790      else
    … …  
    17701796
    17711797; ---------------------------------------------------------------------------
    1772 ;  InsideComment: a front-end call to InsideComment2. This is used when the
    1773 ;     location of the comment, returned by inside_comment2, is not needed.
    1774 ; ---------------------------------------------------------------------------
    1775 defproc inside_comment( mode)
     1798; A front-end call to InsideComment2. This is used when the location of the
     1799; comment, returned by InsideComment2, is not needed.
     1800defproc InsideComment( Mode)
    17761801   CurLine = arg( 2)
    17771802   if CurLine = '' then
    … …  
    17821807      CurCol = .col
    17831808   endif
    1784    return inside_comment2( mode, dummy, CurLine, CurCol)
     1809   return InsideComment2( Mode, dummy, CurLine, CurCol)
    17851810
    17861811; ---------------------------------------------------------------------------
    1787 ;  InsideComment2: determines if the cursor is located within a comment,
    1788 ;     multi-line or single-line. The input is the mode and a "var" variable
    1789 ;     (named "comment_data") in which the location of the comment is returned
    1790 ;     to the caller.
    1791 ;
    1792 ;     return value 0 => cursor is NOT within a comment
    1793 ;        and comment_data is meaningless
    1794 ;     return value 1 => cursor IS within a one-line comment
    1795 ;        and comment_data is set to the column of the start of one-line comment
    1796 ;     return value 2 => cursor IS within a multi-line comment
    1797 ;        and comment_data is set to 6 blank-separated words:
    1798 ;           The line, col and length of the starting MLC token and
    1799 ;           the line, col and length of the ending MLC token.
     1812; A front-end call to LocateMLC. This is used when the location of the
     1813; comment, returned by LocateMLC, is not needed.
     1814defproc InsideMLC( Mode)
     1815   CurLine = arg( 2)
     1816   if CurLine = '' then
     1817      CurLine = .line
     1818   endif
     1819   CurCol = arg( 3)
     1820   if CurCol = '' then
     1821      CurCol = .col
     1822   endif
     1823   retval = 0
     1824   MLCData = LocateMLC( Mode, CurLine, CurCol)
     1825   parse value MLCData with BestMLCStartLine BestMLCStartCol BestMLCStartLen BestMLCEndLine BestMLCEndCol BestMLCEndLen
     1826   if BestMLCStartLine > 0 then
     1827      retval = 1
     1828   endif
     1829   return retval
     1830
    18001831; ---------------------------------------------------------------------------
    1801 defproc inside_comment2( mode, var comment_data)
     1832; Determines if the cursor is located within a comment, multi-line or
     1833; single-line. The input is the mode and a "var" variable
     1834; (named "comment_data") in which the location of the comment is returned
     1835; to the caller.
     1836; Return value:
     1837;    0: cursor is NOT within a comment
     1838;       and comment_data is meaningless
     1839;    1: cursor IS within a one-line comment
     1840;       and comment_data is set to the column of the start of one-line
     1841;       comment
     1842;    2: cursor IS within a multi-line comment
     1843;       and comment_data is set to 6 blank-separated words:
     1844;       o  The line, col and length of the starting MLC token and
     1845;       o  the line, col and length of the ending MLC token.
     1846defproc InsideComment2( Mode, var comment_data)
    18021847   CurLine = arg( 3)
    18031848   if CurLine = '' then
    … …  
    18141859   retval = 0
    18151860   comment_data = ""
    1816    line = textline( curline)
    1817    if QueryModeKey( mode, 'CaseSensitive', '1') then
     1861   line = textline( CurLine)
     1862   if QueryModeKey( Mode, 'CaseSensitive', '1') then
    18181863      MLCCase = 'e'  -- case-sensitive (exact)
    18191864   else
    18201865      MLCCase = 'c'  -- caseless
    18211866   endif
    1822    MLCData =  locateMLC( mode, curline, curcol)
     1867   MLCData = LocateMLC( Mode, CurLine, CurCol)
    18231868   parse value MLCData with BestMLCStartLine BestMLCStartCol BestMLCStartLen BestMLCEndLine BestMLCEndCol BestMLCEndLen
    18241869   if BestMLCStartLine > 0 then
    … …  
    18271872   --#dprintf( "comm", "Retval on exit of outer MLC loop: "retval", cursor: ".line",".col)
    18281873   if retval = 0 then
    1829       SLCPosition = inside_oneline_comment( mode)
     1874      SLCPosition = InsideSLC( Mode, CurLine, CurCol)
    18301875      comment_data = SLCPosition
    18311876      retval = (SLCPosition > 0)
    … …  
    18401885
    18411886; ---------------------------------------------------------------------------
    1842 ; Determine if provided location (line, col) is within a multi-line comment
     1887; Determines if provided location (line, col) is within a multi-line comment
    18431888; (MLC) for the provided mode. The return value is six space-separated
    18441889; numbers representing:
    … …  
    18611906; just a part of a file. Also the amount of events that cause a rebuild of
    18621907; the array could be reduced.
    1863 defproc locateMLC( mode, line, col)
    1864    --dprintf( 'locateMLC( 'mode', 'line', 'col')')
     1908defproc LocateMLC( Mode, line, col)
     1909   --dprintf( 'LocateMLC( 'Mode', 'line', 'col')')
    18651910   -- Build MLC array, return number of different MLC pairs (1 for C: /* ... */)
    1866    ModeMLCCount = buildMLCArray( mode)
    1867    --#dprintf( "array", "locateMLC mode: "mode line","col "ModeMLCCount: "ModeMLCCount)
     1911   ModeMLCCount = buildMLCArray( Mode)
     1912   --#dprintf( "array", "LocateMLC Mode: "Mode line","col "ModeMLCCount: "ModeMLCCount)
    18681913   getfileid fid
    18691914   listindexbase = fid'.assist.'
    … …  
    18831928         MLCListCount = 0
    18841929      endif
    1885       modeindexbase = 'assist.mode.'mode'.'
     1930      modeindexbase = 'assist.mode.'Mode'.'
    18861931      MLCNest  = GetAVar( modeindexbase''i'.MLCNest' )
    18871932
    … …  
    20112056
    20122057; ---------------------------------------------------------------------------
    2013 ;  buildMLCArray: Build an array containing the start and end points of all multi-line
    2014 ;     comments in the current file.
    2015 ; ---------------------------------------------------------------------------
    2016 defproc buildMLCArray( mode)
     2058; Builds an array containing the start and end points of all multi-line
     2059; comments in the current file.
     2060defproc buildMLCArray( Mode)
    20172061   getfileid fid
    2018    if QueryModeKey( mode, 'CaseSensitive', '1') then
     2062   if QueryModeKey( Mode, 'CaseSensitive', '1') then
    20192063      MLCCase = 'e'  -- case-sensitive (exact)
    20202064   else
    20212065      MLCCase = 'c'  -- caseless
    20222066   endif
    2023    modeindexbase = 'assist.mode.'mode'.'
     2067   modeindexbase = 'assist.mode.'Mode'.'
    20242068   listindexbase = fid'.assist.'
    20252069   ModeMLCCount = GetAVar( modeindexbase'0')
    20262070
    20272071   if ModeMLCCount = '' then
    2028       call GetMLCChars( mode, MLCStartChars, MLCEndChars, MLCNestList)
     2072      call GetMLCChars( Mode, MLCStartChars, MLCEndChars, MLCNestList)
    20292073      ModeMLCCount = words( MLCStartChars)
    20302074      call SetAVar( modeindexbase'0', ModeMLCCount)
    … …  
    20362080   endif
    20372081
    2038    --#dprintf( "array", "Build mode: "mode "MLCCount: "ModeMLCCount)
     2082   --#dprintf( "array", "Build mode: "Mode "MLCCount: "ModeMLCCount)
    20392083   do once = 1 to 1
    20402084
    … …  
    20592103
    20602104      call psave_pos( savepos)
    2061       curline     = .line
    2062       curcol      = .col
    20632105      found_count = 0
    20642106      do i = 1 to ModeMLCCount
    … …  
    20672109         MLCNest  = GetAVar( modeindexbase''i'.MLCNest' )
    20682110         --#dprintf( "array", "MLC data: "MLCStart MLCEnd MLCNest)
    2069          MLCStartSearch = escape_search_chars( MLCStart)
    2070          MLCEndSearch   = escape_search_chars( MLCEnd)
     2111         MLCStartSearch = EscapeSearchChars( MLCStart)
     2112         MLCEndSearch   = EscapeSearchChars( MLCEnd)
    20712113         --#dprintf( "array", ""MLCStart "search = "MLCStartSearch)
    20722114         --#dprintf( "array", ""MLCEnd "search = "MLCEndSearch)
    2073          MLCStartLine = curline
    2074          MLCStartCol  = curcol   + 1
    20752115         MLCStartLen  = length( MLCStart)
    2076          MLCEndLine   = curline
    2077          MLCEndCol    = curcol
    20782116         MLCEndLen    = length( MLCEnd)
    20792117         .line        = 1
    … …  
    21032141            endif
    21042142
    2105             if inside_oneline_comment( mode) then
     2143            if InsideSLC( Mode) then
    21062144               right
    21072145               iterate
    21082146            endif
    2109             if inside_literal( mode) then
     2147            if InsideLiteral( Mode) then
    21102148               right
    21112149               iterate
    … …  
    21312169
    21322170               --#dprintf( "comm", "MLCEnd, postsearch loc: ".line",".col)
    2133                SLCPosition = inside_oneline_comment( mode, 1)
     2171               SLCPosition = InsideSLC( Mode, .line, .col, 1)
    21342172               if SLCPosition then
    21352173                  right
    … …  
    21382176
    21392177               -- JBSQ: MLCs "in-progress" can't be in literals?
    2140                -- if inside_literal( mode) then
     2178               -- if InsideLiteral( Mode) then
    21412179               --    iterate
    21422180               -- endif
    … …  
    21772215
    21782216; ---------------------------------------------------------------------------
    2179 ;  GetMLCChars: Return the tokens which start and end multi-line comments
    2180 ;     for the given mode. Also returned is whether the MLC can be nested
    2181 ;     within another MLC. These values are returned through three "var"
    2182 ;     parameters. Each "word" of each these parameters represents the
    2183 ;     start token, the end token and a flag indicating if theat MLC can
    2184 ;     be nested within another.
     2217; Returns the tokens which start and end multi-line comments
     2218; for the given mode. Also returned is whether the MLC can be nested
     2219; within another MLC. These values are returned through three "var"
     2220; parameters. Each "word" of each these parameters represents the
     2221; start token, the end token and a flag indicating if theat MLC can
     2222; be nested within another.
     2223defproc GetMLCChars( Mode, var MLCStartChars, var MLCEndChars, var MLCNestFLags)
     2224   MLCStartChars = QueryModeKey( Mode, 'MultiLineCommentStart')
     2225   if MLCStartChars <> '' then
     2226      MLCEndChars = QueryModeKey( Mode, 'MultiLineCommentEnd')
     2227      MLCNestFlags = QueryModeKey( Mode, 'MultiLineCommentNested', '0')
     2228   endif
     2229   return
     2230
    21852231; ---------------------------------------------------------------------------
    2186 defproc GetMLCChars( mode, var MLCStartChars, var MLCEndChars, var MLCNestFLags)
    2187    MLCStartChars = QueryModeKey( mode, 'MultiLineCommentStart')
    2188    if MLCStartChars <> '' then
    2189       MLCEndChars = QueryModeKey( mode, 'MultiLineCommentEnd')
    2190       MLCNestFlags = QueryModeKey( mode, 'MultiLineCommentNested', '0')
    2191    endif
    2192    return
    2193 
    2194 ; ---------------------------------------------------------------------------
    2195 ;  escape_search_chars: this routine takes a "search-for-this" search string
    2196 ;     and it inserts escape characters in front of any extended grep
    2197 ;     metacharacters. For example if the search string is "(abc)" (i.e.
    2198 ;     find "(abc)" the this routine returns "\(abc\)" because "(" and ")"
    2199 ;     are extended grep metacharacters and so they must be "escaped" with "\"
    2200 ; ---------------------------------------------------------------------------
    2201 defproc escape_search_chars( search_string)
     2232; This routine takes a "search-for-this" search string and it inserts escape
     2233; characters in front of any extended grep metacharacters.
     2234; For example, if the search string is "(abc)" (i.e. find "(abc)"), this
     2235; routine returns "\(abc\)" because "(" and ")" are extended grep
     2236; metacharacters and so they must be "escaped" with "\".
     2237defproc EscapeSearchChars( search_string)
    22022238   p = -1
    22032239   do forever
    … …  
    22122248
    22132249; ---------------------------------------------------------------------------
    2214 ;  inside_oneline_comment: determines if the cursor is located within a
    2215 ;     single line comment. Returns the column of the start of the comment.
    2216 ;     A value of 0 is returned if no one-line comment is found. An optional
    2217 ;     second parameter is used to indicate that a MLC is "in-progress".
    2218 ; ---------------------------------------------------------------------------
    2219 defproc inside_oneline_comment( mode)
     2250; Determines if the cursor is located within a single-line comment.
     2251; Returns the column of the start of the comment. A value of 0 is returned,
     2252; if no one-line comment is found.
     2253; An optional fourth parameter is used to indicate that a MLC is
     2254; "in-progress".
     2255defproc InsideSLC( Mode)
    22202256   CurLine = arg( 2)
    22212257   if CurLine = '' then
    … …  
    22262262      CurCol = .col
    22272263   endif
     2264   MLCInProgress = arg( 4)
     2265   if MLCInProgress = '' then
     2266      MLCInProgress = 0
     2267   endif
     2268
     2269   --#dprintf( "1line", "Entry: "CurLine CurCol "mode = "Mode)
    22282270   line = textline( CurLine)
    2229    --#dprintf( "1line", "Entry: "CurLine CurCol "Mode = "mode)
    2230    if arg(2) == '' then
    2231       MLCInProgress = 0
    2232    else
    2233       MLCInProgress = arg(2)
    2234    endif
    22352271   retval = 0
    2236    indexbase = 'assist.mode.'mode'.'
     2272   indexbase = 'assist.mode.'Mode'.'
    22372273
    22382274   SLCCount = GetAVar( indexbase'SLC.0')
    22392275   if SLCCount = '' then
    2240       call GetSLCChars( mode, SLCCharList, SLCPosList, SLCNeedList, SLCOverrideMLCList)
     2276      call GetSLCChars( Mode, SLCCharList, SLCPosList, SLCNeedList, SLCOverrideMLCList)
    22412277      SLCCount = words( SLCCharList)
    22422278      --#dprintf( "1line", "SLCCount: "SLCCount)
    … …  
    22972333            endif
    22982334            CurCol = p
    2299             if not inside_literal( mode) then
     2335            if not InsideLiteral( Mode) then
    23002336               leave
    23012337            endif
    … …  
    23352371
    23362372; ---------------------------------------------------------------------------
    2337 ;  GetSLCChars: Returns the single-line comment data for the given mode
    2338 ;     For each possible SLC the following is returned:
    2339 ;        The token which initiates the SLC (SLCCharlist)
    2340 ;        A flag indicating any positional requirements (SLCPosList)
    2341 ;           0: SLC can start anywhere on a line
    2342 ;           1: SLC MUST start in column 1
    2343 ;           F: SLC must be the first non-blank on the line
    2344 ;           <negative_number> : SLC must NOT start in this column (-6 mean SLC must NOT
    2345 ;              start in column 6)
    2346 ;        A flag indicating if the token must be followed by a blank (SLCNeedList)
    2347 ;           0: No (i.e. ANY character may follow the start token
    2348 ;           1: A blank must follow the token
    2349 ;        A flag indicating if the SLC will "comment out" a closing MLC token (SLCOverrideMLCList)
    2350 ;           0: No
    2351 ;           1: Yes
     2373; Returns the single-line comment data for the given mode.
     2374; For each possible SLC the following is returned:
     2375; o  The token which initiates the SLC
     2376;    (SLCCharlist)
     2377; o  A flag indicating any positional requirements
     2378;    (SLCPosList)
     2379;       0: SLC can start anywhere on a line
     2380;       1: SLC MUST start in column 1
     2381;       F: SLC must be the first non-blank on the line
     2382;       <negative_number> : SLC must NOT start in this column
     2383;                           (-6 means SLC must NOT start in column 6)
     2384; o  A flag indicating if the token must be followed by a blank
     2385;    (SLCNeedList)
     2386;       0: No (i.e. ANY character may follow the start token
     2387;       1: A blank must follow the token
     2388; o  A flag indicating if the SLC will "comment out" a closing MLC token
     2389;    (SLCOverrideMLCList)
     2390;       0: No
     2391;       1: Yes
     2392defproc GetSLCChars( Mode, var SLCCharList, var SLCPosList, var SLCNeedList, var SLCOverrideMLCList)
     2393   SLCCharList = QueryModeKey( Mode, 'LineComment', '')
     2394   if SLCCharList <> '' then
     2395      SLCNeedList = QueryModeKey( Mode, 'LineCommentNeedSpace', '0')
     2396      SLCPosList = QueryModeKey( Mode, 'LineCommentPos', '0')
     2397      SLCOverrideMLCList = QueryModeKey( Mode, 'LineCommentOverrideMulti', '0')
     2398   endif
     2399   return
     2400
    23522401; ---------------------------------------------------------------------------
    2353 defproc GetSLCChars( mode, var SLCCharList, var SLCPosList, var SLCNeedList, var SLCOverrideMLCList)
    2354    SLCCharList = QueryModeKey( mode, 'LineComment', '')
    2355    if SLCCharList <> '' then
    2356       SLCNeedList = QueryModeKey( mode, 'LineCommentNeedSpace', '0')
    2357       SLCPosList = QueryModeKey( mode, 'LineCommentPos', '0')
    2358       SLCOverrideMLCList = QueryModeKey( mode, 'LineCommentOverrideMulti', '0')
    2359    endif
    2360    return
    2361 
    2362 ; ---------------------------------------------------------------------------
    2363 ;  prune_assist_array: Clear the comment array
    2364 ; ---------------------------------------------------------------------------
    2365 defproc prune_assist_array()
     2402; Clears the comment array.
     2403defproc PruneAssistArray()
    23662404   getfileid fid
    23672405   listindexbase = fid'.assist.'
    … …  
    23702408
    23712409; ---------------------------------------------------------------------------
    2372 ;  next_nonblank_noncomment_nonliteral: repositions the cursor as the name
    2373 ;     of the routine describes.
    2374 ; ---------------------------------------------------------------------------
    2375 defproc next_nonblank_noncomment_nonliteral( mode)
    2376    direction = arg(2)
     2410; Repositions the cursor on the next non-blank, non-comment and non-literal
     2411; character.
     2412defproc NextCodeChar( Mode)
     2413   CurLine = arg( 2)
     2414   if CurLine = '' then
     2415      CurLine = .line
     2416   endif
     2417   CurCol = arg( 3)
     2418   if CurCol = '' then
     2419      CurCol = .col
     2420   endif
     2421   direction = arg( 4)
    23772422   if direction = '' or not wordpos( direction, '+F -R') then
    23782423      direction = '+F'
    23792424   endif
     2425   .line = CurLine
     2426   .col  = CurCol
    23802427   getsearch savesearch
    23812428   setsearch 'xcom l /[^ \t]+/x'direction    -- find the next non-blank
    … …  
    23832430      repeatfind
    23842431      if not rc then
    2385          comment_rc = inside_comment2( mode, comment_data)
     2432         comment_rc = InsideComment2( Mode, comment_data)
    23862433         --dprintf( "passist", "next pos: ".line",".col "Char: '"substr( textline( .line), .col, 1)'"' "comment_rc: "comment_rc)
    23872434         if not comment_rc then
    … …  
    24142461
    24152462; ---------------------------------------------------------------------------
    2416 ;  fortran77_extract_text: In FORTRAN the text of interest to passist is
    2417 ;     located only in columns 7 ... 72.  (An exception is when FORTRAN90-style
    2418 ;     SLCs are supported.) This routine extracts and returns the text of
    2419 ;     interest to the passist routine.
    2420 ; ---------------------------------------------------------------------------
    2421 defproc fortran77_extract_text( linenum)
     2463; In FORTRAN the text of interest to passist is located only in columns
     2464; 7 ... 72.  (An exception is when FORTRAN90-style SLCs are supported.)
     2465; This routine extracts and returns the text of interest to the passist
     2466; routine.
     2467defproc Fortran77ExtractText( linenum)
    24222468   text = substr( textline( linenum), 7, 66)     -- columns 7 ... 72
    24232469compile if 0 /* USE_FORTRAN90_SLC = 1 */
    … …  
    24272473      .col  = 7
    24282474      setsearch 'xcom l /!/xe+F'
    2429       mode      = 'FORTRAN90'
     2475      Mode      = 'FORTRAN90'
    24302476      clist     = '!'
    24312477      case      = 'e'  -- 'e' = case-sensitive
    … …  
    24332479      clen      = 1
    24342480      nestlevel = -1   -- -1 = stop on first 'hit'
    2435       fortran90_rc = assist_search( mode, clist, case, coffset, clen, nestlevel)
     2481      fortran90_rc = AssistSearch( Mode, clist, case, coffset, clen, nestlevel)
    24362482      if not rc then
    24372483         if .line = linenum and .col > 6 then
    … …  
    24492495
    24502496; ---------------------------------------------------------------------------
    2451 ;  fortran77_remove_spaces: In FORTRAN spaces which are not located within a
    2452 ;     literal are irrelevant. This routine removes these insignificant spaces,
    2453 ;     if any.
    2454 ; ---------------------------------------------------------------------------
    2455 defproc fortran77_remove_spaces( text)
    2456    if pos( ' ', text) then
     2497; In FORTRAN, spaces, which are not located within a literal, are irrelevant.
     2498; This routine removes these insignificant spaces, if any.
     2499defproc Fortran77RemoveSpaces( text)
     2500   do once = 1 to 1
     2501      if not pos( ' ', text) then
     2502         leave
     2503      endif
     2504
    24572505      getfileid fid
    2458       'e .temp_fortran'
     2506
     2507      'xcom e .temp_fortran'
    24592508      insertline text
    24602509      p = 0
    … …  
    24652514         if p then
    24662515            .col = p
    2467             if not inside_literal( 'FORTRAN77') then
     2516            if not InsideLiteral( 'FORTRAN77') then
    24682517               delete_char
    24692518               p = 0
    … …  
    24762525      getline text
    24772526      .modify = 0
    2478       'quit'
     2527      'xcom quit'
     2528
    24792529      activatefile fid
    2480    endif
     2530
     2531   enddo
    24812532   return text
    24822533
    24832534; ---------------------------------------------------------------------------
    2484 ;  t8: Dynamically set the array variable 'debuglist' which is used by
    2485 ;  the dprintf proc.
    2486 ; ---------------------------------------------------------------------------
     2535; Dynamically set the array variable 'debuglist', which is used by
     2536; the dprintf proc.
    24872537/*
    24882538defc t8
    24892539-- AddAVar( 'debuglist', str)
    2490    SetAVar( 'debuglist', arg(1))
     2540   SetAVar( 'debuglist', arg( 1))
    24912541
    24922542defc t10
    24932543   list = GetAVar( 'debuglist')
    2494    sayerror 'debuglist (b4): 'list
    2495 
    2496 defc insidecomment
     2544   'SayHint debuglist: 'list
     2545
     2546defc InsideComment, IC
    24972547   CurMode = GetMode()
    2498    if inside_comment( CurMode) then
    2499       sayerror 'Inside a comment'
    2500    elseif inside_literal( CurMode) then
    2501       sayerror 'Inside a literal'
     2548   parse arg CurLine CurCol .
     2549   if CurLine = '' then
     2550      CurLine = .line
     2551   endif
     2552   if CurCol = '' then
     2553      CurCol = .col
     2554   endif
     2555   if InsideComment( CurMode, CurLine, CurCol) then
     2556      'SayHint Inside a comment'
     2557   elseif InsideLiteral( CurMode, CurLine, CurCol) then
     2558      'SayHint Inside a literal'
    25022559   else
    2503       sayerror 'Not inside a comment or literal'
    2504    endif
    2505 
    2506 defc insideliteral
     2560      'SayHint Not inside a comment or literal'
     2561   endif
     2562
     2563defc InsideLiteral, IL
    25072564   CurMode = GetMode()
    2508    if inside_literal( CurMode) then
    2509       sayerror 'Inside a literal'
     2565   parse arg CurLine CurCol .
     2566   if CurLine = '' then
     2567      CurLine = .line
     2568   endif
     2569   if CurCol = '' then
     2570      CurCol = .col
     2571   endif
     2572   if InsideLiteral( CurMode, CurLine, CurCol) then
     2573      'SayHint Inside a literal'
    25102574   else
    2511       sayerror 'Not inside a literal'
    2512    endif
     2575      'SayHint Not inside a literal'
     2576   endif
     2577
     2578defc InsideSingleLineComment, ISLC
     2579   CurMode = GetMode()
     2580   parse arg CurLine CurCol .
     2581   if CurLine = '' then
     2582      CurLine = .line
     2583   endif
     2584   if CurCol = '' then
     2585      CurCol = .col
     2586   endif
     2587   if InsideSLC( CurMode, CurLine, CurCol) then
     2588      'SayHint Inside a single-line comment'
     2589   else
     2590      'SayHint Not inside a single-line comment'
     2591   endif
     2592
     2593defc InsideMultuLineComment, IMLC
     2594   CurMode = GetMode()
     2595   parse arg CurLine CurCol .
     2596   if CurLine = '' then
     2597      CurLine = .line
     2598   endif
     2599   if CurCol = '' then
     2600      CurCol = .col
     2601   endif
     2602   if InsideMLC( CurMode, CurLine, CurCol) then
     2603      'SayHint Inside a multi-line comment'
     2604   else
     2605      'SayHint Not inside a multi-line comment'
     2606   endif
     2607
     2608defc NextCodeChar
     2609   CurMode = GetMode()
     2610   parse arg CurLine CurCol Direction .
     2611   call NextCodeChar( CurMode, CurLine, CurCol, Direction)
    25132612*/
    25142613

  • TabularUnified trunk/src/netlabs/macros/keys.e

    r3251 r3257  
    10611061   -- Invalidate array of multi-line comment positions, used by passist()
    10621062   if not IsSingleKey( lastkey()) & curkey <> prevkey then
    1063       if IsADefProc( 'prune_assist_array') then
    1064          call prune_assist_array()
     1063      if IsADefProc( 'PruneAssistArray') then
     1064         call PruneAssistArray()
    10651065      endif
    10661066   endif

  • TabularUnified trunk/src/netlabs/macros/tags.e

    r3171 r3257  
    181181         if .col > 1 then
    182182            if pos( upcase( substr( line, .col - 1, 1)), IDENTIFIER_STARTER'0123456789') then
    183                end_line
     183               endline
    184184               iterate
    185185            endif
    … …  
    187187         .col = .col + ProcLen
    188188         if pos( upcase( substr( line, .col, 1)), IDENTIFIER_STARTER'0123456789') then
    189             end_line
     189            endline
    190190            iterate
    191191         endif
    192192
    193193         -- Use assist code for comment and literal determination
    194          if inside_comment_literal( 'C') then
     194         if InsideCommentLiteral( 'C') then
    195195            --dprintf( 'Inside comment or literal, iterate')
    196             end_line
     196            endline
    197197            iterate
    198198         endif
    … …  
    228228
    229229         -- Use assist code for comment and literal determination
    230          if inside_comment_literal( 'C') then
     230         if InsideCommentLiteral( 'C') then
    231231            --dprintf( 'Inside comment or literal, iterate')
    232232            .line = CloseBraceLine
    233             end_line
     233            endline
    234234            iterate
    235235         endif
    … …  
    242242         if rcx <> 0 then
    243243            .line = CloseBraceLine
    244             end_line
     244            endline
    245245            iterate
    246246         endif
    … …  
    248248
    249249         -- Previous char must be a closing branch
    250          ch = next_nonblank_noncomment_nonliteral( 'C', '-R')
     250         ch = NextCodeChar( 'C', .line, .col, '-R')
    251251         --dprintf( ') CloseBranch: line =' .line', col = '.col', ch = 'ch)
    252252         -- If not ')' then find next closing brace in col 1.
    253253         if ch <> ')' then
    254254            .line = CloseBraceLine
    255             end_line
     255            endline
    256256            iterate
    257257         endif
    … …  
    262262         if rcx <> 0 then
    263263            .line = CloseBraceLine
    264             end_line
     264            endline
    265265            iterate
    266266         endif
    … …  
    268268
    269269         -- Previous char must be the end of ProcName
    270          ch = next_nonblank_noncomment_nonliteral( 'C', '-R')
     270         ch = NextCodeChar( 'C', .line, .col, '-R')
    271271         if ch = '' then
    272272            .line = CloseBraceLine
    273             end_line
     273            endline
    274274            iterate
    275275         endif
    … …  
    282282         if rc then
    283283            .line = CloseBraceLine
    284             end_line
     284            endline
    285285            iterate
    286286         endif
    … …  
    298298            ProcName = ''
    299299            .line = CloseBraceLine
    300             end_line
     300            endline
    301301            iterate
    302302         endif
    … …  
    349349      endif
    350350
    351       if inside_comment_literal( 'PASCAL') then
     351      if InsideCommentLiteral( 'PASCAL') then
    352352         repeat_find
    353353         iterate
    … …  
    362362            c = upcase( substr( line, .col - 1, 1))
    363363            if (c >= 'A' & c <= 'Z') | (c >= '0' & c <= '9') | c = '$' | c = '_' then
    364                --end_line
     364               --endline
    365365               repeat_find
    366366               iterate
    … …  
    370370         c = upcase( substr( line, .col, 1))
    371371         if (c >= 'A' & c <= 'Z') | (c >= '0' & c <= '9') | c = '$' | c = '_'  then
    372             --end_line
     372            --endline
    373373            repeat_find
    374374            iterate
    … …  
    385385      endif
    386386      if not p then
    387          --end_line
     387         --endline
    388388         repeat_find
    389389         iterate
    … …  
    396396            call psave_pos( save_pos)
    397397            if find_matching_paren() then
    398                --end_line
     398               --endline
    399399               repeat_find
    400400               iterate
    … …  
    404404
    405405         if pos( 'forward;', textline( .line)) then
    406             --end_line
     406            --endline
    407407            repeat_find
    408408            iterate
    … …  
    415415         --return 0
    416416      endif
    417       --end_line
     417      --endline
    418418      --repeat_find
    419419
    … …  
    449449      endif
    450450
    451       if inside_comment_literal( 'ASSEMBLER') then
     451      if InsideCommentLiteral( 'ASSEMBLER') then
    452452         repeat_find
    453453         iterate
    … …  
    483483      endif
    484484
    485       if inside_comment_literal( 'CMD') then
     485      if InsideCommentLiteral( 'CMD') then
    486486         repeat_find
    487487         iterate
    … …  
    516516      endif
    517517
    518       if inside_comment_literal( 'HTEXT') then
     518      if InsideCommentLiteral( 'HTEXT') then
    519519         repeat_find
    520520         iterate
    … …  
    559559      endif
    560560
    561       if inside_comment_literal( 'IPF') then
     561      if InsideCommentLiteral( 'IPF') then
    562562         repeat_find
    563563         iterate
    … …  
    629629      if fFindProcName then
    630630         if length( ProcName) <> ProcLen then  -- a substring of something else
    631             --end_line
     631            --endline
    632632            repeat_find
    633633            iterate
    … …  
    635635      endif
    636636
    637       if inside_comment_literal( 'JAVASCRIPT') then
     637      if InsideCommentLiteral( 'JAVASCRIPT') then
    638638         repeat_find
    639639         iterate
    … …  
    672672      if fFindProcName then
    673673         if length( ProcName) <> ProcLen then  -- a substring of something else
    674             end_line
     674            endline
    675675            repeat_find
    676676            iterate
    … …  
    678678      endif
    679679
    680       if inside_comment_literal( 'PYTHON') then
     680      if InsideCommentLiteral( 'PYTHON') then
    681681         repeat_find
    682682         iterate
    … …  
    739739      Len = GetPmInfo( EPMINFO_LSLENGTH)
    740740
    741       if inside_comment_literal( 'E') then
     741      if InsideCommentLiteral( 'E') then
    742742         repeat_find
    743743         iterate
    … …  
    781781         Next = strip( Next)
    782782         NextLen = length( Next)
    783          -- Move to Next for inside_comment_literal check
     783         -- Move to Next for InsideCommentLiteral check
    784784         .col = .col + NextLen - 1 + pos( Next, RestLine)
    785          if inside_comment_literal( 'E') then
     785         if InsideCommentLiteral( 'E') then
    786786            iterate
    787787         endif
    … …  
    819819      endif
    820820
    821       if inside_comment_literal( 'REXX') then
     821      if InsideCommentLiteral( 'REXX') then
    822822         repeat_find
    823823         iterate
    … …  
    870870      endif
    871871
    872       if inside_comment_literal( 'TEX') then
     872      if InsideCommentLiteral( 'TEX') then
    873873         repeat_find
    874874         iterate
    … …  
    882882            c = upcase( substr( line, .col - 1, 1))
    883883            if (c >= 'A' & c <= 'Z') | (c >= '0' & c <= '9') | c = '$' | c = '_'  then
    884                --end_line
     884               --endline
    885885               repeat_find
    886886               iterate
    … …  
    890890         c = upcase( substr( line, .col, 1))
    891891         if (c >= 'A' & c <= 'Z') | (c >= '0' & c <= '9') | c = '$' | c = '_'  then
    892             --end_line
     892            --endline
    893893            repeat_find
    894894            iterate
    … …  
    901901      col = .col
    902902      if not pos( Keywords, line, 1, 'x') then
    903          --end_line
     903         --endline
    904904         repeat_find
    905905         iterate
    … …  
    932932         --return 0
    933933      endif
    934       --end_line
     934      --endline
    935935      --repeat_find
    936936
    … …  
    13631363         .col = 1
    13641364         call proc_search( ProcName, 1, Mode, Ext)
    1365          --call prune_assist_array()
    13661365         return
    13671366      endif
    … …  
    13721371   'SayHint Searching for routine.'
    13731372   searchrc = proc_search( ProcName, 1, Mode, FType)
    1374    --call prune_assist_array()
    13751373   --dprintf( 'Using proc_search for 'ProcName', filename = '.filename)
    13761374   if searchrc then
    … …  
    15831581      i = i + 1
    15841582      insertline ProcName '('.line')', lb_fid.last + 1, lb_fid
    1585       end_line
     1583      endline
    15861584
    15871585      -- Store item number for cursor pos
    … …  
    15911589   enddo
    15921590
    1593    --call prune_assist_array()
    15941591   call prestore_pos( savepos)
    15951592   if browse_mode then

  • TabularUnified trunk/src/netlabs/macros/undo.e

    r3223 r3257  
    284284
    285285   -- Invalidate array of multi-line comment positions, used by passist()
    286    if IsADefProc( 'prune_assist_array') then
    287       call prune_assist_array()
     286   if IsADefProc( 'PruneAssistArray') then
     287      call PruneAssistArray()
    288288   endif
    289289   'MatchFindOnMove'
    … …  
    337337
    338338   -- Invalidate array of multi-line comment positions, used by passist()
    339    if IsADefProc( 'prune_assist_array') then
    340       call prune_assist_array()
     339   if IsADefProc( 'PruneAssistArray') then
     340      call PruneAssistArray()
    341341   endif
    342342   'MatchFindOnMove'
    … …  
    345345; The following code defines key commands that let you step backwards
    346346; and forwards through the undo states.
    347 ;
    348347; With the switch to accel keys, a new undo state is only created for
    349348; commands different from Undo1 or Redo1.
    350 
    351 ; ---------------------------------------------------------------------------
    352349defc Undo1
    353350   universal current_undo_state
Note: See TracChangeset for help on using the changeset viewer.