LISP-将语法输入转换为字符串（语言理论）

我实现了一个问题，该问题从语法（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)

程序按预期工作，这是我想问的唯一问题，如何将输入数据转换为字符串，因为我想区分“a”终端和“a”非终端

我想我应该在输入“a”、“k”、“*”和“begin”等中使用类似的东西

---

提前感谢您……

您可以使用符号：|这仍然是一个符号，保留其大小写|

---

|m和m都是符号。不同的符号。

@e20:你可以用你的语法写| m |和m。这两个都是不同的符号，它们不是相等的。我看到了读卡器表的默认设置。也就是说，

D'和

D'是相同的符号，都是大写。我需要使用\（反斜杠）或| |（围绕符号名称的管道以保留大小写）。例如.\d是小写的

d'。类似地，| d |是小写的

d'。难道你不知道在LISP中是否还有其他的解决方案吗？你总是可以使用Fortran语言。A、 B，C。。。是非终结符。终端从I，J，K开始。上帝不是终端，除非声明为终端！请