HyperPics: Beyond the UI

Calculating Elapsed Time with AutoLISP

Why calculate elapsed time or differences in time you might be wonder?  There are primarily two reasons to do this:

• Determine the time it took to complete a task; for calculating cost savings or Return on Investment (ROI)
• Generate a unique name

The need to the calculate cost to make something or complete a task/project is nothing new and happens everyday across every company.  When calculating cost savings, you need to consider the following pieces of information:

• Does an action/activity have to be performed?
• How often is the action/activity performed?
• How much does the action/activity cost when performed?
• How long does it currently and/or previously take to complete the action/activity?

Even though calculating cost savings is an important conversation, that is best left for a future article.

Until AutoCAD 2017, the date and time stored in the CDATE and DATE system variables were the best for calculating time differences in an AutoCAD-based product as they included milliseconds.  Starting with AutoCAD 2017-based products, the CDATE and DATE system variables no longer include milliseconds.  Other date related system variables, such TDCREATE were also affected by this change.  I discussed this change across several articles recently, which can be found here:

• Getting the Current Date/Time with AutoLISP - Part 1
• Getting the Current Date/Time with AutoLISP - Part 2
• PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?
• PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Computers can easily handle hundreds of thousands of instructions per second based on their architecture, so milliseconds is a much better measurement in time to measure compared to a full second.  Since the CDATE and DATE system variables no longer include milliseconds, the MILLISECS system variable can be used to calculate time differences in milliseconds.  As part of a custom AutoLISP program, you might store the current time of MILLISECS as the start time and then as part of the final tasks to be performed you might get the end value and subtract the differences of the two time values to get the time that has elapsed. 

Command: (setq start (getvar "MILLISECS"))
25494432

Command: (setq end (getvar "MILLISECS"))
25499471

Command: (- end start)
5039

Of course, it is always best to wrap any functionality that you might want to use across multiple programs in a utility function; making it easier to manage and maintain.  The following is an example of such a function, the Timer function wraps the functionality that stores the start time and returns the time difference in a single function.

; Global variable for the timer
(setq *g-timer-start-time* nil)

; Stores the current time when called, and then returns
; the time difference when called the next time. Time
; difference is returned in milliseconds.
; Usage: (timer)
(defun timer ( / rTimeDiff)
  ; Check to see if the function was previously called
  (if (= *g-timer-start-time* nil)
    (progn
      ; Stores the current milliseconds
      (setq *g-timer-start-time* (getvar "MILLISECS"))
      (princ)
    )
    (progn
      ; Calculates and returns the time difference
      (setq rTimeDiff (- (getvar "MILLISECS") *g-timer-start-time*)
            *g-timer-start-time* nil)
      rTimeDiff
    )
  )
)

The following shows a example of how you might use the Timer function with your custom programs and the output that is returned:

(defun c:CounterLoop ( / loop cnt cur)
  ; Store the current time
  (timer)

  ; Loop 10000 times and output a message every 100 loops
  (setq loop 0 cnt 0)
  (repeat 10000
    (setq cur (fix (/ loop 100.0)))
    (if (= cnt cur)
      (progn
        (prompt (strcat "\nLoop: " (itoa loop)))
        (setq cnt (1+ cnt)) 
      )
    )
    (setq loop (1+ loop))
  )

  (prompt (strcat "\nLoop: " (itoa loop)))

  ; Output the number of elapsed milliseconds
  (prompt (strcat "\nElapsed time (ms): " (itoa (timer))))
 (princ)
)

Partial output from the previous example:

...
Loop: 9700
Loop: 9800
Loop: 9900
Loop: 10000
Elapsed time (ms): 63

While most programs execute very quickly, some might take much longer based on the tasks they perform.  Programs that take longer to execute might complete in tens of thousands of milliseconds, which can be hard to determine just how many seconds or minutes might have elapsed.  The following functions can be used to calculate the differences in time and format milliseconds or seconds as hours, minutes, seconds, and milliseconds:

;| Takes two values in milliseconds and returns the
   difference as an integer/long or double/float

   bMilliseconds = T   - Return value in milliseconds
   bMilliseconds = nil - Return value in seconds

   Usage: (TimeDiff T1 T2 T) - Milliseconds example
   Usage: (TimeDiff T1 T2 nil) - Seconds example

   Example(s)
   (setq T1 24092498)
   (setq T2 24188267)
   (TimeDiff T1 T2 T)
   95769

   (TimeDiff T1 T2 nil)
   95.769
|;
(defun TimeDiff (nStart nEnd bReturnMilliseconds / nDiff)
 
  ;; Get the time difference
  (if (> nStart nEnd)
    (setq nDiff (- nStart nEnd))
    (setq nDiff (- nEnd nStart))
  )

  ;; Return the time difference in milliseconds or seconds
  (if (= bReturnMilliseconds nil)
    (/ nDiff 1000.0)
    nDiff
  )
)

;| Formats milliseconds or seconds into the
   HH:MM:SS:mmm (00:00:00:000) format

   bMilliseconds = T   - Time is expressed in milliseconds
   bMilliseconds = nil - Time is expressed in seconds

   Usage: (FormatTime 122.021 nil) - Seconds example
   Usage: (FormatTime 95769 T)     - Milliseconds example

   Example(s)
   (setq T1 24092498)
   (setq T2 24188267)
   (FormatTime (TimeDiff T1 T2 T) T)
   "00:01:35:769"

   (FormatTime 122.021 nil)
   "00:02:02:021"
|;
(defun FormatTime (dTime bMilliseconds / dDiff sHrs nHrs sMins
                                         nMins sSecs sMSecs nSecs)
  (if bMilliseconds
    (setq dDiff (/ dTime 1000.0))
    (setq dDiff dTime)
  )

  ; Set the default values
  (setq sHrs   "00"
        sMins  "00"
        sSecs  "00"
        sMSecs "000")
   
  ; Get the number of seconds
  (setq nSecs (fix dDiff))

  ; Get the number of milliseconds left
  (setq sMSecs (rtos (* (- dDiff nSecs) 1000.0) 2 0))

  ; Get the number of minutes
  (setq nMins (/ nSecs 60)
        sMins (itoa nMins))

  ; Get the number of hours and minutes, if minutes are greater than 60
  (if (> nMins 60)
    (setq nHrs (fix (/ nMins 60))
          sHrs (itoa nHrs)
          nMins (- nMins (* nHrs 60))
          sMins (itoa nMins))
  )

  ; Get the number of seconds
  (setq sSecs (itoa (- nSecs (* (/ nSecs 60) 60))))

  ; Format Hours to "00"
  (if (= (strlen sHrs) 1)
    (setq sHrs (strcat "0" sHrs))
  )

  ; Format Minutes to "00"
  (if (= (strlen sMins) 1)
    (setq sMins (strcat "0" sMins))
  )

  ; Format Seconds to "00"
  (if (= (strlen sSecs) 1)
    (setq sSecs (strcat "0" sSecs))
  )

  ; Format Milliseconds to "000"
  (while (< (strlen sMSecs) 3)
    (setq sMSecs (strcat "0" sMSecs))
  )

  ; Return the output in the 00:00:00:000 format
  (strcat sHrs ":" sMins ":" sSecs ":" sMSecs) 
)

Hope you found the information in this topic helpful.

Sincerely,
  Lee

 

Getting the Current Date/Time with AutoLISP - Part 2

Needing to populate a title block or stamp a drawing with the current date/time is a very common task in the AutoCAD product along with determining the time it might have taken to execute a custom program for return of investment (ROI) analysis.  AutoCAD-based products support several system variables that can be used to determine the current date/time, these system variables are:

• CDATE - Stores the current date and time as a decimal value.
• DATE - Stores the current date and time in Modified Julian Date format.
• MILLISECS - Stores the current number of milliseconds since the computer was booted.

NOTE: Starting with AutoCAD 2017, the CDATE and DATE system variables no longer store the current time down to milliseconds.

DATE System Variable

The DATE system variable can be used to get the current date and time within the AutoCAD environment while using AutoLISP, but unlick the CDATE system variable will require some work to transform the Modified Julian Date format into something recognizable.  When queried, the DATE system variable returns a value as a real number.  The GETVAR function is used to return the value of a system variable for use with the AutoLISP programming language.

Here is an example of getting the value stored in the DATE system variable:

Command: (getvar "DATE")
2.45781e+06

As previously mentioned, the value of the DATE system variable is a real number.  By default, it isn't possible to see the full value of the DATE system variable without a bit of extra help.  It is best to convert the real number to a string, so you can see and work with the full value which can be accomplished using the RTOS function.  The RTOS function accepts 3 arguments, the real number to convert to a string and two optional arguments which represent the linear unit mode and precision in which the value should be formatted.

Here is an example of converting the value stored in the DATE system variable to a string that represents the real value as a decimal with a precision of 9:

Command: (rtos (getvar "DATE") 2 9)
"2457806.411851852"

The date part of the Modified Julian Date format is the integer part of the number (what is to the left of the decimal), while time is represented by the fraction part of the number (what is to the right of the decimal).  The date is the number of days since Noon on January 1, 4713 BC... Why not, Noon makes sense and time is expressed as a fraction of the since Midnight which can be calculated by multiplying the fraction by 86,400.  If your head is spinning, you are not the only one.  Feel free to take up some light reading on the subject about the Julian Day.  I am sure you are thinking about just sticking with the Gregorian Calendar whenever possible since it is familiar to most people on the planet, which is easier said than done when working with dates in AutoCAD as drawing creation, last updated, and several other dates are all stored as Modified Julian Dates.

These system variables also store dates and/or time values expressed as a Modified Julian Date:

• TDCREATE
• TDINDWG
• TDUCREATE
• TDUPDATE
• TDUSRTIMER
• TDUUPDATE

As you can imagine based on the description, there is a bit of math that is involved to calculate both the date and time using the value returned by the DATE system variable.  While there are no standard AutoLISP functions available for converting a Julian Date to equivalent Gregorian Calendar Date, there are 5 AutoLISP functions in the Express Tools that can be used to make the task easier.  These functions are made available after the Julian.lsp file is loaded into the AutoCAD environment, which can be done using the DATE command or the AutoLISP load function.

The date related AutoLISP functions that are accessible after the Julian.lsp file is loaded are:

• CTOJ - Converts a Gregorian Calendar date and time into the Julian date
• DTOJ - Converts an AutoCAD formatted calendar date and time into the Julian date
• JTOC - Converts a Julian date to a list that contains a Gregorian Calendar date and time
• JTOD - Converts a Julian date to an AutoCAD formatted calendar date and time
• JTOW - Returns the day of the week based on the specified Julian day

Command: (jtoc (getvar "date"))
(2017 2 22 9 21 27.0)

Command: (rtos (jtod (getvar "date")) 2 6)
"20170222.092127"

Since the AutoLISP functions are defined in a LSP file and that LSP file is not compiled, it is possible to open the Julian.lsp file and see how the functions were written.

Converting a Julian Date to  A Gregorian Calendar Date with AutoLISP

While the functions defined in the Express Tools are great, there is one downside to them and that is they are only available when the Express Tools are installed.  This code sample demonstrates how to take the Julian Date from the DATE system variable and convert that value into the equivalent value returned by the CDATE system variable:

; Converts a Modified Julian Date to the same output as CDATE
; Usage: (Julian2DateTime (getvar "DATE"))
(defun Julian2DateTime (julianTime / jDate jTime AA BB CC DD
                                     EE FF GG Y N D HH MM SS)
  ; Break the real number into its integer and fractional parts
  ; Time is based on a fraction of a day, so multiplying that fraction
  ; by 86,400 gives you the number of seconds that have passed
  (setq jDate (fix julianTime)
        jTime (* 86400.0 (- julianTime jDate)))

  ; Calculate the Gregorian date from the Modified Julian Date
  ; based on the whole number
  (setq AA (+ jDate 68569))
  (setq BB (/ (* 4 AA) 146097))
  (setq CC (- AA (/ (+ (* 146097 BB) 3) 4)))
  (setq DD (/ (* 4000 (+ CC 1)) 1461001))
  (setq EE (+ (- CC (/ (* 1461 DD) 4)) 31))
  (setq FF (/ (* 80 EE) 2447))
  (setq GG (/ FF 11))

  ; Year
  (setq Y (+ (* 100 (- BB 49)) DD GG))
  ; Month
  (setq M (* (- (+ FF 2) 12) GG))
  ; Date
  (setq D (- EE (/ (* 2447 FF) 80)))

  ; Calculate the time from the decimal value of the Modified Julian Date
  ; Hours
  (setq HH (fix (/ jTime 3600.0)))
  (setq jTime (- jTime (* HH 3600.0)))
  ; Minutes
  (setq MM (fix (/ jTime 60.0)))
  ; Seconds
  (setq SS (fix (- jTime (* MM 60))))

  ; Output the date as a string in the YYYYMMDD.HHMMSS format to match CDATE
  (strcat (itoa Y)
   (if (> M 10)(itoa M)(strcat "0" (itoa M)))
   (if (> D 10)(itoa D)(strcat "0" (itoa D)))
          "."
   (if (> HH 10)(itoa HH)(strcat "0" (itoa HH)))
   (if (> MM 10)(itoa MM)(strcat "0" (itoa MM)))
   (if (> SS 10)(itoa SS)(strcat "0" (itoa SS)))
  )
)

The output that is generated from the Julian2DateTime function will look similar to the following:

(Julian2DateTime (getvar "DATE"))
"20170222.093707"

(Julian2DateTime (getvar "TDCREATE"))
"20170222.090846"

Hope this article gives you a better understanding of how the value of the DATE system variable can be used to get and format the current date with AutoLISP.

Other related articles:

• Getting the Current Date/Time with AutoLISP - Part 1
• PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?
• PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Sincerely,
  Lee

PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Recently, I mentioned that the CDATE and DATE system variables no longer store time down to milliseconds. In addition to those system variables, the following system variables are now accurate to the nearest second starting with AutoCAD 2017, whereas earlier releases they included milliseconds :

• TDCREATE
• TDINDWG
• TDUCREATE
• TDUPDATE
• TDUSRTIMER
• TDUUPDATE

Any scripts or custom programs that use these system variables should be verified that they work properly with AutoCAD 2017.  In most cases, the scripts and custom programs should work as expected with the exception of the milliseconds part of the time value being returned.  In most cases, milliseconds is now returned as "000" or a similar value that is not as accurate as AutoCAD 2016 and earlier.

The following article is also related to the CDATE and DATE system variables:

• Getting the Current Date/Time with AutoLISP - Part 1
• Getting the Current Date/Time with AutoLISP - Part 2
• PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?

Sincerely,
  Lee

PSA: Be On the Look Out for Usage of the Quick and QUI Object Snap Modes in Scripts and Custom Programs

Upgrading from AutoCAD 2015 or earlier to AutoCAD 2016 or AutoCAD 2017?

If you are in the process of upgrading to a recent release of an AutoCAD-based product, you will want to check the scripts, action macros, and custom programs that you use for any usage of the -OSNAP command, OSMODE system variable, or AutoLISP OSNAP function.  Starting with AutoCAD 2016, the Quick object snap or 'qui' mode is no longer supported and result in unexpected behavior if used.

-OSNAP Command

When the Quick object snap is used with the -OSNAP command in AutoCAD 2016 and later, the Invalid object snap modes. error message is displayed along with the command re-prompting for a valid list of object snaps again.  The prompt being displayed again could cause potential problems with future commands, keywords, and values in the script or custom program.

Command: -OSNAP
Current osnap modes: End,Cen,Int,Ext
Enter list of object snap modes: QUI,END
Invalid object snap modes.
Enter list of object snap modes:

Solution: Remove QUI from the list of object snaps passed to the -OSNAP command, and then retest the affected scripts and custom programs.

OSMODE System Variable

Starting with AutoCAD 2016, the bitcode value of 1024 no longer represents the Quick object snap but rather the Geometric Center object snap.  Since the 1024 bitcode value was repurposed, any script or custom program that expects the Quick object snap might produce unexpected results.

Solution: If your program doesn't require the Geometric Center object snap, you might want to remove the 1024 bitcode value from the sum that is being assigned to the OSMODE system variable as part of the script or custom program.  Once the value has been changed or a decision is to leave it unchanged is made, be sure to test the script or custom program to ensure it is working as expected.

AutoLISP OSNAP Function

The AutoLISP OSNAP function returns a list representing a 3D point or a nil value based on the provided point and comma-delimited string that represents the object snap modes to use.  The 3D point returned is calculated based on the objects near the point provided and within the area of the aperture box along with the object snap modes listed, nil is returned if no point could be calculated based on the lack of objects within the aperture box or none of the object snap modes listed being valid for the objects in the aperture box. If the '_qui' object snap mode is specified in a program that is executed by AutoCAD 2016 or later, the point returned will always be nil since the object snap no longer exists.

Solution: Remove qui or _qui from the comma-delimited string that represents the list of object snap modes to be passed to the OSNAP function.  After the object snap mode has been removed, retest the affected custom program.

Hope you found the information in this article useful.

Sincerely,
  Lee

PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?

In AutoCAD 2017-based products, the CDATE and DATE system variables no longer store the current time down to the current millisecond which if you are getting the current date or time might not be a deal breaker for your custom programs.  However, the CDATE system variables are also used to determine how long it takes for a custom program to run or to generate unique block names/entries in a log file.

If you are using these system variables, make sure your programs don't rely on time intervals as small as milliseconds.  If your custom programs do rely on milliseconds, chances are your custom programs might not be functioning as expected or could be taking longer than they did in previous releases if you are using a loop to wait for a detectable time change.

When working with time intervals as small as milliseconds, consider looking at the MILLISECS system variable.  The MILLISECS system variable returns the time difference in which the workstation was booted until now in milliseconds.  Using the MILLISECS system variable, you could get the last 2 or 3 digits of the value and append them to the value returned by the CDATE system variable if you want a value that is comparable to that returned in AutoCAD 2016-based products and earlier.  However, if you are just tracking time differences, you might just want to migrate to using the MILLISECS system variable instead of the CDATE system variable.

Sample Code

The following is an example of a custom function named CDATE that returns the values of the MILLISECS and CDATE system variables based on the release of AutoCAD being used.  The function returns the value of the CDATE system variable when executed on AutoCAD 2016-based products and earlier, and returns a value that combines the values of the CDATE and MILLISECS system variables when executed on AutoCAD 2017.

; Returns a CDATE value that includes milliseconds based on release
; Usage: (CDate)
; Replaces (rtos (getvar "CDATE") 2 8)
(defun CDate ( / ms)
  ; Check to see which AutoCAd release is being used
  (if (< (atof (getvar "ACADVER")) 21.0)
    (rtos (getvar "CDATE") 2 8)
    (progn
      ; Get the current milliseconds and append it to the CDATE value
      (setq ms (itoa (getvar "MILLISECS")))
      (strcat (rtos (getvar "CDATE") 2 6)(substr ms (- (strlen ms) 2)))
    )
  )
)

Hope this helps you understand what might need to be changed with your custom programs and how you might go about making the change.

Other related articles:

• Getting the Current Date/Time with AutoLISP - Part 1
• Getting the Current Date/Time with AutoLISP - Part 2
• PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Sincerely,
  Lee

Getting the Current Date/Time with AutoLISP - Part 1

Needing to populate a title block or stamp a drawing with the current date/time is a very common task in the AutoCAD product along with determining the time it might have taken to execute a custom program for return of investment (ROI) analysis.  AutoCAD-based products support several system variables that can be used to determine the current date/time, these system variables are:

• CDATE - Stores the current date and time as a decimal value.
• DATE - Stores the current date and time in Modified Julian Date format.
• MILLISECS - Stores the current number of milliseconds since the computer was booted.

NOTE: Starting with AutoCAD 2017, the CDATE and DATE system variables no longer store the current time down to milliseconds.

CDATE System Variable

The CDATE system variable is the most common approach to getting the current date and time within the AutoCAD environment while using AutoLISP.  When queried, the CDATE system variable returns a value as a real number.  The GETVAR function is used to return the value of a system variable for use with the AutoLISP programming language.

Here is an example of getting the value stored in the CDATE system variable:

Command: (getvar "CDATE")
2.01702e+07

As previously mentioned, the value of the CDATE system variable is a real number.  By default, it isn't possible to see the full value of the CDATE system variable without a bit of extra help.  It is best to convert the real number to a string, so you can see and work with the full value which can be accomplished using the RTOS function.  The RTOS function accepts 3 arguments, the real number to convert to a string and two optional arguments which represent the linear unit mode and precision in which the value should be formatted.

Here is an example of converting the value stored in the CDATE system variable to a string that represents the real value as a decimal with a precision of 6:

Command: (rtos (getvar "CDATE") 2 6)
"20170214.090919"

NOTE: Prior to AutoCAD 2017-based products, using a precision of 8 would include milliseconds.  Starting with AutoCAD 2017-based products, the last two places that represent milliseconds are returned as "00".

The string returned by the RTOS function in the previous example allows you to see the full real number.  The whole number prior to the decimal represents the current date while the fraction represents the current time.

Date - 20170214
Time - 090919

Year - 2017
Month - 02
Date - 14

Hours - 09
Minutes - 09
Seconds - 19

Formatting the CDATE Value with AutoLISP

This code sample demonstrates how to pull the string apart that is returned by the RTOS function into the current Month, Day, Year, Hours, Minutes, and Seconds:

; Prints or outputs the current date and time
; bOutput = T - Output the string to the Command prompt
; bOutput = nil - Return a formatted string MM/DD/YYYY  HH:MM:SS
; Usage: (CurDate T)
; Usage: (CurDate nil)
(defun CurDate (bOuput / cdate_val YYYY M D HH MM SS)
  ; Get the current date/time
  (setq cdate_val (rtos (getvar "CDATE") 2 6))

  ; Break up the string into its separate parts
  (setq YYYY (substr cdate_val 1 4)
        M    (substr cdate_val 5 2)
        D    (substr cdate_val 7 2)
        HH   (substr cdate_val 10 2)
        MM   (substr cdate_val 12 2)
        SS   (substr cdate_val 14 2)
  )

  ; Output the current date and time to the Command
  ; prompt or return the formatted output as a string
  (if bOuput
    (progn
      (prompt (strcat "\nDate: " M "/" D "/" YYYY
                      "\nTime: " HH ":" MM ":" SS
              )
      )
      (princ)
    )
    (strcat M "/" D "/" YYYY "  " HH ":" MM ":" SS)
  )
)

The output that is generated from the CurDate function will look similar to the following:

(CurDate T)

Date: 02/14/2017
Time: 14:38:57

(CurDate nil)

"02/14/2017  14:39:04"

Hope this article gives you a better understanding of how the value of the CDATE system variable can be used to get and format the current date with AutoLISP.

Other related articles:

• Getting the Current Date/Time with AutoLISP - Part 2
• PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?
• PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Sincerely,
  Lee

(Updated) Splitting A String Into A List of Elements Based on Delimiter

Update - Sample code was revised to include some additional error handling and return some basic error messages in the case of nil being passed to the function.

When working with file paths in AutoCAD, it is common that you might need to work with a string that contains multiple paths that are separated by a delimiter.  Commonly, the delimiter used to separate one path from another is a semi-colon (;).

The ACADPREFIX system variable returns a string that contains a listing of all the AutoCAD support paths.

(getvar "acadprefix")

"C:\Users\ambrosl\appdata\roaming\autodesk\autocad 2017\r21.0\enu\support;C:\program files\autodesk\autocad 2017\support;C:\program files\autodesk\autocad 2017\support\en-us;C:\program files\autodesk\autocad 2017\fonts;C:\program files\autodesk\autocad 2017\help;C:\program files\autodesk\autocad 2017\express;C:\program files\autodesk\autocad 2017\support\color;C:\Program Files\Autodesk\AutoCAD 2017\drv;"

The following code defines a function named SPLIT which breaks up a string into elements with in a list based on the delimiter specified:

;; Usage: (split (getvar "acadprefix") ";")

(defun split (sExpression sDelimiter / len val sList)
  (if (and (= (type sExpression) 'STR) (= (type sDelimiter) 'STR))
    (progn
      ; Get the length of the first item from the expression based
      ; on delimiter position
      (setq len (vl-string-position (ascii sDelimiter) sExpression))

      ; Loop until there are no more instances of the delimiter
      ; in the expression
      (while (numberp len)
        ; Get the item from the expression
        (setq val (substr sExpression 1 len))

        ; Append the item to the list
        (setq sList (cons val sList))

        ; Get the remaining part of the expression
        (setq sExpression (substr sExpression (+ 2 len)))

        ; Get the length of the next item from the string based
        ; on delimiter position
        (setq len (vl-string-position (ascii sDelimiter) sExpression))
      )

      ; Add the last value to the list
      (if (/= sExpression nil)
        (setq sList (cons sExpression sList))
      )

      ; Reverses the elements in the list and return the list
      (reverse sList)
    )
    (progn
      (if (not (= (type sExpression) 'STR))
        (prompt "\nSplit Error: First argument must be the string to split.")
      )
      (if (not (= (type sDelimiter) 'STR))
        (prompt "\nSplit Error: Second argument must be the character that represents the delimiter to use.")
      )
      (princ)
    )
  )
)

The results of using the SPLIT function on the ACADPREFIX system variable is as follows:

(split (getvar "acadprefix") ";") 

("C:\\Users\\ambrosl\\appdata\\roaming\\autodesk\\autocad 2017\\r21.0\\enu\\support" "C:\\program files\\autodesk\\autocad 2017\\support" "C:\\program files\\autodesk\\autocad 2017\\support\\en-us" "C:\\program files\\autodesk\\autocad 2017\\fonts" "C:\\program files\\autodesk\\autocad 2017\\help" "C:\\program files\\autodesk\\autocad 2017\\express" "C:\\program files\\autodesk\\autocad 2017\\support\\color" "C:\\Program Files\\Autodesk\\AutoCAD 2017\\drv" "")

The SPLIT function can also be used to separate the name of an Xref from a named style or layer name.

For example, Grid Plan|Architectural_Plan_Dim is the layer name created in a host drawing after the drawing file named Grid Plan is attached and that drawing that contains a layer named Architectural_Plan_Dim. The pipe (|) character is used to separate the Xref name from the layer name.

(split "Grid Plan|Architectural_Plan_Dim" "|")
("Grid Plan" "Architectural_Plan_Dim")

Sincerely,
  Lee