221 lines
7.9 KiB
Plaintext
221 lines
7.9 KiB
Plaintext
;; Function To Be Tested: . (MASTERSCOPE) (Program Analysis)
|
|
;;
|
|
;; Source: Lyric Release Overview (Lyric Beta Release)
|
|
;; Section 19 (Masterscope), Page 22
|
|
;; Section: Program Analysis
|
|
;;
|
|
;; Created By: John Park
|
|
;;
|
|
;; Creation Date: Feb 25, 1987
|
|
;;
|
|
;; Last Update: March 26, 1987
|
|
;;
|
|
;; Massively munged by Rene P. S. Bane June 24, 1988
|
|
;;
|
|
;; Filed As: {ERIS}<lispcore>test>program-analysis>masterscope.u
|
|
;;
|
|
;;
|
|
;; Syntax: . &rest LINE
|
|
;;
|
|
;; Function Description: Make a MASTERSCOPE query. Masterscope is an interactive
|
|
;; program for analyzing and cross referencing user programs. It contains
|
|
;; facilities for analyzing user functions to determine what other functions are
|
|
;; called, how and where variables are bound, set, or referenced, as well as
|
|
;; which functions use particular record declarations. Masterscope is able to
|
|
;; analyze definitions directly from a file as well as in-core definitions.
|
|
;; This test is almost identical to the masterscope as an exec command, which is
|
|
;; located in {eris}<lispcore>test>exec>masterscope.u
|
|
;;
|
|
;; Argument(s): Masterscope commands (SEE IRM, Vol 3, Section 19)
|
|
;;
|
|
;; Returns: (SEE IRM, Vol 3, Section 19)
|
|
;;
|
|
;; Constraints/Limitations: Due to the nature of Programmer's Assistant commands,
|
|
;; testing them will be performed using do-test and the interlisp function bksysfuf.
|
|
;; Comments or messages are incorporated within
|
|
;; each command file, which will be run by using the function bksysbuf.
|
|
;; Each test setup is titled "MASTERSCOPE-TEST-SETUP", which executes the command
|
|
;; string. The do-test form within the command file will return T or "test
|
|
;; failed" This test file requires TEDIT and MASTERSCOPE package
|
|
;; The tree structure of the functions being analyzed are as follows:
|
|
;;
|
|
;; Top-Funtion
|
|
;; |
|
|
;; Fun-A------------------------Fun-B
|
|
;; | |
|
|
;; --------------------- --------------------
|
|
;; | | | | | |
|
|
;; Fun-A1 Fun-A2 Fun-A3 Fun-B1 Fun-B2 Fun-B3
|
|
;; |
|
|
;; --------------
|
|
;; | |
|
|
;; Fun-C1 Fun-A1
|
|
;;
|
|
;; Messages will be printed before each command in the command files is executed
|
|
;; for user monitoring. Test result is logged on
|
|
;; {eris}<lispcore>test>program-analysis>masterscope.report
|
|
|
|
(DO-TEST "MASTERSCOPE-TEST-SETUP"
|
|
;; If the browser is already loaded, undo what the browser did so this testfile
|
|
;; will work properly, then redo it. This is relying on the browser to always
|
|
;; affect MSPATHS, because there is no official way of undoing the browser
|
|
;; (that I know of)
|
|
(IL:IF (IL:GETD 'IL:OLDMSPATHS)
|
|
IL:THEN
|
|
(IL:MOVD 'IL:MSPATHS 'TMP-MSPATHS)
|
|
(IL:MOVD 'IL:OLDMSPATHS 'IL:MSPATHS))
|
|
(SETQ TEST-SUCCEEDED T)
|
|
(DEFUN PASS-FAIL (COMMAND-LANGUAGE TEST-ITEM)
|
|
(IL:IF (NOT TEST-ITEM)
|
|
IL:THEN (FORMAT *ERROR-OUTPUT* "Test ~s failed~%" COMMAND-LANGUAGE)
|
|
(SETQ TEST-SUCCEEDED NIL) (BREAK "Argh!")
|
|
IL:ELSE "Hey, no problem!"))
|
|
|
|
; Reinitialize and Define functions to be analyzed
|
|
(IL:MASTERSCOPE '(ERASE))
|
|
(DEFUN TOP-FUNTION NIL (AND (FUN-A) (FUN-B)))
|
|
(DEFUN FUN-A NIL (OR (FUN-A1) (FUN-A2) (FUN-A3)))
|
|
(DEFUN FUN-B NIL (OR (FUN-B1) (FUN-B2) (FUN-B3)))
|
|
(DEFUN FUN-A1 NIL T)
|
|
(DEFUN FUN-A2 NIL NIL)
|
|
(DEFUN FUN-A3 NIL T)
|
|
(DEFUN FUN-B1 NIL (AND (FUN-C1)(FUN-A1)))
|
|
(DEFUN FUN-B2 NIL NIL)
|
|
(DEFUN FUN-B3 NIL T)
|
|
(DEFUN FUN-C1 NIL NIL)
|
|
; Start analyzing functions in top-function
|
|
(IL:MASTERSCOPE '(ANALYZE TOP-FUNTION))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-A))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-B))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-B1))
|
|
|
|
(PASS-FAIL "Who calls FUN-A1" (NOT (SET-EXCLUSIVE-OR (IL:MASTERSCOPE '(WHO CALLS FUN-A1)) '(FUN-A FUN-B1))))
|
|
|
|
(PASS-FAIL "Who calls TOP-FUNTION" (NOT (IL:MASTERSCOPE '(WHO CALLS TOP-FUNTION))))
|
|
|
|
(PASS-FAIL "Who calls FUN-A" (NOT (SET-EXCLUSIVE-OR (IL:MASTERSCOPE '(WHO CALLS FUN-A)) '(TOP-FUNTION))))
|
|
|
|
(PASS-FAIL "Who calls FUN-B2" (NOT (SET-EXCLUSIVE-OR (IL:MASTERSCOPE '(WHO CALLS FUN-B2)) '(FUN-B))))
|
|
|
|
(DRIBBLE '{CORE}WHO-CALLS)
|
|
(IL:MASTERSCOPE '(WHO CALLS WHO))
|
|
(DRIBBLE)
|
|
|
|
(DRIBBLE '{CORE}PATHS)
|
|
(IL:MASTERSCOPE '(SHOW PATHS TO FUN-A1 FROM TOP-FUNTION))
|
|
(DRIBBLE)
|
|
|
|
; ERASE (erase all information about the functions in SET from the database)
|
|
(IL:MASTERSCOPE '(ERASE))
|
|
|
|
(PASS-FAIL "All info erased" (NOT (OR (IL:MASTERSCOPE '(WHO CALLS FUN-A))
|
|
(IL:MASTERSCOPE '(WHO CALLS FUN-B1))
|
|
(IL:MASTERSCOPE '(WHO CALLS FUN-B2))
|
|
)))
|
|
|
|
; REANALYZE (causes masterscope to reanalyze the functions in SET)
|
|
(IL:MASTERSCOPE '(ANALYZE TOP-FUNTION))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-A))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-B))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-B1))
|
|
(IL:MASTERSCOPE '(ERASE FUN-A))
|
|
(IL:MASTERSCOPE '(REANALYZE FUN-A))
|
|
|
|
(PASS-FAIL "Reanalyzing" (NOT (SET-EXCLUSIVE-OR (IL:MASTERSCOPE '(WHO CALLS FUN-A1)) '(FUN-A FUN-B1))))
|
|
|
|
(IL:MASTERSCOPE '(ERASE))
|
|
|
|
(PASS-FAIL "Called-by (reanalyzing too)" (NOT (SET-EXCLUSIVE-OR (IL:MASTERSCOPE '(WHO IS CALLED BY TOP-FUNTION)) '(FUN-A FUN-B))))
|
|
|
|
|
|
; DESCRIBE SET (prints out the bind, use freely and call information)
|
|
|
|
(DEFUN FUN-DESCRIBE (X Y) (SETQ X1 (1+ X)) (SETQ Y1 (1- Y)))
|
|
(IL:MASTERSCOPE '(ANALYZE FUN-DESCRIBE))
|
|
(DRIBBLE '{CORE}DESCRIBE)
|
|
(IL:MASTERSCOPE '(DESCRIBE FUN-DESCRIBE))
|
|
(DRIBBLE)
|
|
(IL:MASTERSCOPE '(ERASE))
|
|
; analyzing the file that contains hopefully correct results
|
|
(SETQ DESCRIBE-FLG NIL)
|
|
(SETQ DESCRIBE-FILE (OPEN "{CORE}DESCRIBE"))
|
|
|
|
;; Yeeuck. Awful test, relies on Masterscope returning exactly the characters
|
|
;; expected. At least now it doesn't require the exact number of spaces....Rene
|
|
;; p.s. premature EOF will return a NIL, so that will count as failure as well.
|
|
(LET (NEXT-LINE)
|
|
(IL:WHILE (AND (NOT (EQ 'EOF
|
|
(SETQ NEXT-LINE (READ-LINE DESCRIBE-FILE NIL 'EOF))))
|
|
(NOT (SEARCH "calls" NEXT-LINE :TEST #'STRING-EQUAL))))
|
|
(PASS-FAIL "Describe"
|
|
(AND (STRING-EQUAL "calls:1+,1-" (DELETE #\Space NEXT-LINE))
|
|
(STRING-EQUAL "binds:X,Y" (DELETE #\Space (READ-LINE DESCRIBE-FILE NIL NIL)))
|
|
(STRING-EQUAL "usesfree:Y1,X1" (DELETE #\Space (READ-LINE DESCRIBE-FILE NIL NIL)))
|
|
))
|
|
) ; close let
|
|
|
|
|
|
(CLOSE DESCRIBE-FILE)
|
|
(DELETE-FILE "{CORE}DESCRIBE")
|
|
|
|
; analyzing the file that contains the previous masterscope interactions
|
|
; (who calls?)
|
|
|
|
(SETQ WHO-CALLS (OPEN "{CORE}WHO-CALLS"))
|
|
;; Another test which replaces the previous "throw away the first three lines
|
|
;; no matter what" and ignores spaces. See comment for the DESCRIBE test. There
|
|
;; MUST be a better way! And >>I<< didn't spell "funtion" that way....Rene
|
|
;; JRB - a feature of who calls who is that the order in which the calling information
|
|
;; comes out is dependent on the order things got analyzed in. Things get reanalyzed
|
|
;; by Masterscope itself all the time, in whatever order Masterscope feels like doing it.
|
|
;; What you really have to do here is suck in all the lines and do a SET-EXCLUSIVE-OR
|
|
;; between two lists of strings; yuck**2.
|
|
(LET (ALL-LINES NEXT-LINE)
|
|
;; First suck in the lines
|
|
(IL:WHILE (NOT (EQ 'EOF (SETQ NEXT-LINE (READ-LINE WHO-CALLS NIL 'EOF))))
|
|
IL:DO (PUSH (DELETE #\Space NEXT-LINE) ALL-LINES))
|
|
;; Then compare them
|
|
(PASS-FAIL "Who calls...? (analyzing)"
|
|
(NOT (SET-EXCLUSIVE-OR ALL-LINES
|
|
'("top-funtion--(fun-afun-b)"
|
|
"FUN-B1--(FUN-C1FUN-A1)"
|
|
"FUN-B--(FUN-B1FUN-B2FUN-B3)"
|
|
"FUN-A--(FUN-A1FUN-A2FUN-A3)")
|
|
:TEST #'STRING-EQUAL))))
|
|
|
|
(CLOSE WHO-CALLS)
|
|
(DELETE-FILE "{CORE}WHO-CALLS")
|
|
|
|
; analyzing the file that contains the masterscope interaction (show paths)
|
|
(SETQ PATHS (OPEN "{CORE}PATHS"))
|
|
|
|
(LET (NEXT-LINE)
|
|
(IL:WHILE (AND (NOT (EQ 'EOF
|
|
(SETQ NEXT-LINE (READ-LINE PATHS NIL 'EOF))))
|
|
(NOT (SEARCH "top-funtion" NEXT-LINE :TEST #'STRING-EQUAL))))
|
|
(PASS-FAIL "Show paths (would-be graph)"
|
|
(AND
|
|
|
|
(STRING-EQUAL "1.FUN-A1FUN-ATOP-FUNTION" (DELETE #\Space NEXT-LINE))
|
|
(STRING-EQUAL "2.FUN-B1FUN-BTOP-FUNTION" (DELETE #\Space (READ-LINE PATHS NIL NIL)))
|
|
))
|
|
) ; close let
|
|
|
|
|
|
(CLOSE PATHS)
|
|
(DELETE-FILE "{CORE}PATHS")
|
|
|
|
;; if the browser was loaded, reset MSPATHS so it looks loaded again
|
|
(IL:IF (IL:GETD 'OLDMSPATHS)
|
|
IL:THEN (IL:MOVD 'TMP-MSPATHS 'IL:MSPATHS))
|
|
|
|
TEST-SUCCEEDED
|
|
|
|
)
|
|
|
|
STOP
|
|
|
|
|
|
|
|
|