Lines Matching refs:self
72 def __init__(self): argument
73 self.id = None
74 self.value = None
75 self.lineno = 0
76 self.colno = 0
78 def set(self,id,val=None): argument
79 self.id = id
81 self.value = val
83 self.value = id
86 def copyFrom(self,src): argument
87 self.id = src.id
88 self.value = src.value
89 self.lineno = src.lineno
90 self.colno = src.colno
92 def __repr__(self): argument
93 if self.id == tokIDENT:
94 return "(ident %s)" % self.value
95 if self.id == tokNUMBER:
96 return "(number %s)" % self.value
97 if self.id == tokSTRING:
98 return "(string '%s')" % self.value
99 if self.id == tokLN:
101 if self.id == tokEOF:
103 if self.id == tokSPACE and self.value == "\\":
107 return self.id
109 def __str__(self): argument
110 if self.id == tokIDENT:
111 return self.value
112 if self.id == tokNUMBER:
113 return self.value
114 if self.id == tokSTRING:
115 return self.value
116 if self.id == tokEOF:
118 if self.id == tokSPACE:
119 if self.value == "\\": # trailing \
122 return self.value
124 return self.id
127 def __init__(self,msg): argument
140 def __init__(self,tokens): argument
141 self.tokens = tokens
142 self.n = 0
143 self.count = len(tokens)
145 def set(self,n): argument
149 if n > self.count:
150 n = self.count
151 self.n = n
153 def peekId(self): argument
155 if (self.n >= self.count):
157 return self.tokens[self.n].id
159 def peek(self): argument
161 if (self.n >= self.count):
163 return self.tokens[self.n]
165 def skip(self): argument
167 if (self.n < self.count):
168 self.n += 1
170 def skipSpaces(self): argument
173 tok = self.peekId()
176 self.skip()
178 def skipIfId(self,id): argument
180 if self.peekId() == id:
181 self.skip()
183 def expectId(self,id): argument
186 tok = self.peek()
189 self.skip()
191 def remain(self): argument
193 return self.tokens[self.n:]
213 def __init__(self): argument
215 self.eof = False # end of file reached ?
216 self.text = None # content of current line, with final \n stripped
217 self.line = 0 # number of current line
218 self.pos = 0 # current character position in current line
219 self.len = 0 # length of current line text
220 self.held = Token()
222 def setLineText(self,line): argument
225 self.text = line
226 self.len = len(line)
227 self.pos = 0
229 def fillLineText(self): argument
232 self.eof = True
234 def markPos(self,tok): argument
236 if self.eof or self.pos > self.len:
237 tok.lineno = self.line + 1
240 tok.lineno = self.line
241 tok.colno = self.pos
243 def peekChar(self): argument
245 if self.eof:
248 if self.pos > self.len:
249 self.pos = 0
250 self.line += 1
251 self.fillLineText()
252 if self.eof:
255 if self.pos == self.len:
258 return self.text[self.pos]
260 def peekNChar(self,n): argument
262 if self.pos + n > self.len:
264 return self.text[self.pos:self.pos+n]
266 def skipChar(self): argument
268 if not self.eof:
269 self.pos += 1
271 def skipNChars(self,n): argument
272 if self.pos + n <= self.len:
273 self.pos += n
276 self.skipChar()
279 def nextChar(self): argument
281 result = self.peekChar()
282 self.skipChar()
285 def getEscape(self): argument
287 result = self.nextChar()
290 num = self.peekNChar(3)
299 self.skipNChars(3)
302 num = self.peekNChar(2)
311 self.skipNChars(2)
314 num = self.peekNChar(4)
323 self.skipNChars(4)
327 def nextRealToken(self,tok): argument
329 c = self.nextChar()
334 c = self.peekChar()
336 self.skipChar()
338 c = self.nextChar()
343 self.skipChar()
347 c = self.nextChar()
363 c2 = self.peekChar()
367 self.skipChar()
372 print "nextRealToken: \\ found, next token is '%s'" % repr(self.peekChar())
373 if self.peekChar() == tokLN: # trailing \
375 self.skipChar()
382 c +=self.getEscape()
386 c2 = self.nextChar()
389 c += self.getEscape()
392 c2 = self.nextChar()
404 c2 = self.nextChar()
419 c2 = self.peekChar()
423 self.skipChar()
428 c2 = self.peekChar()
432 self.skipChar()
442 if self.pos + sklen <= self.len and \
443 self.text[self.pos:self.pos+sklen] == sk[1:]:
444 self.pos += sklen
449 def nextToken(self,tok): argument
452 self.markPos(tok)
453 self.nextRealToken(tok)
455 def getToken(self): argument
457 self.nextToken(tok)
462 def toTokenList(self): argument
468 self.nextToken(tok)
476 def __init__(self,line,lineno=1): argument
477 CppTokenizer.__init__(self)
478 self.line = lineno
479 self.setLineText(line)
485 def __init__(self,lines=[],lineno=1): argument
487 CppTokenizer.__init__(self)
488 self.line = lineno
489 self.lines = lines
490 self.index = 0
491 self.count = len(lines)
493 if self.count > 0:
494 self.fillLineText()
496 self.eof = True
498 def addLine(self,line): argument
501 if self.count == 0:
502 self.setLineText(line)
503 self.index = 1
504 self.lines.append(line)
505 self.count += 1
506 self.eof = False
508 def fillLineText(self): argument
509 if self.index < self.count:
510 self.setLineText(self.lines[self.index])
511 self.index += 1
513 self.eof = True
517 def __init__(self,file,lineno=1): argument
518 CppTokenizer.__init__(self)
519 self.file = file
520 self.line = lineno
522 def fillLineText(self): argument
523 line = self.file.readline()
529 self.setLineText(line)
531 self.eof = True
537 def __init__(self,tokenizer=None): argument
538 self.tokenizer = tokenizer
539 self.token = Token()
541 def setTokenizer(self,tokenizer): argument
542 self.tokenizer = tokenizer
544 def expect(self,id): argument
545 self.tokenizer.nextToken(self.token)
546 tokid = self.token.id
549 if self.token.value == id and (tokid == tokIDENT or tokid == tokNUMBER):
551 raise BadExpectedToken, "### BAD TOKEN: '%s' expecting '%s'" % (self.token.id,id)
553 def expectToken(self,id,line,col): argument
554 self.expect(id)
555 if self.token.lineno != line:
556 …dExpectedToken, "### BAD LINENO: token '%s' got '%d' expecting '%d'" % (id,self.token.lineno,line)
557 if self.token.colno != col:
558 raise BadExpectedToken, "### BAD COLNO: '%d' expecting '%d'" % (self.token.colno,col)
560 def expectTokenVal(self,id,value,line,col): argument
561 self.expectToken(id,line,col)
562 if self.token.value != value:
563 raise BadExpectedToken, "### BAD VALUE: '%s' expecting '%s'" % (self.token.value,value)
565 def expectList(self,list): argument
567 self.expect(item)
672 def __init__(self,op): argument
673 self.op = op
675 def __repr__(self): argument
676 return "(%s)" % self.op
678 def __str__(self): argument
679 return "operator(%s)" % self.op
681 def precedence(self): argument
683 return Expr.precedences.get(self.op, 1000)
685 def isUnary(self): argument
686 return self.op in Expr.unaries
688 def isBinary(self): argument
689 return self.op in Expr.binaries
691 def isDefined(self): argument
692 return self.op is opDefined
694 def toInt(self): argument
700 def __init__(self,value): argument
701 Expr.__init__(self,opInteger)
702 self.arg = value
704 def __repr__(self): argument
705 return "(int %s)" % self.arg
707 def __str__(self): argument
708 return self.arg
710 def toInt(self): argument
711 s = self.arg # string value
718 def __init__(self,name): argument
719 Expr.__init__(self,opIdent)
720 self.name = name
722 def __repr__(self): argument
723 return "(ident %s)" % self.name
725 def __str__(self): argument
726 return self.name
729 def __init__(self,funcname,params): argument
730 Expr.__init__(self,opCall)
731 self.funcname = funcname
732 self.params = params
734 def __repr__(self): argument
735 result = "(call %s [" % self.funcname
737 for param in self.params:
743 def __str__(self): argument
744 result = "%s(" % self.funcname
746 for param in self.params:
754 def __init__(self,cond,iftrue,iffalse): argument
755 Expr.__init__(self,opTest)
756 self.cond = cond
757 self.iftrue = iftrue
758 self.iffalse = iffalse
760 def __repr__(self): argument
761 return "(?: %s %s %s)" % (repr(self.cond),repr(self.iftrue),repr(self.iffalse))
763 def __str__(self): argument
764 return "(%s) ? (%s) : (%s)" % (self.cond, self.iftrue, self.iffalse)
767 def __init__(self,op,arg): argument
768 Expr.__init__(self,op)
769 self.arg = arg
771 def __repr__(self): argument
772 return "(%s %s)" % (self.op, repr(self.arg))
775 def __init__(self,op,macroname): argument
776 SingleArgExpr.__init__(self.opDefined,macroname)
778 def __str__(self): argument
779 return "defined(%s)" % self.arg
783 def __init__(self,op,arg,opstr=None): argument
784 SingleArgExpr.__init__(self,op,arg)
787 self.opstr = opstr
789 def __str__(self): argument
790 arg_s = str(self.arg)
791 arg_prec = self.arg.precedence()
792 self_prec = self.precedence()
794 return "%s(%s)" % (self.opstr,arg_s)
796 return "%s%s" % (self.opstr, arg_s)
799 def __init__(self,op,arg1,arg2): argument
800 Expr.__init__(self,op)
801 self.arg1 = arg1
802 self.arg2 = arg2
804 def __repr__(self): argument
805 return "(%s %s %s)" % (self.op, repr(self.arg1), repr(self.arg2))
808 def __init__(self,op,arg1,arg2,opstr=None): argument
809 TwoArgExpr.__init__(self,op,arg1,arg2)
812 self.opstr = opstr
814 def __str__(self): argument
815 arg1_s = str(self.arg1)
816 arg2_s = str(self.arg2)
817 arg1_prec = self.arg1.precedence()
818 arg2_prec = self.arg2.precedence()
819 self_prec = self.precedence()
827 result += " %s " % self.opstr
852 def __init__(self,tokens): argument
853 self.tok = tokens
854 self.n = len(self.tok)
855 self.i = 0
857 def mark(self): argument
858 return self.i
860 def release(self,pos): argument
861 self.i = pos
863 def peekId(self): argument
864 if self.i < self.n:
865 return self.tok[self.i].id
868 def peek(self): argument
869 if self.i < self.n:
870 return self.tok[self.i]
873 def skip(self): argument
874 if self.i < self.n:
875 self.i += 1
877 def skipOptional(self,id): argument
878 if self.i < self.n and self.tok[self.i].id == id:
879 self.i += 1
881 def skipSpaces(self): argument
882 i = self.i
883 n = self.n
884 tok = self.tok
887 self.i = i
892 def is_integer(self): argument
893 id = self.tok[self.i].id
912 def is_defined(self): argument
913 id = self.tok[self.i].id
917 pos = self.mark()
920 if self.peekId() == tokLPAREN:
921 self.skip()
924 if self.peekId() != tokIDENT:
925 self.throw( BadExpectedToken, "identifier expected")
927 macroname = self.peek().value
928 self.skip()
930 self.skipSpaces()
931 if self.peekId() != tokRPAREN:
932 self.throw( BadExpectedToken, "missing right-paren after 'defined' directive")
933 self.skip()
935 i = self.i
938 def is_call_or_ident(self): argument
941 def parse(self, i): argument
976 def __init__(self, tokens): argument
978 self.tok = tokens
979 self.n = len(tokens)
982 expr = self.is_expr(0)
985 self.expr = expr[0]
989 def throw(self,exception,i,msg): argument
990 if i < self.n:
991 tok = self.tok[i]
997 def skip_spaces(self,i): argument
999 while i < self.n:
1000 t = self.tok[i]
1006 def expectId(self,i,id): argument
1008 i = self.skip_spaces(i)
1009 if i >= self.n or self.tok[i].id != id:
1010 … self.throw(BadExpectedToken,i,"### expecting '%s' in expression, got '%s'" % (id, self.tok[i].id))
1013 def expectIdent(self,i): argument
1014 i = self.skip_spaces(i)
1015 if i >= self.n or self.tok[i].id != tokIDENT:
1016 …self.throw(BadExpectedToken,i,"### expecting identifier in expression, got '%s'" % (id, self.tok[i…
1024 def is_decimal(self,i): argument
1025 v = self.tok[i].value[:]
1037 def is_hexadecimal(self,i): argument
1038 v = self.tok[i].value[:]
1053 def is_integer(self,i): argument
1054 if self.tok[i].id != tokNUMBER:
1057 c = self.is_decimal(i)
1060 c = self.is_hexadecimal(i)
1065 def is_number(self,i): argument
1066 t = self.tok[i]
1067 if t.id == tokMINUS and i+1 < self.n:
1068 c = self.is_integer(i+1)
1073 if t.id == tokPLUS and i+1 < self.n:
1074 c = self.is_integer(i+1)
1077 return self.is_integer(i)
1080 def is_alnum(self,i): argument
1082 i = self.skip_spaces(i)
1083 if i >= self.n:
1085 t = self.tok[i]
1093 def is_defined(self,i): argument
1094 t = self.tok[i]
1099 i = self.skip_spaces(i+1)
1101 if i < self.n and self.tok[i].id == tokLPAREN:
1103 i = self.skip_spaces(i+1)
1105 if i >= self.n:
1106 … self.throw(CppConstantExpected,i,"### 'defined' must be followed by macro name or left paren")
1108 t = self.tok[i]
1110 self.throw(CppConstantExpected,i,"### 'defined' must be followed by macro name")
1114 i = self.expectId(i,tokRPAREN)
1119 def is_call_or_ident(self,i): argument
1120 i = self.skip_spaces(i)
1121 if i >= self.n:
1124 t = self.tok[i]
1130 i = self.skip_spaces(i+1)
1131 if i >= self.n or self.tok[i].id != tokLPAREN:
1138 while i < self.n:
1139 id = self.tok[i].id
1143 while j < i and self.tok[j].id == tokSPACE:
1146 while k > j and self.tok[k-1].id == tokSPACE:
1148 param = self.tok[j:k]
1157 if i >= self.n:
1162 def is_token(self,i,token): argument
1163 i = self.skip_spaces(i)
1164 if i >= self.n or self.tok[i].id != token:
1169 def is_value(self,i): argument
1170 t = self.tok[i]
1174 c = self.is_number(i)
1177 c = self.is_defined(i)
1180 c = self.is_call_or_ident(i)
1183 i = self.skip_spaces(i)
1184 if i >= self.n or self.tok[i].id != tokLPAREN:
1189 while i2 < self.n:
1190 t = self.tok[i2]
1200 self.throw(CppInvalidExpression, i, "expression missing closing parenthesis")
1203 print "CppExpr: trying to parse sub-expression %s" % repr(self.tok[i+1:i2])
1204 oldcount = self.n
1205 self.n = i2
1206 c = self.is_expr(i+1)
1207 self.n = oldcount
1209 self.throw(CppInvalidExpression, i, "invalid expression within parenthesis")
1214 def is_unary(self,i): argument
1215 i = self.skip_spaces(i)
1216 if i >= self.n:
1219 t = self.tok[i]
1221 c = self.is_unary(i+1)
1223 self.throw(CppInvalidExpression, i, "%s operator must be followed by value" % t.id)
1227 return self.is_value(i)
1229 def is_binary(self,i): argument
1230 i = self.skip_spaces(i)
1231 if i >= self.n:
1234 c = self.is_unary(i)
1239 i2 = self.skip_spaces(i2)
1240 if i2 >= self.n:
1243 t = self.tok[i2]
1245 c = self.is_binary(i2+1)
1247 … self.throw(CppInvalidExpression, i,"### %s operator must be followed by value" % t.id )
1253 def is_expr(self,i): argument
1254 return self.is_binary(i)
1256 def dump_node(self,e): argument
1279 line += " %s)" % self.dump_node(e[1])
1281 line += " %s %s)" % (self.dump_node(e[1]), self.dump_node(e[2]))
1287 def __repr__(self): argument
1288 return self.dump_node(self.expr)
1290 def source_node(self,e): argument
1305 arg_src = self.source_node(arg)
1316 arg1_src = self.source_node(arg)
1317 arg2_src = self.source_node(arg2)
1326 def __str__(self): argument
1327 return self.source_node(self.expr)
1329 def int_node(self,e): argument
1337 def toInt(self): argument
1338 return self.int_node(self.expr)
1340 def optimize_node(self,e,macros={}): argument
1355 v = self.optimize_node(v, macros)
1364 l = self.optimize_node(l, macros)
1365 r = self.optimize_node(r, macros)
1366 li = self.int_node(l)
1367 ri = self.int_node(r)
1376 l = self.optimize_node(l, macros)
1377 r = self.optimize_node(r, macros)
1378 li = self.int_node(l)
1379 ri = self.int_node(r)
1392 def optimize(self,macros={}): argument
1393 self.expr = self.optimize_node(self.expr,macros)
1395 def removePrefixedNode(self,e,prefix,names): argument
1407 v = self.removePrefixedNode(v,prefix,names)
1411 v1 = self.removePrefixedNode(v1,prefix,names)
1412 v2 = self.removePrefixedNode(v2,prefix,names)
1418 params2.append( self.removePrefixedNode(param,prefix,names) )
1423 def removePrefixed(self,prefix,names={}): argument
1424 self.expr = self.removePrefixedNode(self.expr,prefix,names)
1426 def is_equal_node(self,e1,e2): argument
1434 return self.is_equal_node(e1[1],e2[1]) and self.is_equal_node(e1[2],e2[2])
1436 def is_equal(self,other): argument
1437 return self.is_equal_node(self.expr,other.expr)
1538 def __init__(self,tokens,directive=None,lineno=0): argument
1556 self.tokens = tokens
1557 self.directive = directive
1559 self.lineno = lineno
1561 self.lineno = self.tokens[0].lineno
1563 if self.isIf():
1564 self.expr = CppExpr( self.tokens )
1566 def isDirective(self): argument
1568 return self.directive != None
1570 def isConditional(self): argument
1572 return self.directive in ["if","ifdef","ifndef","else","elif","endif"]
1574 def isDefine(self): argument
1576 if self.directive != "define":
1579 return self.tokens[0].value
1581 def isIf(self): argument
1583 return self.directive in ["if","ifdef","ifndef","elif"]
1585 def isInclude(self): argument
1588 if self.directive != "include":
1592 if self.tokens[0].id == tokSTRING:
1594 return self.tokens[0].value
1597 if self.tokens[0].id == "<":
1599 tok = self.tokens
1612 def __repr__(self): argument
1614 if self.directive:
1615 result = "#%s " % self.directive
1616 if self.isIf():
1617 result += repr(self.expr)
1619 for tok in self.tokens:
1623 for tok in self.tokens:
1628 def __str__(self): argument
1630 if self.directive:
1631 if self.directive == "if":
1633 e = self.expr.expr
1640 result = "#if " + str(self.expr)
1642 result = "#%s" % self.directive
1643 if len(self.tokens):
1645 for tok in self.tokens:
1649 for tok in self.tokens:
1658 def __init__(self,blocks): argument
1659 self.blocks = blocks
1661 def __len__(self): argument
1662 return len(self.blocks)
1664 def __getitem__(self,n): argument
1665 return self.blocks[n]
1667 def __repr__(self): argument
1668 return repr(self.blocks)
1670 def __str__(self): argument
1672 for b in self.blocks:
1678 def optimizeIf01(self): argument
1680 self.blocks = optimize_if01(self.blocks)
1682 def optimizeMacros(self, macros): argument
1684 for b in self.blocks:
1688 def removeMacroDefines(self,macros): argument
1690 self.blocks = remove_macro_defines(self.blocks,macros)
1692 def removePrefixed(self,prefix,names): argument
1693 for b in self.blocks:
1697 def optimizeAll(self,macros): argument
1698 self.optimizeMacros(macros)
1699 self.optimizeIf01()
1702 def findIncludes(self): argument
1705 for b in self.blocks:
1713 def write(self,out): argument
1714 out.write(str(self))
1716 def removeComments(self): argument
1717 for b in self.blocks:
1722 def removeEmptyLines(self): argument
1726 for b in self.blocks:
1782 def removeVarsAndFuncs(self,knownStatics=set()): argument
1798 for b in self.blocks:
1857 self.blocks = blocks2
1859 def insertDisclaimer(self,disclaimer="/* auto-generated file, DO NOT EDIT */"): argument
1864 self.blocks = [ Block(tokens) ] + self.blocks
1869 def __init__(self,tokzer=None): argument
1872 self.reset(tokzer)
1874 def reset(self,tokzer): argument
1875 self.state = 1
1876 self.tokzer = tokzer
1878 def getBlocks(self,tokzer=None): argument
1892 tokzer = self.tokzer
1964 def parse(self,tokzer): argument
1965 return self.getBlocks( tokzer )
1967 def parseLines(self,lines): argument
1969 return self.getBlocks( CppLinesTokenizer(lines) )
1971 def parseFile(self,path): argument
1974 result = self.getBlocks( CppFileTokenizer(file) )