home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / snobol / aisnobol / ending.sno < prev    next >
Text File  |  1987-10-16  |  4KB  |  113 lines
  1. * ENDING.SNO -- SNOBOL4+ Version
  2. *
  3. * Analysis of English Endings
  4. *
  5. * SNO8OL4 implementation of flowchart on p. 74 of
  6. *     Winograd, T.  Understanding Natural Language.
  7. *           New York:  Academic Press, 1972.
  8. *
  9. *    To run:
  10. *      SNOBOL4 ENDING <ENDING.IN
  11. *
  12.  &FULLSCAN = 1
  13.  &TRIM = 1
  14.  
  15.  DEFINE('WORDEND(WORD)L,VOWEL,DOUBLE,LIQUID,NOEND')
  16.  DEFINE('MATCH(L,PAT)')
  17.  DEFINE('CUT(N)')
  18.  DEFINE('ADDON(X)')
  19.  DEFINE('TRY()')
  20.             :(WORDEND.END)
  21. *
  22. WORDEND
  23.         WRD = WORD
  24.         DOUBLE = (LEN(1) $ L) *L RPOS(0)
  25.         LIQUID = ANY("LRSVZ")
  26.         NOEND = ANY("CGSVZ")
  27.         VOWEL = ANY("AEIOUY")
  28. *
  29.         WRD
  30. +       ("N'T" | "'S" | "S'" | "S" | "LY" |
  31. +        "ING" | "ED" | "EN" | "ER" | "EST")
  32. +        $ WEND RPOS(0) =                          :F(WTRY)
  33. *
  34.         WEND POS(0) ("S" | "'S" | "S'" | "N'T") RPOS(0)
  35. +                                                 :F(WORDEND.1)
  36. *
  37.         MATCH(1,"E")                              :F(WTRY)
  38.         MATCH(2,"I") CUT(2) ADDON("Y")            :S(WTRY)
  39.         MATCH(2,"TH")                             :S(WTRY)
  40.         MATCH(2,ANY("HX")) CUT(1)                 :S(WTRY)
  41.         MATCH(2,ANY("SZ") ANY("SZ")) CUT(1)       :S(WTRY)
  42.         MATCH(2,ANY("SZ"))                        :S(WTRY)
  43.         MATCH(2,"V")                              :F(WTRY)
  44.         ~TRY() CUT(2) ADDON("FE")                 :S(WTRY)F(RETURN)
  45. *
  46. WORDEND.1
  47.         IDENT(WEND,"LY")                          :F(WORDEND.2)
  48.         MATCH(1,"I") CUT(1) ADDON("Y")            :S(WTRY)
  49.         ~TRY() ADDON("LE")                        :S(WTRY)F(RETURN)
  50. *
  51. WORDEND.2
  52.         MATCH(1,VOWEL)                            :F(WORDEND.3)
  53.         MATCH(1,"I") CUT(1) ADDON("Y")            :S(WTRY)
  54.         MATCH(1,"Y")                              :S(WTRY)
  55.         ~MATCH(1,"E") ADDON("E")                  :S(WTRY)
  56.         MATCH(2,"E")                              :S(WTRY)
  57.         ~TRY() ADDON("E")                         :S(WTRY)F(RETURN)
  58. *
  59. WORDEND.3
  60.         MATCH(1,"H")                              :F(WORDEND.4)
  61.         MATCH(2,"T")                              :F(WTRY)
  62.         ~TRY() ADDON("E")                         :S(WTRY)F(RETURN)
  63. *
  64. WORDEND.4
  65.         WRD DOUBLE                                :F(WORDEND.5)
  66.         ~MATCH(1,LIQUID) CUT(1)                   :S(WTRY)
  67.         ~TRY() CUT(1)                             :S(WTRY)F(RETURN)
  68. *
  69. WORDEND.5
  70.         MATCH(2,VOWEL)                            :S(WORDEND.6)
  71.         MATCH(1,"RL")                             :S(WTRY)
  72.         MATCH(1,LIQUID | NOEND) ADDON("E")        :(WTRY)
  73. *
  74. WORDEND.6
  75.         ~MATCH(3,VOWEL) ADDON("E")                :S(WTRY)
  76.         MATCH(1,NOEND) ADDON("E")                 :(WTRY)
  77. *
  78. WTRY    TRY()                                     :S(RETURN)F(FRETURN)
  79. *
  80. *
  81. *
  82. MATCH
  83.         WRD PAT RPOS(L - 1)                       :S(RETURN)F(FRETURN)
  84. *
  85. CUT
  86.         WRD RPOS(N) REM =                         :(RETURN)
  87. *
  88. ADDON
  89.         WRD = WRD X                               :(RETURN)
  90. *
  91. TRY
  92.         DIFFER(DICTIONARY<WRD>)                   :S(RETURN)F(FRETURN)
  93. *
  94. WORDEND.END
  95. *
  96. *
  97. * Main program starts here
  98. *
  99.  DICTIONARY = TABLE(101)
  100.  WORDS  =
  101. +     'BASH,BATHE,LEAN,LEAVE,DENT,DANCE,DOG,KISS,CURVE,'
  102. +     'CURL,ROT,ROLL,PLAY,PLY,REAL,PALE,KNIFE,PRETTY,'
  103. +     'NOBLE,PATROL,'
  104. DICT.LOOP
  105.        WORDS BREAK(',') . W LEN(1) =              :F(DICT.LOOP.END)
  106.        DICTIONARY<W> = 1                          :(DICT.LOOP)
  107. DICT.LOOP.END
  108. *
  109. READ   W = REPLACE(INPUT,&LCASE,&UCASE)           :F(END)
  110.        WORDEND(W)
  111.        OUTPUT = WRD                               :(READ)
  112. END
  113.