Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

# -*- coding: iso-8859-1 -*- 

"""A lexical analyzer class for simple shell-like syntaxes.""" 

 

# Module and documentation by Eric S. Raymond, 21 Dec 1998 

# Input stacking and error message cleanup added by ESR, March 2000 

# push_source() and pop_source() made explicit by ESR, January 2001. 

# Posix compliance, split(), string arguments, and 

# iterator interface by Gustavo Niemeyer, April 2003. 

 

import os.path 

import sys 

from collections import deque 

 

try: 

    from cStringIO import StringIO 

except ImportError: 

    from StringIO import StringIO 

 

__all__ = ["shlex", "split"] 

 

class shlex: 

    "A lexical analyzer class for simple shell-like syntaxes." 

    def __init__(self, instream=None, infile=None, posix=False): 

        if isinstance(instream, basestring): 

            instream = StringIO(instream) 

        if instream is not None: 

            self.instream = instream 

            self.infile = infile 

        else: 

            self.instream = sys.stdin 

            self.infile = None 

        self.posix = posix 

        if posix: 

            self.eof = None 

        else: 

            self.eof = '' 

        self.commenters = '#' 

        self.wordchars = ('abcdfeghijklmnopqrstuvwxyz' 

                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_') 

        if self.posix: 

            self.wordchars += ('ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ' 

                               'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ') 

        self.whitespace = ' \t\r\n' 

        self.whitespace_split = False 

        self.quotes = '\'"' 

        self.escape = '\\' 

        self.escapedquotes = '"' 

        self.state = ' ' 

        self.pushback = deque() 

        self.lineno = 1 

        self.debug = 0 

        self.token = '' 

        self.filestack = deque() 

        self.source = None 

        if self.debug: 

            print 'shlex: reading from %s, line %d' \ 

                  % (self.instream, self.lineno) 

 

    def push_token(self, tok): 

        "Push a token onto the stack popped by the get_token method" 

        if self.debug >= 1: 

            print "shlex: pushing token " + repr(tok) 

        self.pushback.appendleft(tok) 

 

    def push_source(self, newstream, newfile=None): 

        "Push an input source onto the lexer's input source stack." 

        if isinstance(newstream, basestring): 

            newstream = StringIO(newstream) 

        self.filestack.appendleft((self.infile, self.instream, self.lineno)) 

        self.infile = newfile 

        self.instream = newstream 

        self.lineno = 1 

        if self.debug: 

            if newfile is not None: 

                print 'shlex: pushing to file %s' % (self.infile,) 

            else: 

                print 'shlex: pushing to stream %s' % (self.instream,) 

 

    def pop_source(self): 

        "Pop the input source stack." 

        self.instream.close() 

        (self.infile, self.instream, self.lineno) = self.filestack.popleft() 

        if self.debug: 

            print 'shlex: popping to %s, line %d' \ 

                  % (self.instream, self.lineno) 

        self.state = ' ' 

 

    def get_token(self): 

        "Get a token from the input stream (or from stack if it's nonempty)" 

        if self.pushback: 

            tok = self.pushback.popleft() 

            if self.debug >= 1: 

                print "shlex: popping token " + repr(tok) 

            return tok 

        # No pushback.  Get a token. 

        raw = self.read_token() 

        # Handle inclusions 

        if self.source is not None: 

            while raw == self.source: 

                spec = self.sourcehook(self.read_token()) 

                if spec: 

                    (newfile, newstream) = spec 

                    self.push_source(newstream, newfile) 

                raw = self.get_token() 

        # Maybe we got EOF instead? 

        while raw == self.eof: 

            if not self.filestack: 

                return self.eof 

            else: 

                self.pop_source() 

                raw = self.get_token() 

        # Neither inclusion nor EOF 

        if self.debug >= 1: 

            if raw != self.eof: 

                print "shlex: token=" + repr(raw) 

            else: 

                print "shlex: token=EOF" 

        return raw 

 

    def read_token(self): 

        quoted = False 

        escapedstate = ' ' 

        while True: 

            nextchar = self.instream.read(1) 

            if nextchar == '\n': 

                self.lineno = self.lineno + 1 

            if self.debug >= 3: 

                print "shlex: in state", repr(self.state), \ 

                      "I see character:", repr(nextchar) 

            if self.state is None: 

                self.token = ''        # past end of file 

                break 

            elif self.state == ' ': 

                if not nextchar: 

                    self.state = None  # end of file 

                    break 

                elif nextchar in self.whitespace: 

                    if self.debug >= 2: 

                        print "shlex: I see whitespace in whitespace state" 

                    if self.token or (self.posix and quoted): 

                        break   # emit current token 

                    else: 

                        continue 

                elif nextchar in self.commenters: 

                    self.instream.readline() 

                    self.lineno = self.lineno + 1 

                elif self.posix and nextchar in self.escape: 

                    escapedstate = 'a' 

                    self.state = nextchar 

                elif nextchar in self.wordchars: 

                    self.token = nextchar 

                    self.state = 'a' 

                elif nextchar in self.quotes: 

                    if not self.posix: 

                        self.token = nextchar 

                    self.state = nextchar 

                elif self.whitespace_split: 

                    self.token = nextchar 

                    self.state = 'a' 

                else: 

                    self.token = nextchar 

                    if self.token or (self.posix and quoted): 

                        break   # emit current token 

                    else: 

                        continue 

            elif self.state in self.quotes: 

                quoted = True 

                if not nextchar:      # end of file 

                    if self.debug >= 2: 

                        print "shlex: I see EOF in quotes state" 

                    # XXX what error should be raised here? 

                    raise ValueError, "No closing quotation" 

                if nextchar == self.state: 

                    if not self.posix: 

                        self.token = self.token + nextchar 

                        self.state = ' ' 

                        break 

                    else: 

                        self.state = 'a' 

                elif self.posix and nextchar in self.escape and \ 

                     self.state in self.escapedquotes: 

                    escapedstate = self.state 

                    self.state = nextchar 

                else: 

                    self.token = self.token + nextchar 

            elif self.state in self.escape: 

                if not nextchar:      # end of file 

                    if self.debug >= 2: 

                        print "shlex: I see EOF in escape state" 

                    # XXX what error should be raised here? 

                    raise ValueError, "No escaped character" 

                # In posix shells, only the quote itself or the escape 

                # character may be escaped within quotes. 

                if escapedstate in self.quotes and \ 

                   nextchar != self.state and nextchar != escapedstate: 

                    self.token = self.token + self.state 

                self.token = self.token + nextchar 

                self.state = escapedstate 

            elif self.state == 'a': 

                if not nextchar: 

                    self.state = None   # end of file 

                    break 

                elif nextchar in self.whitespace: 

                    if self.debug >= 2: 

                        print "shlex: I see whitespace in word state" 

                    self.state = ' ' 

                    if self.token or (self.posix and quoted): 

                        break   # emit current token 

                    else: 

                        continue 

                elif nextchar in self.commenters: 

                    self.instream.readline() 

                    self.lineno = self.lineno + 1 

                    if self.posix: 

                        self.state = ' ' 

                        if self.token or (self.posix and quoted): 

                            break   # emit current token 

                        else: 

                            continue 

                elif self.posix and nextchar in self.quotes: 

                    self.state = nextchar 

                elif self.posix and nextchar in self.escape: 

                    escapedstate = 'a' 

                    self.state = nextchar 

                elif nextchar in self.wordchars or nextchar in self.quotes \ 

                    or self.whitespace_split: 

                    self.token = self.token + nextchar 

                else: 

                    self.pushback.appendleft(nextchar) 

                    if self.debug >= 2: 

                        print "shlex: I see punctuation in word state" 

                    self.state = ' ' 

                    if self.token: 

                        break   # emit current token 

                    else: 

                        continue 

        result = self.token 

        self.token = '' 

        if self.posix and not quoted and result == '': 

            result = None 

        if self.debug > 1: 

            if result: 

                print "shlex: raw token=" + repr(result) 

            else: 

                print "shlex: raw token=EOF" 

        return result 

 

    def sourcehook(self, newfile): 

        "Hook called on a filename to be sourced." 

        if newfile[0] == '"': 

            newfile = newfile[1:-1] 

        # This implements cpp-like semantics for relative-path inclusion. 

        if isinstance(self.infile, basestring) and not os.path.isabs(newfile): 

            newfile = os.path.join(os.path.dirname(self.infile), newfile) 

        return (newfile, open(newfile, "r")) 

 

    def error_leader(self, infile=None, lineno=None): 

        "Emit a C-compiler-like, Emacs-friendly error-message leader." 

        if infile is None: 

            infile = self.infile 

        if lineno is None: 

            lineno = self.lineno 

        return "\"%s\", line %d: " % (infile, lineno) 

 

    def __iter__(self): 

        return self 

 

    def next(self): 

        token = self.get_token() 

        if token == self.eof: 

            raise StopIteration 

        return token 

 

def split(s, comments=False, posix=True): 

    lex = shlex(s, posix=posix) 

    lex.whitespace_split = True 

    if not comments: 

        lex.commenters = '' 

    return list(lex) 

 

if __name__ == '__main__': 

    if len(sys.argv) == 1: 

        lexer = shlex() 

    else: 

        file = sys.argv[1] 

        lexer = shlex(open(file), file) 

    while 1: 

        tt = lexer.get_token() 

        if tt: 

            print "Token: " + repr(tt) 

        else: 

            break