tools:
[dwarf-doc.git] / dwarf5 / tools / fileio.py
1 # Copyright 2012 DWARF Debugging Information Format Committee
2
3 # All the little classes used in storing latex source data.
4 # Reads in the tex source and builds internal lists of the
5 # tokenized source.  The tokenization is adequate
6 # for our purposes, but just barely adequate.
7
8 import sys
9
10 # Keep if  "k" 
11 # Otherwise delete.
12 global keepcomments
13 keepcomments = "k"
14
15 def isIdStart(c):
16   if isIndivid(c) == "y":
17     return "n"
18   if  ord(c) >= ord('a') and ord(c) <= ord('z'):
19     return "y"
20   if  ord(c) >= ord('A') and ord(c) <= ord('Z'):
21     return "y"
22   # It is tex/latex, so backslash starts a word.
23   if c == "\\":
24     return "y"
25   if c == "_":
26     return "y"
27   return "n"
28
29 def isIdNext(c):
30   if isIndivid(c) == "y":
31     return "n"
32   if  ord(c) >= ord('a') and ord(c) <= ord('z'):
33     return "y"
34   if  ord(c) >= ord('A') and ord(c) <= ord('Z'):
35     return "y"
36   if  ord(c) >= ord('0') and ord(c) <= ord('9'):
37     return "y"
38   # This is so we allow the colon in our tags
39   # Unfortunately, this gives trouble if we have a
40   # : at the end of a DW* name on input.
41   if c == ":":
42     return "y"
43   # Do not allow \ in the middle of a name.
44   if c == "\\":
45     return "n"
46   if c == "-":
47     return "y"
48   if c == "_":
49     return "y"
50   return "n"
51 def isShift(c):
52   if ord(c) >= 128:
53     return "y"
54   return "n"
55 def isIndivid(c):
56   if c == "[":
57     return "y"
58   if c == "]":
59     return "y"
60   if c == "{":
61     return "y"
62   if c == "}":
63     return "y"
64   if c == " ":
65     return "y"
66   if c == "\t":
67     return "y"
68   return "n"
69
70 # self._tex        DW\-\_ATE and the like
71 # self._underbar   DW\_ATE  and the like
72 # self._std   the way a DW_ATE and the like looks in the standard
73 # self._label With all _ and - removed.  Like DWATE
74
75 class dwtoken:
76   """ Token types: 
77   id: identifier
78   ind: a character taken as an individual character.
79   none: No characters seen yet.
80   shift: A character with the high bit of 8 bits set, not something we expect.
81   -      In DW4 these high-bit-chars are special 3-character left and right quotes.
82   -      charfix.py  can replace these with Latex ascii quotes.
83   other: Some other character, but ascii, seemingly.  """
84   def __init__(self):
85     self._tex = []
86     self._underbar = []
87     self._std = []
88     self._label = []
89     # Class is "id", "ind","other","shift","none"
90     self._class = "none"
91     self._linenum = 0
92   def insertid(self,string,line):
93     self._class =  "id"
94     self._tex = list(string)
95     self._underbar = self._tex
96     self._std = self._tex
97     self._label = self._tex
98     self._linenum = line
99   def setIndivid(self,c,line):
100     self._tex = [c]
101     self._underbar = [c]
102     self._std = [c]
103     self._label = [c]
104     self._class =  "ind"
105     self._linenum = line
106   def setInitialIdChar(self,c,line):
107     self._tex = [c]
108     self._class =  "id"
109     self._linenum = line
110   def setNextIdChar(self,c):
111     self._tex += [c]
112
113   def setInitialShift(self,c,line):
114     self._tex = [c]
115     self._underbar = [c]
116     self._std = [c]
117     self._label = [c]
118     self._class =  "shift"
119     self._linenum = line
120   def setNextShift(self,c):
121     self._tex += [c]
122     self._underbar += [c]
123     self._std += [c]
124     self._label += [c]
125     self._class =  "shift"
126   def setInitialOther(self,c,line):
127     self._tex = [c]
128     self._underbar = [c]
129     self._std = [c]
130     self._label = [c]
131     self._class =  "other"
132     self._linenum = line
133   def setNextOther(self,c):
134     self._tex += [c]
135     self._underbar += [c]
136     self._std += [c]
137     self._label += [c]
138     self._class =  "other"
139   def finishUpId(self):
140     """ This transforms the strings from the input form into
141         the internal forms we want.
142     """
143     self._underbar = []
144     self._std = []
145     self._label = []
146     n = 0
147     # Drop \-
148     while int(n) < len(self._tex):
149       c = self._tex[n]
150       if n < (len (self._tex) - 1) and c == "\\" and self._tex[n+1] == "-":
151         n = n +2
152         continue
153       self._underbar += [c]
154       n = n +1
155     # Drop \ from \_
156     n = 0
157     while int(n) < len(self._underbar):
158       c = self._underbar[n]
159       if n < (len (self._underbar) - 1) and c == "\\" and self._underbar[n+1] == "_":
160         n = n +1
161         continue
162       self._std += [c]
163       n = n +1
164     # Drop  underbar
165     n = 0
166     while int(n) < len(self._std):
167       c = self._std[n]
168       if  c == "_":
169         n = n +1
170         continue
171       self._label += [c]
172       n = n +1
173
174   def dwprintquotedshortform(self,d):
175       print "'",self.shortform(d),"'",
176   def shortform(self,d):
177       return ''.join(d)
178   def dwprint(self):
179     if self._class == "ind":
180       print self._class, 
181       self.dwprintquotedshortform(self._tex)
182       print ""
183     else:
184       # This prints the token with end-line oddly.
185       print self._class, 
186       self.dwprintquotedshortform(self._tex)
187       self.dwprintquotedshortform(self._underbar)
188       self.dwprintquotedshortform(self._std)
189       self.dwprintquotedshortform(self._label)
190       print ""
191   def dwwrite(self,outfile):
192     for x in self._tex:
193       outfile.write(x)
194
195 class  dwline:
196   """using an input line, create a list of tokens for the line.
197      Legal class transitions in tokenize() are:
198      none->shift
199      none->other
200      none->id
201      none->ind
202
203      other->ind
204      other->id
205      other->shift
206
207      shift->id
208      shift->ind
209      shift->other
210
211      id->ind
212      id->other
213      id->shift
214   """
215   def __init__(self):
216     # list of dwtoken.
217     self._toks = []
218
219   
220   def tokenize(self,rec,filename,linenum):
221     """using an input line, create a list of tokens for the line.
222        Legal class transitions in tokenize() are:
223        none->other
224        none->id
225        none->ind
226        other->ind
227        other->id
228        id->ind
229        id->other
230     """
231     dwclass = "none"
232     combotok = dwtoken()
233     charnum= -1 
234     global keepcomments
235     for c in rec:
236       charnum = charnum +1
237       if ord(c) >= 128:
238         print " Warning: encountered character ord:",ord(c), "at offset",charnum,"line",linenum,filename
239       if keepcomments == "d" and c == "%" and ( charnum == 0 or rec[charnum - 1] != "\\" ):  
240         # Not keeping comments. We drop % and following to end of line 
241         # unless preceeded by \ 
242         break
243
244       if c == "\n" or c == "\r":
245           # Just drop these for now. Allowing them
246           # would not be harmful.
247           continue
248       elif dwclass == "none" or dwclass == "ind":
249         if isShift(c) == "y":
250           combotok.setInitialShift(c,linenum)
251           dwclass = "shift"
252           continue
253         if isIndivid(c) == "y":
254           a = dwtoken()
255           a.setIndivid(c,linenum);
256           self._toks += [a]
257           continue
258         if isIdStart(c) == "y":
259           combotok.setInitialIdChar(c,linenum)
260           dwclass = "id"
261           continue
262         # is "other"
263         combotok.setInitialOther(c,linenum)
264         dwclass = "other"
265         continue
266       elif dwclass == "id": 
267         if isIdNext(c) == "y":
268           combotok.setNextIdChar(c)
269           continue
270         if isShift(c) == "y":
271           combotok.finishUpId()
272           self._toks += [combotok]
273           combotok = dwtoken()
274           combotok.setInitialShift(c,linenum);
275           dwclass = "shift"
276           continue
277         if isIndivid(c) == "y":
278           combotok.finishUpId()
279           self._toks += [combotok]
280           combotok = dwtoken()
281           a = dwtoken()
282           a.setIndivid(c,linenum);
283           dwclass = "ind"
284           self._toks += [a]
285           continue
286         # Other class input, other starts here.
287         combotok.finishUpId()
288         self._toks += [combotok]
289         combotok = dwtoken()
290         combotok.setInitialOther(c,linenum);
291         dwclass = "other"
292         continue
293       elif dwclass == "shift":
294         if isShift(c) == "y":
295           combotok.setNextShift(c);
296           continue
297         if isIndivid(c) == "y":
298           self._toks += [combotok]
299           combotok = dwtoken()
300           a = dwtoken()
301           a.setIndivid(c,linenum);
302           dwclass = "ind"
303           self._toks += [a]
304           continue
305         if isIdStart(c) == "y":
306           self._toks += [combotok]
307           combotok = dwtoken()
308           combotok.setInitialIdChar(c,linenum);
309           dwclass = "id"
310           continue
311         # Shift class input, other starts here.
312         self._toks += [combotok]
313         combotok = dwtoken()
314         combotok.setInitialOther(c,linenum);
315         dwclass = "other"
316         continue
317       elif dwclass == "other":
318         if isShift(c) == "y":
319           self._toks += [combotok]
320           combotok = dwtoken()
321           combotok.setInitialShift(c,linenum);
322           dwclass = "shift"
323           continue
324         if isIndivid(c) == "y":
325           self._toks += [combotok]
326           combotok = dwtoken()
327           a = dwtoken()
328           a.setIndivid(c,linenum);
329           dwclass = "ind"
330           self._toks += [a]
331           continue
332         if isIdStart(c) == "y":
333           self._toks += [combotok]
334           combotok = dwtoken()
335           combotok.setInitialIdChar(c,linenum);
336           dwclass = "id"
337           continue
338         combotok.setNextOther(c);
339         continue
340       # Else case impossible.
341      
342     #Finish up final non-empty other or id token
343     if dwclass == "id":
344       combotok.finishUpId()
345       self._toks += [combotok]
346       dwclass = "none"
347     if dwclass == "shift":
348       self._toks += [combotok]
349       dwclass = "none"
350     if dwclass == "other":
351       self._toks += [combotok]
352       dwclass = "none"
353   def dwprint(self,linenum):
354     print "Number of tokens in line ",linenum," : ",len(self._toks)
355     if len(self._toks) == 0:
356       #Just print an empty line.
357       print ""
358     else:
359       for t in self._toks:
360         t.dwprint()
361   def dwwrite(self, outfile, linenum):
362     for t in self._toks:
363       t.dwwrite(outfile)
364     outfile.write("\n")
365   def dwtransformline(self,callfunc,myfile,lnum):
366     toks = callfunc(self._toks,myfile,lnum)
367     self._toks = toks
368     
369
370 class dwfile:
371   def __init__(self,name):
372     # list of dwline.
373     self._name = name
374     # Name of the file.
375     self._lines = []
376     try:
377       file = open(name,"r");
378     except IOError, message:
379       print >> sys.stderr , "File could not be opened: ", name
380       sys.exit(1)
381     linenum=0
382     while 1:
383       try:
384         rec = file.readline()
385       except EOFError:
386         break
387       if len(rec) < 1:
388         # eof
389         break
390       linenum = linenum +1
391       aline = dwline()
392       aline.tokenize(rec,name,linenum)
393       self._lines += [aline]
394
395   def dwprint(self):
396     print "Number of lines in ", self._name, ":  ",len(self._lines)
397     lnum = 1
398     for l in self._lines:
399        l.dwprint(lnum)
400        lnum = lnum + 1
401   def dwwrite(self):
402     # The lnum is just for debugging messages.
403
404     outname = self._name + ".out"
405     print outname
406     try:
407       outfile = open(outname,"w");
408     except IOError, message:
409       print >> sys.stderr , "Output File could not be opened: ", name
410       sys.exit(1)
411     lnum = 1
412     for l in self._lines:
413       l.dwwrite(outfile,lnum)
414       lnum = lnum + 1
415   # transformtoks looks at the file as a token sequence,
416   # not a line sequence.
417   # New view required by recent changes to .tex
418   def dwtransformfiletoks(self,callfunc,myfile):
419      FIXME 
420
421   def dwtransformtoks(self,callfunc,myfile):
422     globaltoklist = [] 
423     for l in self._lines:
424       for t in l._toks:
425         globaltoklist += [t]
426     toknum = 0
427     tokmax = len(globaltoklist)
428     self.dwtransformfiletoks(callfunc,myfile)
429
430   def dwtransformline(self,callfunc,myfile):
431     lnum = 1
432     for l in self._lines:
433       l.dwtransformline(callfunc,myfile,lnum)
434       lnum = lnum + 1
435
436 class dwfiles:
437   def __init__(self):
438     # list of dwfile.
439     self._files = []
440
441   def addFile(self,name):
442     f = dwfile(name)
443     self._files += [f]
444     
445   def dwprint(self):
446     print "Number of files: ",len(self._files);
447     for f in self._files:
448       f.dwprint()
449   def dwwrite(self):
450     for f in self._files:
451       f.dwwrite()
452   def dwtransformline(self,callfunc):
453     for f in self._files:
454       f.dwtransformline(callfunc,f)
455   def dwtransformtoks(self,callfunc):
456     for f in self._files:
457       f.dwtransformtoks(callfunc,f)
458
459
460 def setkeepordeletecomments(val):
461   """ Pass in "k" or "d" to keep or delete comments, respectively """
462   global keepcomments
463   keepcomments = val
464
465 def readFilelist(filelist):
466   dwf = dwfiles()
467   for f in filelist:
468     dwf.addFile(f)
469   return dwf
470