Subversion Repositories programming

Rev

Rev 163 | Rev 165 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 163 Rev 164
Line 17... Line 17...
17 
except NameError:
 17 
except NameError:
18 
  (True, False) = (1, 0)
 18 
  (True, False) = (1, 0)
19 
 
 19 
 
20 
import sys
 20 
import sys
21 
 
 21 
 
- 
 
 22 
class Queue:
- 
 
 23 
    """Implements a basic FIFO queue"""
- 
 
 24 
 
- 
 
 25 
    def __init__(self):
- 
 
 26 
        self.q = []
- 
 
 27 
 
- 
 
 28 
    def empty(self):
- 
 
 29 
        """Empty the queue"""
- 
 
 30 
        self.q = []
- 
 
 31 
 
- 
 
 32 
    def enqueue(self, elem):
- 
 
 33 
        """Enqueue an element"""
- 
 
 34 
        self.q.append(elem)
- 
 
 35 
 
- 
 
 36 
    def dequeue(self):
- 
 
 37 
        """Get the object at the front of the queue"""
- 
 
 38 
        elem = self.q[0]
- 
 
 39 
        self.q = self.q[1:]
- 
 
 40 
        return elem
- 
 
 41 
 
22 
class RecursiveDescentParser:
 42 
class RecursiveDescentParser:
23 
    def __init__(self):
 43 
    def __init__(self):
24 
        self.__clear()
 44 
        self.__clear()
25 
 
 45 
 
26 
    def __clear(self):
 46 
    def __clear(self):
Line 52... Line 72...
52 
            else:
 72 
            else:
53 
                print 'Bad Selection'
 73 
                print 'Bad Selection'
54 
                print
 74 
                print
55 
 
 75 
 
56 
    def __test_str(self):
 76 
    def __test_str(self):
57 
        print 'Parsing: %s' % (self.procE() and 'Completed' or 'Failed', )
 77 
        print 'Parsing: %s' % ((self.procE() and len(self.str) == self.strpos) and 'Completed' or 'Failed', )
58 
        print
 78 
        print
59 
 
 79 
 
60 
    def procE(self):
 80 
    def procE(self):
61 
        print 'procE(%s) ->' % (self.str[self.strpos:])
 81 
        print 'procE(%s) ->' % (self.str[self.strpos:])
62 
 
 82 
 
- 
 
 83 
        # Catch the exception generated below if we don't have enough
- 
 
 84 
        # input to 'look ahead'
- 
 
 85 
        try:
63 
        return self.procT() and self.procEprm()
 86 
            return self.procT() and self.procEprm()
- 
 
 87 
        except IndexError:
- 
 
 88 
            print 'Not enough input to continue, failed.'
- 
 
 89 
            return False
64 
 
 90 
 
65 
    def procEprm(self):
 91 
    def procEprm(self):
66 
        # Check empty str
 92 
        # Check empty str
67 
        if self.strpos >= len(self.str):
 93 
        if self.strpos >= len(self.str):
68 
            return True
 94 
            return True
Line 83... Line 109...
83 
        return True
 109 
        return True
84 
 
 110 
 
85 
    def procT(self):
 111 
    def procT(self):
86 
        print 'procT(%s) ->' % (self.str[self.strpos:])
 112 
        print 'procT(%s) ->' % (self.str[self.strpos:])
87 
 
 113 
 
88 
        return self.procF() and self.procTprm()
 114 
        return self.procP() and self.procTprm()
89 
 
 115 
 
90 
    def procTprm(self):
 116 
    def procTprm(self):
91 
        # Check empty str
 117 
        # Check empty str
92 
        if self.strpos >= len(self.str):
 118 
        if self.strpos >= len(self.str):
93 
            return True
 119 
            return True
Line 95... Line 121...
95 
        print 'procTprm(%s) ->' % (self.str[self.strpos:])
 121 
        print 'procTprm(%s) ->' % (self.str[self.strpos:])
96 
 
 122 
 
97 
        # Check *
 123 
        # Check *
98 
        if self.str[self.strpos] == '*':
 124 
        if self.str[self.strpos] == '*':
99 
            self.strpos += 1
 125 
            self.strpos += 1
100 
            return self.procF() and self.procTprm()
 126 
            return self.procP() and self.procTprm()
- 
 
 127 
 
- 
 
 128 
        # we accept empty str, so take it
- 
 
 129 
        return True
- 
 
 130 
 
- 
 
 131 
    def procP(self):
- 
 
 132 
        print 'procP(%s) ->' % (self.str[self.strpos:])
- 
 
 133 
 
- 
 
 134 
        return self.procF() and self.procPprm()
- 
 
 135 
 
- 
 
 136 
    def procPprm(self):
- 
 
 137 
        # Check empty str
- 
 
 138 
        if self.strpos >= len(self.str):
- 
 
 139 
            return True
- 
 
 140 
 
- 
 
 141 
        print 'procPprm(%s) -> ' % (self.str[self.strpos:])
- 
 
 142 
 
- 
 
 143 
        # check exp symbol
- 
 
 144 
        if self.str[self.strpos] == '^':
- 
 
 145 
            self.strpos += 1
- 
 
 146 
            return self.procF() and self.procPprm()
101 
 
 147 
 
102 
        # we accept empty str, so take it
 148 
        # we accept empty str, so take it
103 
        return True
 149 
        return True
104 
 
 150 
 
105 
    def procF(self):
 151 
    def procF(self):
Line 114... Line 160...
114 
        if self.str[self.strpos] == '(':
 160 
        if self.str[self.strpos] == '(':
115 
            self.strpos += 1
 161 
            self.strpos += 1
116 
 
 162 
 
117 
            if self.procE():
 163 
            if self.procE():
118 
                if self.str[self.strpos] == ')':
 164 
                if self.str[self.strpos] == ')':
- 
 
 165 
                    self.strpos += 1
119 
                    return True
 166 
                    return True
120 
 
 167 
 
- 
 
 168 
                return False
- 
 
 169 
 
121 
            return False
 170 
            return False
122 
 
 171 
 
123 
        # Must be a number
 172 
        # Must be a number
124 
        return self.procN()
 173 
        return self.procN()
125 
 
 174 
 
126 
    def procN(self):
 175 
    def procN(self):
127 
        print 'procN(%s) ->' % (self.str[self.strpos:])
 176 
        print 'procN(%s) ->' % (self.str[self.strpos:])
128 
 
 177 
 
129 
        if self.str[self.strpos] in '0123456789':
 178 
        if self.procD(): # we have one digit
- 
 
 179 
            if self.procD(): # two digits
130 
            self.strpos += 1
 180 
                return True
- 
 
 181 
 
131 
            return True
 182 
            return True
132 
 
 183 
 
133 
        return False
 184 
        return False
134 
 
 185 
 
135 
    def procV(self):
 186 
    def procV(self):
136 
        print 'procV(%s) ->' % (self.str[self.strpos:])
 187 
        print 'procV(%s) ->' % (self.str[self.strpos:])
137 
 
 188 
 
138 
        return self.procN()
 189 
        return self.procD()
- 
 
 190 
 
- 
 
 191 
    def procD(self):
- 
 
 192 
        print 'procD(%s) ->' % (self.str[self.strpos:])
- 
 
 193 
 
- 
 
 194 
        # Check if we are a single digit
- 
 
 195 
        if self.str[self.strpos] in '0123456789':
- 
 
 196 
            self.strpos += 1
- 
 
 197 
            return True
- 
 
 198 
 
- 
 
 199 
        return False
139 
 
 200 
 
140 
if __name__ == '__main__':
 201 
if __name__ == '__main__':
141 
    rdp = RecursiveDescentParser()
 202 
    rdp = RecursiveDescentParser()
142 
    rdp.main_menu()
 203 
    rdp.main_menu()
143 
 
 204