Question

我已经实现了一个问题，它决定了语法中的非生产性或不可访问的元素（Vn; Vt; P; S）其中Vn - 变量集合; Vt-集终端和P - 生产规则，以及S - 起始符号。

;;; Defining a grammar
(defvar *VN* '(A B C D S)) ; non-terminal variables
(defvar *VT* '(k m n)) ; terminal
(defvar *P* '((S A B) ; set of production rules
              (S C D)
              (S A k)
              (A k)
              (B m)
              (B D m D)
              (C n)))

;;; FINDING PRODUCTIVE ELEMENTS

(defun PROD-STEP (VT P PRODS)
  ;;(format t "P = ~S~%" P)
  ;;(format t "PRODS = ~S~%" PRODS)
  (if (null P)
      PRODS
      (if (subsetp (rest (first P)) (union VT PRODS))
          (PROD-STEP VT (rest P) (union (cons (first (first P)) nil) PRODS))
          (PROD-STEP VT (rest P) PRODS))))

(defun PROD-AUX (VT P PRODS oldLength)
  (if (= (length PRODS) oldLength)
      PRODS
      (PROD-AUX VT P (PROD-STEP VT P PRODS) (length PRODS))))

(defun PROD (VT P)
    (PROD-AUX VT P nil -1))

;;; END OF FINDING PROD ELEMENTS

(trace PROD-STEP)
(trace PROD-AUX)
(trace PROD)
(PROD *VT* *P*)

;;; FINDING ACCESSIBLE ELEMENTS

(defun ACCESS-STEP (P ACC)
  ;;(format t "Pacc = ~S~%" P)
  ;;(format t "ACC = ~S~%" ACC)
  (if (null P)
      ACC
      (if (member (first (first P)) ACC)
          (ACCESS-STEP (rest P) (union (rest (first P)) ACC))
          (ACCESS-STEP (rest P) ACC))))

(defun ACCESS-AUX (P ACC oldLength)
  (if (= (length ACC) oldLength)
      ACC
      (ACCESS-AUX P (ACCESS-STEP P ACC) (length ACC))))

(defun ACCESS (P S)
  ;;(format t "Paccess = ~S~%" P)
  (ACCESS-AUX P (cons S nil) 0))

 ;;; END OF FINDING ACCESSIBLE ELEMENTS

(trace ACCESS-STEP)
(trace ACCESS-AUX)
(trace ACCESS)
(ACCESS *P* 'S)

;;; REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS

(defun BuildRules-AUX (VT ACCS PRODS P newP)
  ;;(format t "newP = ~S~%" newP)
  (if (null P)
      newP
      ;; VN' = (ACCESS(G) INTERSECT PROD(G))
      ;; VT' = (VT INTERSECT ACCESS(G))
      ;; DACA REGULA ESTE A->X, A = (first (first P)) SI X = (rest (first P))
      ;; VERIFICAM DACA A APARTINE VN' SI X APARTINE (VT' UNION VN')
      (if (and (member (first (first P)) (intersection PRODS ACCS))
               (subsetp (rest (first P))
                        (union (intersection ACCS PRODS)
                               (intersection VT ACCS))))
          (BuildRules-AUX VT ACCS PRODS (rest P) (union newP 
                                                        (cons (first P) nil)))
          (BuildRules-AUX VT ACCS PRODS (rest P) newP))))

(defun BuildRules (VT ACCS PRODS P)
  (BuildRules-AUX VT ACCS PRODS P nil))

(trace BuildRules-AUX)
(trace BuildRules)

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*)*P*)

(defun SIMPL-AUX (VN VT P S ACCS PRODS)
  (setq ACCS (ACCESS P S))
  (setq PRODS (PROD VT P))
  (if (and (null (set-difference (union VN VT) ACCS))
           (null (set-difference VN PRODS)))
      (cons VN (cons VT (cons P S)))
      (SIMPL-AUX (intersection ACCS PRODS)
                 (intersection VT ACCS)
                 (BuildRules VT ACCS PRODS P)
                 S
                 ACCS
                 PRODS)))

(defun SIMPL (VN VT P S)
  (SIMPL-AUX *VN* *VT* *P* 'S nil nil))

;;; END OF REMOVING INACCESSIBLE AND NOT PRODUCTIVE ELEMENTS

;;; GETTING THE RESULTS

(SIMPL *VN* *VT* *P* 'S)

但现在我不得不得到一些中间结果。

为了提高工作效率，我很清楚我会使用PROD和ACCESS，

(PROD *VT* *P*) 
(ACCESS *P* 'S)

但我不确定如何得到一些中间结果：

非生产性
不可访问

因为我只有一个功能：

(BuildRules *VT* (ACCESS *P* 'S) (PROD *VT* *P*) *P*)

你能帮忙解决这个问题吗？

Answer 1

您只需要使用仅替换一种谓词的替换build-rules函数。顺便说一句，使用remove-if-not可以更清楚地写出来。

Lisp - 中间结果消除了语法中难以访问和非生产性的元素

1 个答案: