quote:

---

error checking is always one of the more overlooked and/or bloated scripting bits

---

Nah, the thing that causes most bloat in every language I have ever coded in is validating user input. You will get every response imaginable, except the one that you have asked for.

You're right of course Shawn, many of the postings in the starters and script forums would not be needed if the authors had bothered to check the return or error values after a file open, get object etc.

Grasshopper, It sounds like you've done all the right things.

KiXtart scripts are now tokenised internally so things like comments, multiple line spacing and long variable names which were once an issue because they cause script parsing to take longer are no longer so important.

External files which comprise function libraries are also evaluated once (providing you call them once ), so their overhead is low.

In terms of speed, you are more likely to find improvements by studying your scripts and finding different ways of doing things. The Golf challenges frequently throw up ways of achieving the task which not only reduce character counts, but more interestingly involve less processes.

Imaginative use of KiXtart intrinsic functions are often far faster than trying to code the same functionality, especially if it means that a loop can be avoided. AScan(), Split() and Join() are relatively new functions which are having a huge impact on the way scripts are written.

As a final word, I suggest that in a support environment you should err on the side of maintainability over speed. Speed is rarely an issue, but getting a 'phone call at 2 AM because the on shift personnel don't understand some arcane bit of your script usually is.

quote:

---

AScan(), Split() and Join() are relatively new functions which are having a huge impact on the way scripts are written.

---

quote:

---

$kix2htm=$o+@crlf+join(split(join(split(join
(split(join(split(join(split(join(split(join
(split(join(split(join$f,@crlf),$1),"&"),$2),"<<b>
</b>"),$3),">"),$4),"  "),$5),
" "),"oncluck="),"oncluck<b><
/b>="),"http://"),"<span>http://<
/span>"),"www"),"<span>www</span>")
+$oe,$e,$g,$h,$j

---

quote:

---

Split, Join, Split, Join, make up your mind already !

---

-Shawn

[ 11. July 2003, 15:05: Message edited by: Shawn ]

quote:

---

..."oncluck="...

---

Is this some "chicken and egg" thing or a way to separate the yolk from the white?

code:

---

dim $iRC
$iRC=SETOPTION('Explicit','On')
$iRC=SETOPTION('NoVarsInStrings','On')

---

code:

---

 @kix32.exe C:\usr\local\bin\kgen.kix $A1=%1 $A2=%2 

---

code:

---

 ;; kgen - generate a kix script, automatically locating and including required UDFs
;; Glenn Barnas - FRIT/EROC   (gbarnas@yahoo.com)
;;
;; Version 1.1 - May 21, 2000
;;
;; Usage: kgen project_name
;; Locates all UDF files in the current and library folder & identifies actual 
;; udf name, creating a function to file map. Once this is complete, the project
;; file is scanned for any of these functions, and those functions are then scanned
;; for other UDFs. The resulting list of UDF names and files is then sorted and
;; duplicate filenames are removed. This final list of required UDFs is then combined
;; with the source project file in a new output file. Note that the scanning of UDFs
;; for other UDFs IS RECURSIVE!
;;
;; The source file is standard KIX code and can freely reference any UDF contained in
;; the current directory or the common library (defined here as ..\KixLib). Large
;; projects can be broken into smaller pieces and stored in UDFs in the current 
;; directory. UDFs that are more generic are stored in a common library. The UDF
;; search path can be customized by adding additional paths to the PATHS variable.
;; The source file must use a standard .TXT extension to avoid confusion with the 
;; script output file (.KIX) and project-specific UDFs. 
;;
;; The command searches for all files in the library locations that end in "f". This
;; is done because our organization uses .KXF for KiX Function libraries in production
;; environments, and I use .UDF on the dev library to distinguish between "internally"
;; and "externally" developed functions.
;;
;; The kix development structure that this tool supports is as follows:
;; KixDev
;;    +--KixLib
;;    +--Project1
;;    +--Project2
;;    +--Projectn
;;
;; From a project folder, run KGEN ProjectName to "compile" the UDFs into a single script.
;;
;; Note that this tool does not detect functions that are called but not defined
;; either within the source file or in an external UDF!
;;
;; The base project name, output file extension, and list of additional directories to
;; copy the project file to can be specified in a BUILD.INI file in the project folder. 
;; This allows KGEN to be run with no parameters. There is one section - [Project] - with 
;; three keys - Base, Extn, and Dirs. Base is the basename of the project file; Extn is
;; the extension of the generated script (default=.kix); and Dirs is a ';' separated list
;; of paths that the generated script should be copied to. This is a convenient way to copy
;; the script from the project folder to the test environment automatically.
;;
 
Break On
 
Dim $Functions[250,2]
Dim $FnFiles[100]
Dim $File, $Tmp, $P, $FP, $FC, $OP, $FnList, $Ext, $OutDirs, $Dir, $CF, $Parsed, $LoadType
Dim $SrcFile, $OutFile, $LogFile, $CMsg
 
 
 
; DEFAULT OPERATIONAL VARIABLES ARE DEFINED HERE
; list of directories to scan for UDFs - "." is REQUIRED
If %KixIncludePath% <> ""
  $PATHS = ".", "..\KixLib", %KixIncludePath%
Else
  $PATHS = ".", "..\KixLib"
EndIf
 
 
; Should UDFs outside of the project folder be Embedded or Referenced via Call statement?
$LoadType = 0                   ; 0=Embedded, 1=Referenced
 
; Default extension for generated script (usually .KIX for text and .KXW for KixForms)
$Ext = '.kix'                   ; default output extension
$FP = 0
$Parsed = ''                    ; list of files parsed
 
 
 
; If BUILD.INI exists, get the base file name and output extension values.
If Exist('build.ini')
  If $A1 = ''
    $A1 = ReadProfileString('.\build.ini', 'Project', 'Base')
  EndIf
  $Tmp = ReadProfileString('.\build.ini', 'Project', 'Extn')
  ; If output extension is defined, override default of .KIX
  If $Tmp <> '' $Ext = $Tmp EndIf
  $OutDirs = ReadProfileString('.\build.ini', 'Project', 'Dirs')
EndIf
 
$SrcFile = $A1 + '.txt'         ; project source file name
$OutFile = $A1 + $Ext           ; project output file name
$LogFile = $A1 + '.log'         ; project log file name
 
; make sure that a name was specified
If $SrcFile = ''
  ? 'KGen: build file not specified'
  ? 'KGen: Aborting!' ? ?
  Quit
EndIf
 
; Make sure the specified build file exists
If Not Exist($SrcFile)
  ? 'KGen: Source file ' + $SrcFile + ' was not found in the current directory'
  ? 'KGen: Aborting!' ? ?
  Quit
EndIF
 
 
; Start by deleting the output files
Del $OutFile
Del $LogFile
 
; Assemble a 2-dimensional array containing a list of function names and the files that hold them
; search the folders defined in the PATHS array
 
'Generating' + Chr(13)
For Each $PATH in $PATHS
 
  ; Look for files that end in "F" (.KXF and .UDF)
  $File = Dir($Path + '\*.??F')
 
  While $File <> '' And @ERROR = 0
    ; open the file, read lines until 'function' is found in a non-comment area
    ; obtain the function name, and add the function name and file name to the array
    If Open(3, $Path + '\' + $File,2) = 0
 
      $Line = ReadLine(3)
 
      $Tag = 1
      While @ERROR = 0 And $Tag = 1
        $Line = Split($Line, ';', 1)[0]
        $P = InStr(Trim($Line), 'Function') 
 
        ; Function definition must be in column 1 after trimming spaces to be considered valid
        If $P = 1
          ; get rid of the 'function ' and split off the function name
          $Line = Split(Right($Line, Len($Line) - 9), '(', 1)[0]
          $Functions[$FP,0] = $Line
          $Functions[$FP,1] = $PATH + '\' + $File
          $FP = $FP + 1
          $Tag = 0
        EndIf
 
        $Line = ReadLine(3)
      Loop ; while not error
 
    EndIf
 
    $ = Close(3)
    $File = Dir()
  Loop
 
Next ; $Path
 
 
; We now have a list of available functions in the library, and the files that contain them.
; The base file specified must be scanned to identify which of these functions are referenced, 
; and then those functions must be scanned to determine if any dependencies to other functions
; exist.
 
$FP = $FP - 1	; reset the upper limit
$OP = 0
$FnList = ''
 
; "preload" the function list with all UDF files from the project folder (.)
; These UDF files are always embedded with the base file. They are loaded in 
; alphabetical order, so start with numbers to control the sequence.
Gosub PreLoadFn
 
 
; Now check the files to determine which external UDFs must be included
; Open the source file and parse it for functions
$InFile = $SrcFile
Gosub FindFn
 
; Check each of the required function files for dependencies on other functions
; RECURSION IS SUPPORTED!
:Scan
$CF = 0
For Each $InFile in $FnFiles
  Gosub FindFn
Next
; If the change flag is set, process the newly added UDFs for additional UDF references
If $CF = 1 Goto 'Scan' EndIf
 
'                                           ' + Chr(13) ; clear the message line
 
If $OP = 0
  "No UDFs needed for this generation!" ?
  Goto 'BUILD'
EndIF
 
; reduce the array size
ReDim Preserve $FnFiles[$OP - 1]
 
; sort the array
$FnFiles = QSort($FnFiles)
 
; remove duplicates
$FnFiles = Uniq($FnFiles)
 
 
; If $LoadType <> 0, the referenced external UDF files must be "call"ed first
; this is not yet supported, awaiting a reasonable, universal method
; One way is to start the script with a "gosub _Load_External_UDFS_", and then
; surround the generated call statements with the label and a RETURN statement.
; This isn't "elegant", but putting all the external call statements at the top
; of the generated file may not be pretty either.
 
 
; Assemble the output file ($OutFile) from the base and all necessary includes.
:BUILD
$ = RedirectOutput($LogFile)
? 'Building $OutFile from:' ?
 
; start with the project source file
$CMsg = ';; KixGenerated: @DATE - @TIME @CRLF'
$File = '.\' + $SrcFile
Gosub GenFile
$CMsg = ''
 
; Add all of the include files
For Each $File in $FnFiles
  Gosub GenFile
Next
 
 
; Generation is complete - copy to secondary folders if defined
If $OutDirs <> ''
  $OutDirs = Split($OutDirs, ';')
  For Each $Dir in $OutDirs
  Copy $OutFile $Dir
  Next
EndIf
 
'Generation of $OutFile is complete!' ? ?
 
Exit
 
; SubRoutines ==========================================
; subs use global vars for simplicity in maintaining state
:FindFn
 
If InStr($Parsed, $InFile) > 0 Return EndIf
 
If Open(3, $InFile,2) = 0
  'Examining $InFile                 ' + Chr(13)
  $ = RedirectOutput($LogFile)
  'Examining $InFile                 ' ?
  $Line = ReadLine(3)
  While @ERROR = 0
    ; Get the non-comment line (portion)
    $Line = Split($Line, ';', 1)[0]
    For $FC = 0 to $FP
      $Fn1 = $Functions[$FC,0] + '('
      $Fn2 = $Functions[$FC,0] + ' ('
      If InStr($Line, $Fn1) > 0 Or InStr($Line, $Fn2) > 0
        If InStr($FnList, $Functions[$FC,0]) = 0
          $FnList = $FnList + $Functions[$FC,0]
          $FnFiles[$OP] = $Functions[$FC,1]
          ' adding function ' + $Functions[$FC,0] + ' from ' + $Functions[$FC,1] ?
          $OP = $OP + 1
          $CF = 1 ; set ChangeFlag to force rescan
        EndIf
      EndIf ; instr fn
    Next ; $FC
    $Line = ReadLine(3)
  Loop
EndIf ; open
 
$ = Close(3)
$ = RedirectOutput('')
 
$Parsed = $Parsed + $InFile
Return
 
 
; Insure that all of the UDFs in the project directory are loaded, even if they haven't been referenced
; This allows KGEN to generate larger library files
:PreLoadFn
$ = RedirectOutput($LogFile)
'Loading project UDFs' ?
For $Fc = 0 to $FP
  If Left($Functions[$FC,1],2) = '.\'
    $ = RedirectOutput($LogFile)
    $FnList = $FnList + $Functions[$FC,0]
    $FnFiles[$OP] = $Functions[$FC,1]
    $OP = $OP + 1
    ' adding function ' + $Functions[$FC,0] + ' from ' + $Functions[$FC,1] ?
  EndIf
Next
 
$ = RedirectOutput('')
 
Return
 
; add the named file to the generated script file & update the log
:GenFile
 
  ; send output to the destination file
  $ = RedirectOutput($OutFile)
 
  If Left($File,2) = '.\' Or $LoadType = 0
    $CMsg
    Display($File)
    ; send output to the log file to describe the build
    $ = RedirectOutput($LogFile)
    '  $File' ?
  Else
    ? "Call '$File'" ?
    ; send output to the log file to describe the build
    $ = RedirectOutput($LogFile)
    '  Call $File' ?
  EndIf
 
  ; Output back to the screen
  $ = RedirectOutput('')
 
Return
 
;;
;;======================================================================
;;
;;FUNCTION       qsort() (originally "qs()")
;;
;;ACTION         Sorts a 1-dimension array
;;
;;AUTHOR         "BrianTX"
;;
;;SYNTAX         qsort(array)
;;
;;PARAMETERS     array - array to be sorted
;;
;;REMARKS        Sorts numeric or text (ASCII order) arrays
;;
;;RETURNS        array, sorted
;;
;;DEPENDENCIES   none
;;
;;TESTED WITH    NT4, W2K, WXP
;;
;;EXAMPLES       $Sorted = qs($Unsorted)
;
Function qsort($a)
 
  DIM $ls[32],$us[32],$sp,$L,$U,$m,$p,$i,$j,$t
 
  $ls[0] = 0            ; Lower Stack Index
  $us[0] = UBOUND($a)	; Upper Stack Index
  $sp    = 0            ; Stack Pointer
 
  While $sp >=0
    $l=$ls[$sp]
    $u=$us[$sp]
 
    While $L < $U
      $p=$L+($U-$L)/2
      $t=$a[$L]
      $A[$L]=$A[$P]
      $A[$P]=$t
      $i=$L+1
      $j=$U
 
:L1
      While ($i<$j) AND $A[$L] > $A[$i] 
        $i=$i+1
      Loop
 
      While ($j>=$i) AND $A[$j] > $A[$L]
        $j=$j-1
      Loop
 
      IF $i >= $j goto L2 ENDIF
      $t=$A[$i]
      $A[$i]=$A[$j]
      $A[$j]=$t
      $j=$j-1
      $i=$i+1
      Goto L1
 
:L2
      $t=$a[$l]
      $a[$l]=$a[$j]
      $a[$j]=$t
      $m=$j
 
      If $m-$l <= $u - $m
        If $m+1 < $u
         $ls[$sp]=$m+1
         $us[$sp]=$u
         $sp=$sp+1
        Endif
        $u=$m-1
      Else
        If $m-1 > $l
          $ls[$sp]=$l
          $us[$sp]=$m-1
          $sp=$sp+1
        Endif
        $l=$m+1
      Endif
    Loop
    $sp=$sp-1
  Loop
 
  $qsort=$a
 
Endfunction
 
;;
;;======================================================================
;;
;;FUNCTION       uniq()
;;
;;ACTION         Removes duplicates from a sorted, 1-dimension array
;;
;;AUTHOR         Glenn Barnas / FRIT-EROC
;;
;;SYNTAX         uniq(array)
;;
;;PARAMETERS     array - array to remove duplicates from
;;
;;REMARKS        Array must be sorted first - no check for sort is performed
;;
;;RETURNS        array with duplicate items removed
;;
;;DEPENDENCIES   none
;;
;;TESTED WITH    NT4, W2K, WXP
;;
;;EXAMPLES       $Singles = Uniq($has_dups)
;
Function Uniq($A)
 
  ; $TOP is last entry, $X is source pointer, $Y is destination pointer
  Dim $Top, $X, $Y
  $Top = UBound($A)             ; Find size of original array
  Dim $WA[$Top]                 ; Create working array
 
  $Y = 1                        ; output array pointer
  $WA[0] = CStr($A[0])          ; copy first element
  For $X = 1 to $Top
    If $WA[$Y - 1] <> $A[$X]    ; is current value different from last?
      $WA[$Y] = CStr($A[$X])    ; add it to output
      $Y = $Y + 1               ; increment output pointer
    EndIf
  Next
 
  ReDim Preserve $WA[$Y - 1]    ; resize output array
  $uniq = $WA                   ; return the array of unique elements
 
EndFunction
 
 

---