code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket","leftparen","rightparen",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","comma","dot","appendsym",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket, leftparen, rightparen,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint,comma,dot,appendsym,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('append', appendsym)
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '[', leftparen)
addToSymTbl( ']', rightparen)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( EOF, endfile)
addToSymTbl( ',', comma)
addToSymTbl( '.', dot)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
##print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["=", "#", "<", ">", "{", "}", "(", ")", "[","]", "+" , "-", "*", "/", ";","!", "==",",",".", EOF]:
token = lookup(ch) # preloaded with appropriate token
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | - | * | /) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == assignsym:assignStmt()
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#===============================================================================
def array():
#a=[1,2,3];
#a=append(4);
#print a;
#===============================================================================
global array;
global list;
list =[];
#a=[1,2,3];
while (token.token == number):
print("#array address")
emit(0, "loadv", token.value)
list.append(token.value)
emit(0, "store", token.value+100)
emit(0, "push", token.value+200)
getoken()
if token.token == comma:getoken()
if token.token == rightparen:getoken()
if token.token == semicolon:getoken()
print ("\n"+ "#This is a list of array from txt\n" + "#"+str(list) + "\n");
if token.token == idsym:getoken()
if token.token == dot:getoken()
if token.token == appendsym:getoken()
if token.token == leftbracket:getoken()
while( token.token == number):
print("#store new value to list")
emit(0, "load", token.value)
list.append(token.value)
emit(0, "store", 104)
emit(0, "push", token.value+200)
getoken()
print("\n"+ "#Now the list have new value added to list" + "\n#"+str(list)+"\n")
if token.token == rightbracket:getoken()
if token.token == semicolon:getoken()
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
if token.token == varsym:
vars()
elif token.token == idsym:
assignStmt()
elif token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
if token.token == idsym: getoken()
if token.token == leftparen:getoken()
if token.token == number:
searchindex = token.value
print("\n#The search index is " + str(searchindex))
print ("#The value got from list is " + str(list[searchindex]))
emit(0, "loadv", list[searchindex])
emit(0, "store", 206)
print("\n")
getoken()
if token.token == rightparen:getoken()
if token.token == plus:
getoken()
emit(0, "loadv", token.value)
emit(0, "add", 206)
emit(0, "store", 101)
emit(0, "writeint", 0) # Memory address 0 is the ACC
getoken()
if token.token == semicolon: getoken()
print("#The result of a[1]+5 should be 7")
if token.token == rightbrace:
print("")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals:
srcfile.read()
# getoken()
elif token.token == assignsym:
getoken()
elif token.token == number:
factor()
elif token.token == leftparen: # [
array()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == jumpeq:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 999) # Save current result
if token.token == jumpeq:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpeq", 83)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
print("# Store value")
emit(0, "loadv", token.value)
emit(0, "store", 50)
print(" ")
getoken()
elif token.token == leftparen:getoken()
elif token.token == assignsym:getoken()
elif token.token == semicolon:getoken()
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
global searchindex;
global result;
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
stmtList()
if token.token == rightparen: getoken()
elif token.token == number: array()
# else: error(" ] expected")
if token.token == printsym:printStmt()
stmtList()
getoken()
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else: error(" } expected")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('declare_array.txt', 'r')
line = srcfile.read() # readline
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
srcfile.close()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
#emit(0, "constant", "'A'")
#emit(0, "constant", 10)
#emit(0, "constant", 8)
#emit(0, "constant", 25)
#emit(0, "constant", -10)
main()
"""srcfile = open('tiny.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print repr(token)
"""
#getoken()
| Python |
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint", "halt",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, halt,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('halt', halt)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
#if line == "": line = EOF
#if line == "#": line = notequals
print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["=", "#", "<", ">", "{", "}", "(", ")", "+" , "-", "*", "/", ";","!", "==", EOF]:
token = lookup(ch) # preloaded with appropriate token
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == idsym:
assignStmt()
elif token.token == halt:
emit(0, "halt",0 )
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == assignsym:
getoken()
elif token.token == jumpeq:
getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus or token.token == mpy or token.token == div or token.token == lessthan or token.token == greaterthan or token.token == jumpne or token.token == jumpeq:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 999) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus:
emit(0, "loadv", 999)
emit(0, "add", 999)
emit(0, "store", 999)
if op.token == leftbracket:getoken()
elif op.token == minus: # Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 6)
elif op.token == mpy:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "mpy", 998)
emit(0, "store", 7)
elif op.token == div:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "div", 998)
emit(0, "store", 8)
elif op.token == lessthan:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumplt", 80)
emit(0, "loadv", 0)
emit(0, "store", 9)
elif op.token == greaterthan:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpgt", 81)
emit(0, "loadv", 0)
emit(0, "store", 10)
#not working
elif op.token == jumpne:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpne", 82)
emit(0, "loadv", 0)
emit(0, "store", 11)
elif op.token == jumpeq:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpeq", 83)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == semicolon: getoken()
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
if token.token == varsym : vars()
stmtList()
if token.token == halt:
print("\n#*** Stop execution ***\n")
elif token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else: error(" } expected")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
# srcfile = open('while_If_forever_loop.txt', 'r')
# srcfile = open('while_If_Continue_restart_loop.txt', 'r')
srcfile = open('Read_Write_int_ch.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
emit(0, "constant", "'A'")
emit(0, "constant", 10)
emit(0, "constant", 12)
emit(0, "constant", 25)
emit(0, "constant", -10)
main()
#srcfile = open('tiny.txt', 'r')
#lexer = shlex.shlex(srcfile)
#for token in lexer:
# print repr(token)
#getoken()
| Python |
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["=", "#", "<", ">", "{", "}", "(", ")", "+" , "-", "*", "/", ";","!", "==", EOF]:
token = lookup(ch) # preloaded with appropriate token
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == idsym:
assignStmt()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("\n*** Compilation finished ***\n")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals:
srcfile.read()
# getoken()
elif token.token == assignsym:
getoken()
elif token.token == jumpeq:
getoken()
elif token.token == semicolon:getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
if token.token == lessthan:
print("lessthan")
getoken()
expression()
stmt()
if token.token == semicolon:getoken()
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus or token.token == mpy or token.token == div or token.token == lessthan or token.token == greaterthan or token.token == jumpne or token.token == jumpeq:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 999) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus:
emit(0, "add", 999)
emit(0, "store", 999)
if op.token == leftbracket:getoken()
elif op.token == minus: # Subtract - have to swap operand order
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 6)
elif op.token == mpy:
emit(0, "mpy", 998)
emit(0, "store", 7)
elif op.token == div:
emit(0, "div", 998)
emit(0, "store", 8)
elif op.token == lessthan:
emit(0, "compare",105 )
emit(0, "jumplt", 150)
emit(150, "halt", 0)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", token.value+100)
getoken()
elif token.token == rightbrace:print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
if token.token == varsym : vars()
stmtList()
if token.token == rightbrace:
print("\n*** Compilation finished ***\n")
else: error(" } expected")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('break.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
srcfile.close()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
#emit(0, "constant", "'A'")
#emit(0, "constant", 10)
#emit(0, "constant", 12)
#emit(0, "constant", 25)
#emit(0, "constant", -10)
main()
#srcfile = open('tiny.txt', 'r')
#lexer = shlex.shlex(srcfile)
#for token in lexer:
# print repr(token)
#getoken()
| Python |
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
#if line == "": line = EOF
#if line == "#": line = notequals
print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["=", "#", "<", ">", "{", "}", "(", ")", "+" , "-", "*", "/", ";","!", "==", EOF]:
token = lookup(ch) # preloaded with appropriate token
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == idsym:
assignStmt()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == assignsym:
getoken()
elif token.token == jumpeq:
getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus or token.token == mpy or token.token == div or token.token == lessthan or token.token == greaterthan or token.token == jumpne or token.token == jumpeq:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 999) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus:
emit(0, "loadv", 999)
emit(0, "add", 999)
emit(0, "store", 999)
if op.token == leftbracket:getoken()
elif op.token == minus: # Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 6)
elif op.token == mpy:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "mpy", 998)
emit(0, "store", 7)
elif op.token == div:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "div", 998)
emit(0, "store", 8)
elif op.token == lessthan:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumplt", 80)
emit(0, "loadv", 0)
emit(0, "store", 9)
elif op.token == greaterthan:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpgt", 81)
emit(0, "loadv", 0)
emit(0, "store", 10)
#not working
elif op.token == jumpne:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpne", 82)
emit(0, "loadv", 0)
emit(0, "store", 11)
elif op.token == jumpeq:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpeq", 83)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
if token.token == varsym : vars()
stmtList()
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else: error(" } expected")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
# srcfile = open('while_If_forever_loop.txt', 'r')
# srcfile = open('while_If_Continue_restart_loop.txt', 'r')
srcfile = open('Read_Write_int_ch.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
emit(0, "constant", "'A'")
emit(0, "constant", 10)
emit(0, "constant", 12)
emit(0, "constant", 25)
emit(0, "constant", -10)
main()
#srcfile = open('tiny.txt', 'r')
#lexer = shlex.shlex(srcfile)
#for token in lexer:
# print repr(token)
#getoken()
| Python |
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
#if line == "": line = EOF
#if line == "#": line = notequals
print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["#", "<", ">", "{", "}", "(", ")", "+" , "-", "*", "/", ";","!", EOF]:
token = lookup(ch) # preloaded with appropriate token
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == idsym:
assignStmt()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == assignsym:
getoken()
elif token.token == jumpeq:
getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
if token.token == idsym:getoken()
if token.token == assignsym: getoken()
if token.token == number:
emit(0, "loadv", token.value)
if token.token == semicolon:getoken()
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
if token.token == idsym: getoken()
if token.token == assignsym:getoken()
if token.token == idsym: getoken()
if token.token == plus: getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 400)
emit(0, "add", 202)
getoken()
emit(0, "jump", 20)
# emit(0, "increment", 1)
#emit(0, "store", 202)
# emit(0, "jumpi", 14)
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
expression()
stmt()
# emit(0, "increment", 1)
# emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus or token.token == mpy or token.token == div or token.token == lessthan or token.token == greaterthan or token.token == jumpne or token.token == jumpeq:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 300) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus:
emit(0, "loadv", 999)
emit(0, "add", 999)
emit(0, "store", 999)
if op.token == leftbracket:getoken()
elif op.token == minus: # Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 6)
elif op.token == mpy:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "mpy", 998)
emit(0, "store", 7)
elif op.token == div:
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "div", 998)
emit(0, "store", 8)
elif op.token == lessthan:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumplt", 80)
emit(0, "loadv", 0)
emit(0, "store", 9)
elif op.token == greaterthan:
emit(0, "compare", 202)
emit(0, "jumpgt", 81)
getoken()
emit(81, "loadv", 2)
emit(82, "store", 202)
getoken()
elif op.token == jumpeq:
emit(0, "store", 998)
emit(0, "compare", 999)
emit(0, "jumpeq", 83)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 200+token.value)
getoken()
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
if token.token == varsym : vars()
stmtList()
if token.token == elsesym:elseStmt()
stmtList()
if token.token == rightbrace:
print("\n#*** Compilation finished ***\n")
else: error(" } expected")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
# srcfile = open('while_If_forever_loop.txt', 'r')
# srcfile = open('while_If_Continue_restart_loop.txt', 'r')
srcfile = open('while_If_Continue_restart_loop.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
#emit(0, "constant", "'A'")
#emit(0, "constant", 10)
#emit(0, "constant", 12)
#emit(0, "constant", 25)
#emit(0, "constant", -10)
main()
#srcfile = open('tiny.txt', 'r')
#lexer = shlex.shlex(srcfile)
#for token in lexer:
# print repr(token)
#getoken()
| Python |
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "elsesym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","remainder", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace,\
varsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym, ifsym, elsesym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,remainder, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '%', remainder)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '!=', jumpne)
addToSymTbl( '==', jumpeq)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in ["#", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%", EOF]:
token = lookup(ch) # preloaded with appropriate token
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
else: error("semicolon expected in declaration")
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == jumpne:
expression()
elif token.token == jumpeq:
expression()
elif token.token == lessthanequal:
expression()
elif token.token == greaterthanequal:
expression()
elif token.token == rightbrace:getoken()
elif token.token == semicolon:
getoken()
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == ifsym: stmt()
elif token.token == whilesym: stmt()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("#")
elif token.token == greaterthanequal: print("#")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
expression()
stmt()
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
print("#While statement\n")
getoken() # skip "while"
expression()
emit(0, "compare", 204)
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression()
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken()
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus or token.token == mpy or token.token == div or token.token == lessthan or token.token == greaterthan or token.token == jumpeq or token.token == jumpne or token.token == lessthanequal or token.token == greaterthanequal:
op = token # remember +/-
getoken() # skip past +/-
#emit(0, "store", 2) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "loadv", 999)
emit(0, "add", 999)
emit(0, "store", 999)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
elif op.token == mpy: #*
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "mpy", 998)
emit(0, "store", 881)
elif op.token == div: #/
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "div", 998)
emit(0, "store", 882)
elif op.token == remainder: #%
emit(0, "store", 998)
emit(0, "load", 999)
emit(0, "mod", 998)
emit(0, "store", 883)
elif op.token == jumpeq: #==
print("#==\n")
emit(0, "compare", 11)
emit(0, "jumpeq", 310)
if token.token == idsym:getoken()
if token.token == assignsym:getoken()
emit(310, "loadv", token.value)
emit(311, "store", 401)
emit(312, "return", 0)
getoken()
getoken()
elif op.token == jumpne: #!=
print("#!=\n")
emit(0, "compare", 204)
emit(0, "jumpne", 300)
if token.token == idsym:getoken()
if token.token == assignsym:getoken()
emit(300, "loadv", token.value)
emit(301, "store", 400)
emit(302, "return", 0)
getoken()
getoken()
elif op.token == lessthanequal: #<=
print("#<=\n")
emit(0, "compare", 204)
emit(0, "jumplt", 320)
emit(0, "compare", 204)
emit(0, "jumpeq", 320)
if token.token == idsym:getoken()
if token.token == assignsym:getoken()
emit(320, "loadv", token.value)
emit(321, "store", 402)
emit(322, "return", 0)
getoken()
getoken()
elif op.token == greaterthanequal: #>=
print("#>=\n")
emit(0, "compare", 204)
emit(0, "jumpgt", 330)
emit(0, "compare", 204)
emit(0, "jumpeq", 330)
if token.token == idsym:getoken()
if token.token == assignsym:getoken()
emit(330, "loadv", token.value)
emit(331, "store", 403)
emit(332, "return", 0)
getoken()
if token.token == semicolon:getoken()
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 200+token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == lessthan:
print("#<")
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == semicolon: getoken()
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == leftbrace: getoken()
else: error(" { expected")
if token.token == idsym: getoken()
else: error("Program name expected")
if token.token == semicolon: getoken()
else: error("Semicolon expected")
if token.token == varsym : vars()
stmtList()
if token.token == rightbrace:
print("\n")
else: error(" } expected")
if token.token == rightbrace:
print("\n")
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('character.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
srcfile.close()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
emit(0, "load", 0)
main()
#srcfile = open('tiny.txt', 'r')
#lexer = shlex.shlex(srcfile)
#for token in lexer:
# print repr(token)
getoken()
| Python |
'''
Created on Jun 23, 2014
@author: Brian
'''
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken","programsym", "idsym", "assignsym", "leftbrace", "rightbrace","comma",
"varsym","functionsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym","printmsg", "ifsym", "elsesym","declaresym","forsym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","addup","addup_1",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","ex","remainder","returnvalue","return_a", "endfile"]
# define the tokens as variables
unknownToken,programsym, idsym, assignsym, leftbrace, rightbrace, comma,\
varsym,functionsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym,printmsg, ifsym, elsesym,declaresym, forsym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, addup,addup_1,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,ex,remainder,returnvalue,return_a, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('function', functionsym) # function
addToSymTbl('program', programsym) # function
addToSymTbl('declare', declaresym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', forsym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('printmsg', printmsg)#PRINTMESSAGE
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('addup', addup)#ADDUP
addToSymTbl('addup(1)',addup_1)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '!', ex)
addToSymTbl( '%', remainder)
addToSymTbl( ',', comma)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
addToSymTbl( 'return', returnvalue)
addToSymTbl( 'return a', return_a)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in [",", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%", EOF]:
token = lookup(ch) # preloaded with appropriate token
# special characters
# check ==
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check ==
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check <=
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check >=
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["addup"]:
ch = getch()
addup_a = "addup(a)"
if ch == "(":
ch = getch()
if ch == "a":
ch = getch()
if ch == ")":
char = addup_a
else:
token = lookup(ch)
else:
token = lookup(ch)
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif token.token ==return_a:
emit(0,"return", 0)
getoken()
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
elif token.token == assignsym: getoken()
else: error("semicolon expected in declaration")
#===============================================================================
def parameters(value1):
#<parameters> ::= (<value>)
#===============================================================================
global va1;
if token.token == leftbracket:getoken();
#1st variable
if token.token == number:
emit(0, "loadv", token.value)
if token.token == rightbracket: getoken();
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == printmsg:
printMsg()
elif token.token == addup:
addup()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == varsym:
vars()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == functionsym:
functionStmt()
elif token.token == rightbrace:
print("")
elif token.token == semicolon:
print("")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
print("#Print String APPLE to memory")
emit(0, "loadv", 100)
emit(0, "store", 1)
emit(0, "call", 40)
emit(40, "load-Ind", 0)
emit(41, "jumpeq", 45)
emit(42, "writech",150)
emit(43, "increment", 1)
emit(44, "jump", 40)
emit(45, "return", 0)
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("")
elif token.token == greaterthanequal: print("")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 1) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "call", 27)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("#!=")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == semicolon: getoken()
elif token.token == rightbrace: print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> <function> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == programsym:
# print "name",tokenNames[token.token]
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym: getoken()
else: error("Program error - Program name expected")
if token.token == semicolon: getoken()
else: error("Program error - Semicolon 1 expected")
if token.token == declaresym :
vars()
if token.token == varsym :
vars()
if token.token == functionsym:
functionStmt()
if token.token == leftbrace:
getoken()
if token.token == printsym:
print("#print")
getoken()
if token.token == leftbracket: #(
getoken()
else: error(" ( expected")
#=================================================
# Start Function
#=================================================
if token.token == addup:
functionStmt()
#=================================================
# End Function
#=================================================
stmtList()
#=================================================
def functionStmt():
#=================================================
# <function> ::= { <id>; <vars > <stmtlist> }
#<parameters>::= <var>, <var>
print("#Start of Function")
getoken(); #skip function - already been recognised
# function name called addup
#combine addup(a) into one token
if token.token == addup: #addup
getoken();
if token.token == leftbracket: #(
getoken()
else: error(" ( expected")
if token.token == number:
emit(0,"loadv", token.value)
emit(0, "store", 1)
emit(0, "call", 27)
getoken()
if token.token == rightbracket:
getoken()
else: error("Function error: rightbracket expected")
if token.token == rightbracket:
emit(27, "loadv", 1)
emit(28, "add", 1)
emit(29, "store", 1)
emit(30, "return", 0)
getoken()
else: error("Function error: rightbracket expected")
if token.token == semicolon:
emit(0, "writeInt", 0)
getoken()
else: error("Function error: semicolon expected")
if token.token == idsym:
if token.name == "n":
tokenNames[token.token]= "addup_n"
print "#token:-",tokenNames[token.token]
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == number:getoken()
else: error("Function error: number expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == returnvalue:getoken()
else: error("Function error: return expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
print("#End of function define \n")
#===============================================================================
def addup_a():
#===============================================================================
"""
emit(27, "add", 1)
emit(28, "return", 0)
"""
if token.token == leftbracket: #(
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
getoken()
elif token.token == comma:
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "call", 27)
emit(0, "add", 1)
emit(0, "return", 0)
else:emit(0,"return", 0)
if token.token == rightbracket:
getoken()
"""
if token.token == idsym: #a
factor()
if token.token == rightbracket: #)
tokenNames[token.token]= "addup_a"
print "#token:-",tokenNames[token.token]
getoken()
if token.token == leftbrace:
getoken()
if token.token == idsym:
factor()
if token.token == assignsym:
getoken()
if token.token == number:
factor()
if token.token == semicolon:
getoken()
if token.token ==returnvalue:
getoken()
if token.token == idsym:
factor()
tokenNames[token.token]= "return_a"
print "#token:-",tokenNames[token.token]
getoken()
else: error("Return expected")
if token.token == semicolon:
getoken()
if token.token ==return_a:
emit(0,"return", addup_a)
getoken()
else: error("Return_a expected")
if token.token == semicolon:
getoken()
if token.token == rightbrace:
getoken()
"""
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('1Parameter.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
srcfile = open('1Parameter.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print "#"+repr(token)
emit(0, "load", 0)
emit(100, "constant", "'A'")
emit(101, "constant", "'P'")
emit(102, "constant", "'P'")
emit(103, "constant", "'L'")
emit(104, "constant", "'E'")
main()
#getoken()
| Python |
'''
Created on Jun 23, 2014
@author: Brian
'''
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken","programsym", "idsym", "assignsym", "leftbrace", "rightbrace","comma",
"varsym","functionsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym","printmsg", "ifsym", "elsesym","declaresym","forsym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","addup","addup_1",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","ex","remainder","returnvalue","return_a", "endfile"]
# define the tokens as variables
unknownToken,programsym, idsym, assignsym, leftbrace, rightbrace, comma,\
varsym,functionsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym,printmsg, ifsym, elsesym,declaresym, forsym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, addup,addup_1,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,ex,remainder,returnvalue,return_a, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('function', functionsym) # function
addToSymTbl('program', programsym) # function
addToSymTbl('declare', declaresym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', forsym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('printmsg', printmsg)#PRINTMESSAGE
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('addup', addup)#ADDUP
addToSymTbl('addup(1)',addup_1)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '!', ex)
addToSymTbl( '%', remainder)
addToSymTbl( ',', comma)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
addToSymTbl( 'return', returnvalue)
addToSymTbl( 'return a', return_a)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in [",", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%", EOF]:
token = lookup(ch) # preloaded with appropriate token
# special characters
# check ==
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check ==
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check <=
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check >=
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["addup"]:
ch = getch()
addup_a = "addup(a)"
if ch == "(":
ch = getch()
if ch == "a":
ch = getch()
if ch == ")":
char = addup_a
else:
token = lookup(ch)
else:
token = lookup(ch)
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif token.token ==return_a:
emit(0,"return", 0)
getoken()
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
elif token.token == assignsym: getoken()
else: error("semicolon expected in declaration")
#===============================================================================
def parameters(value1):
#<parameters> ::= (<value>)
#===============================================================================
global va1;
if token.token == leftbracket:getoken();
#1st variable
if token.token == number:
emit(0, "loadv", token.value)
if token.token == rightbracket: getoken();
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == printmsg:
printMsg()
elif token.token == addup:
addup()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == varsym:
vars()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == functionsym:
functionStmt()
elif token.token == rightbrace:
print("")
elif token.token == semicolon:
print("")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
print("#Print String APPLE to memory")
emit(0, "loadv", 100)
emit(0, "store", 1)
emit(0, "call", 40)
emit(40, "load-Ind", 0)
emit(41, "jumpeq", 45)
emit(42, "writech",150)
emit(43, "increment", 1)
emit(44, "jump", 40)
emit(45, "return", 0)
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("")
elif token.token == greaterthanequal: print("")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 1) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "call", 27)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("#!=")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == semicolon: getoken()
elif token.token == rightbrace: print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> <function> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == programsym:
# print "name",tokenNames[token.token]
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym: getoken()
else: error("Program error - Program name expected")
if token.token == semicolon: getoken()
else: error("Program error - Semicolon 1 expected")
if token.token == declaresym :
vars()
if token.token == varsym :
vars()
if token.token == functionsym:
functionStmt()
if token.token == leftbrace:
getoken()
if token.token == printsym:
print("#print")
getoken()
if token.token == leftbracket: #(
getoken()
else: error(" ( expected")
#=================================================
# Start Function
#=================================================
if token.token == addup:
functionStmt()
#=================================================
# End Function
#=================================================
stmtList()
#=================================================
def functionStmt():
#=================================================
# <function> ::= { <id>; <vars > <stmtlist> }
#<parameters>::= <var>, <var>
print("#Start of Function")
getoken(); #skip function - already been recognised
# function name called addup
#combine addup(a) into one token
if token.token == addup: #addup
getoken();
if token.token == leftbracket: #(
getoken()
else: error("Function error: ( expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
emit(0, "call", 27)
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: rightbracket expected")
if token.token == rightbracket:
emit(27, "loadv", 1)
emit(28, "add", 1)
emit(29, "add", 200)
emit(30, "add", 201)
emit(31, "store", 1)
emit(32, "return", 0)
getoken()
else: error("Function error: rightbracket expected")
if token.token == semicolon:
emit(0, "writeInt", 0)
getoken()
else: error("Function error: semicolon expected")
if token.token == idsym:
if token.name == "n":
tokenNames[token.token]= "addup_n"
print "#token:-",tokenNames[token.token],"\n"
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
#c=4;
#c aka local variable;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 200)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of c=4;
#b=6;
#c aka local variable;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 201)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of c=6;
# n=n+1;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == number:
# emit(0, "loadv", token.value)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of n=n+1;
#return n+c+b;
if token.token == returnvalue:getoken()
else: error("Function error: return expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end return n+c;
#===============================================================================
def addup_a():
#===============================================================================
"""
emit(27, "add", 1)
emit(28, "return", 0)
"""
if token.token == leftbracket: #(
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
getoken()
elif token.token == comma:
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "call", 27)
emit(0, "add", 1)
emit(0, "return", 0)
else:emit(0,"return", 0)
if token.token == rightbracket:
getoken()
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('function_local.txt', 'r')
line = srcfile.read() # readline
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
srcfile = open('function_local.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print "#"+repr(token)
emit(0, "load", 0)
emit(100, "constant", "'A'")
emit(101, "constant", "'P'")
emit(102, "constant", "'P'")
emit(103, "constant", "'L'")
emit(104, "constant", "'E'")
main()
#getoken()
| Python |
'''
Created on Jun 23, 2014
@author: Brian
'''
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken","programsym", "idsym", "assignsym", "leftbrace", "rightbrace","comma",
"varsym","functionsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym","printmsg", "ifsym", "elsesym","declaresym","forsym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","addup","addup_1",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","ex","remainder","returnvalue","return_a", "endfile"]
# define the tokens as variables
unknownToken,programsym, idsym, assignsym, leftbrace, rightbrace, comma,\
varsym,functionsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym,printmsg, ifsym, elsesym,declaresym, forsym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, addup,addup_1,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,ex,remainder,returnvalue,return_a, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('function', functionsym) # function
addToSymTbl('program', programsym) # function
addToSymTbl('declare', declaresym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', forsym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('printmsg', printmsg)#PRINTMESSAGE
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('addup', addup)#ADDUP
addToSymTbl('addup(1)',addup_1)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '!', ex)
addToSymTbl( '%', remainder)
addToSymTbl( ',', comma)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
addToSymTbl( 'return', returnvalue)
addToSymTbl( 'return a', return_a)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in [",", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%", EOF]:
token = lookup(ch) # preloaded with appropriate token
# special characters
# check ==
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check ==
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check <=
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check >=
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["addup"]:
ch = getch()
addup_a = "addup(a)"
if ch == "(":
ch = getch()
if ch == "a":
ch = getch()
if ch == ")":
char = addup_a
else:
token = lookup(ch)
else:
token = lookup(ch)
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif token.token ==return_a:
emit(0,"return", 0)
getoken()
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
elif token.token == assignsym: getoken()
else: error("semicolon expected in declaration")
#===============================================================================
def parameters(value1):
#<parameters> ::= (<value>)
#===============================================================================
global va1;
if token.token == leftbracket:getoken();
#1st variable
if token.token == number:
emit(0, "loadv", token.value)
if token.token == rightbracket: getoken();
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == printmsg:
printMsg()
elif token.token == addup:
addup()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == varsym:
vars()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == functionsym:
functionStmt()
elif token.token == rightbrace:
print("")
elif token.token == semicolon:
print("")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
print("#Print String APPLE to memory")
emit(0, "loadv", 100)
emit(0, "store", 1)
emit(0, "call", 40)
emit(40, "load-Ind", 0)
emit(41, "jumpeq", 45)
emit(42, "writech",150)
emit(43, "increment", 1)
emit(44, "jump", 40)
emit(45, "return", 0)
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("")
elif token.token == greaterthanequal: print("")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 1) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "call", 27)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("#!=")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == semicolon: getoken()
elif token.token == rightbrace: print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> <function> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == programsym:
# print "name",tokenNames[token.token]
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym: getoken()
else: error("Program error - Program name expected")
if token.token == semicolon: getoken()
else: error("Program error - Semicolon 1 expected")
if token.token == declaresym :
vars()
if token.token == varsym :
vars()
if token.token == functionsym:
functionStmt()
if token.token == leftbrace:
getoken()
if token.token == printsym:
print("#print")
getoken()
if token.token == leftbracket: #(
getoken()
else: error(" ( expected")
#=================================================
# Start Function
#=================================================
if token.token == addup:
functionStmt()
#=================================================
# End Function
#=================================================
stmtList()
#=================================================
def functionStmt():
#=================================================
# <function> ::= { <id>; <vars > <stmtlist> }
#<parameters>::= <var>, <var>
print("#Start of Function")
getoken(); #skip function - already been recognised
# function name called addup
#combine addup(a) into one token
if token.token == addup: #addup
getoken();
if token.token == leftbracket: #(
getoken()
else: error(" ( expected")
if token.token == number:
emit(0,"loadv", token.value)
emit(0, "store", 1)
getoken()
if token.token == comma:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
getoken()
if token.token == rightbracket:
getoken()
if token.token == rightbracket:
emit(0, "call", 28)
emit(28, "add", 1)
emit(29, "store", 1)
emit(30, "return", 0)
getoken()
if token.token == semicolon:
emit(0, "writeInt", 0)
getoken()
if token.token == idsym:
if token.name == "n":
tokenNames[token.token]= "addup_n"
print "#token:-",tokenNames[token.token]
getoken()
if token.token == comma: getoken()
if token.name == "m":
tokenNames[token.token]= "addup_m"
print "#token:-",tokenNames[token.token]
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == returnvalue:getoken()
else: error("Function error: return expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
print("#End of function define \n")
#===============================================================================
def addup_a():
#===============================================================================
"""
emit(27, "add", 1)
emit(28, "return", 0)
"""
if token.token == leftbracket: #(
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
getoken()
elif token.token == comma:
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "call", 27)
emit(0, "add", 1)
emit(0, "return", 0)
else:emit(0,"return", 0)
if token.token == rightbracket:
getoken()
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('parameter_more.txt', 'r')
line = srcfile.read() # readline
# for line in open('tiny.txt', 'r'):
# if not line.startswith("#"):
# debugScanner = False
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
srcfile = open('parameter_more.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print "#"+repr(token)
emit(0, "load", 0)
emit(100, "constant", "'A'")
emit(101, "constant", "'P'")
emit(102, "constant", "'P'")
emit(103, "constant", "'L'")
emit(104, "constant", "'E'")
main()
#getoken()
| Python |
'''
Created on Jun 23, 2014
@author: Brian
'''
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
import math
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken","programsym", "idsym", "assignsym", "leftbrace", "rightbrace","comma",
"varsym","functionsym", "semicolon", "whilesym", "leftbracket", "rightbracket","quote",
"printsym","printmsg", "ifsym", "elsesym","declaresym","forsym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","addup","addup_1","fact","stringsym",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","ex","remainder","returnvalue","return_a", "endfile"]
# define the tokens as variables
unknownToken,programsym, idsym, assignsym, leftbrace, rightbrace, comma,\
varsym,functionsym, semicolon, whilesym, leftbracket, rightbracket,quote,\
printsym,printmsg, ifsym, elsesym,declaresym, forsym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, addup,addup_1,fact,stringsym,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,ex,remainder,returnvalue,return_a, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('function', functionsym) # function
addToSymTbl('program', programsym) # function
addToSymTbl('declare', declaresym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', forsym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('printmsg', printmsg)#PRINTMESSAGE
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('addup', addup)#ADDUP
addToSymTbl('addup(1)',addup_1)
addToSymTbl('fact', fact)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '!', ex)
addToSymTbl( '%', remainder)
addToSymTbl( ',', comma)
addToSymTbl("Factorial of 5 is", stringsym)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
addToSymTbl( 'return', returnvalue)
addToSymTbl( 'return a', return_a)
addToSymTbl( '"',quote)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in [",", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%",'"', EOF]:
token = lookup(ch) # preloaded with appropriate token
# special characters
# check ==
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check ==
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check <=
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check >=
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif token.token ==return_a:
emit(0,"return", 0)
getoken()
else:
print "#Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
elif token.token == assignsym: getoken()
else: error("semicolon expected in declaration")
#===============================================================================
def parameters(value1):
#<parameters> ::= (<value>)
#===============================================================================
global va1;
if token.token == leftbracket:getoken();
#1st variable
if token.token == number:
emit(0, "loadv", token.value)
if token.token == rightbracket: getoken();
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == printmsg:
printMsg()
elif token.token == addup:
addup()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == varsym:
vars()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == functionsym:
functionStmt()
elif token.token == rightbrace:
print("")
elif token.token == semicolon:
print("")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
print("#Print String APPLE to memory")
emit(0, "loadv", 100)
emit(0, "store", 1)
emit(0, "call", 40)
emit(40, "load-Ind", 0)
emit(41, "jumpeq", 45)
emit(42, "writech",150)
emit(43, "increment", 1)
emit(44, "jump", 40)
emit(45, "return", 0)
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("")
elif token.token == greaterthanequal: print("")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 1) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "call", 27)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("#!=")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == semicolon: getoken()
elif token.token == rightbrace: print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> <function> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == programsym:
# print "name",tokenNames[token.token]
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym: getoken()
else: error("Program error - Program name expected")
if token.token == semicolon: getoken()
else: error("Program error - Semicolon 1 expected")
if token.token == declaresym :
vars()
getoken()
if token.token == varsym :
print("Decare "+token.name)
vars()
getoken()
if token.token == functionsym:
getoken()
if token.token == fact:
functionStmt()
getoken()
#print ("Factorial of 5 is ", factor(5));
if token.token == printsym:
print("#print factorial"+"\n")
getoken()
else: error("program error - print expected")
if token.token == leftbracket:
getoken()
else: error("program error - ( expected")
if token.token == quote:getoken()
else: error("program error - ' expected")
if token.token == idsym:
print("#"+token.name+""),
getoken()
else: error("program error - stringsym expected")
if token.token == idsym:
print(token.name+""),
getoken()
else: error("program error - stringsym expected")
if token.token == number:
print(str(token.value)+""),
getoken()
else: error("program error - stringsym expected")
if token.token == idsym:
print(token.name+"")
getoken()
else: error("program error - stringsym expected")
if token.token == quote:getoken()
else: error("program error - ' expected")
if token.token == comma:getoken()
if token.token == fact: functionStmt()
#}
if token.token == rightbrace:
getoken()
else:error("program error - } expected")
#=================================================
def functionStmt():
#=================================================
# <function> ::= { <id>; <vars > <stmtlist> }
#<parameters>::= <var>, <var>
#
getoken(); #skip function - already been recognised
# function name called addup
#combine addup(a) into one token
if token.token == fact: #addup
getoken();
if token.token == leftbracket: #(
getoken()
else: error("Function error: ( expected")
if token.token == number:
if token.value == 1:
emit(0, "loadv", 1)
emit(0, "store", 1)
emit(0, "writeInt", 0)
getoken()
else:
emit(0, "loadv", token.value)
emit(0, "store", 300)
emit(0, "call", 27)
getoken()
if token.token == rightbracket:
emit(28, "subtract", 105) #4
emit(29, "store",301)
emit(30, "subtract", 105) #3
emit(31, "store", 302)
emit(32, "subtract", 105) #2
emit(33, "store", 303)
emit(34, "subtract", 105) #1
emit(35, "mpy", 300)
emit(36, "mpy", 301)
emit(37, "mpy", 302)
emit(38, "mpy", 303)
emit(39, "store", 1)
getoken()
# else: error("Function error: rightbracket expected")
if token.token == rightbracket:
getoken()
# else: error("Function error: rightbracket expected")
if token.token == semicolon:
emit(0, "writeInt", 0)
print("#The Factorial of 5 is" +" "+ str(math.factorial(5)))
print("\n#*** Compilation finished ***\n")
getoken()
# else: error("Function error: semicolon expected")
if token.token == idsym:
print("#Start of Function")
if token.name == "n":
tokenNames[token.token]= "fact_n"
print "#token:-",tokenNames[token.token],"\n"
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
#if (n==1) return(1);
if token.token == ifsym:getoken()
else: error("Function error: idsym expected")
if token.token == leftbracket:getoken()
else: error("Function error: ( expected")
if token.token == idsym: factor()
if token.token == jumpeq:getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 200)
getoken()
else: error("Function error: assignsym expected")
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
#return (1);
if token.token == returnvalue:getoken()
else: error("Function error: return expected")
if token.token == leftbracket:getoken()
else: error("Function error: ( expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 201)
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon: getoken()
else: error("Function error: ; expected")
#else{
if token.token == elsesym: getoken()
else: error("Function error: else expected")
if token.token == leftbrace: getoken()
else: error("Function error: { expected")
#factN1=n-1;
if token.token == idsym:
if token.name == "factN1":
print("#Token name:"+token.name+"\n")
getoken()
if token.token == assignsym:getoken()
if token.token == idsym:getoken()
if token.token == minus:
# print("#min"+"\n")
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 202)
getoken()
if token.token == semicolon:getoken()
#return(n*fact(factN1));
if token.token == returnvalue:getoken()
if token.token == leftbracket:getoken()
if token.token == idsym: getoken()
if token.token == mpy: getoken()
if token.token == idsym: getoken()
if token.name == "fact":getoken()
if token.token == leftbracket:getoken()
if token.name =="factN1":getoken()
if token.token == rightbracket:getoken()
if token.token == rightbracket:getoken()
if token.token == semicolon:getoken()
#};
if token.token == rightbrace:getoken()
if token.token == semicolon:getoken()
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('recursion_function.txt', 'r')
line = srcfile.read() # readline
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
"""srcfile = open('recursion_function', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print "#"+repr(token)
"""
emit(0, "load", 0)
emit(100, "constant", "'A'")
emit(101, "constant", "'P'")
emit(102, "constant", "'P'")
emit(103, "constant", "'L'")
emit(104, "constant", "'E'")
emit(105, "constant", "1")
main()
#getoken()
| Python |
'''
Created on Jun 23, 2014
@author: Brian
'''
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <vars > <stmtlist> }
<vars> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= (+|-) ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames =\
[ "unknownToken","programsym", "idsym", "assignsym", "leftbrace", "rightbrace","comma",
"varsym","functionsym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym","printmsg", "ifsym", "elsesym","declaresym","forsym", "equals", "notequals", "lessthan", "greaterthan",
"readch", "readint", "writech", "writeint","addup","addup_1",
"number", "plus", "minus", "mpy", "div", "jumpne", "jumpeq","lessthanequal","greaterthanequal","ex","remainder","returnvalue","return_a", "endfile"]
# define the tokens as variables
unknownToken,programsym, idsym, assignsym, leftbrace, rightbrace, comma,\
varsym,functionsym, semicolon, whilesym, leftbracket, rightbracket,\
printsym,printmsg, ifsym, elsesym,declaresym, forsym, equals, notequals, lessthan, greaterthan,\
readch, readint, writech, writeint, addup,addup_1,\
number, plus, minus, mpy, div, jumpne, jumpeq, lessthanequal, greaterthanequal,ex,remainder,returnvalue,return_a, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value = 0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber= 0 # The current number
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varsym) # VAR
addToSymTbl('function', functionsym) # function
addToSymTbl('program', programsym) # function
addToSymTbl('declare', declaresym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('for', forsym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('printmsg', printmsg)#PRINTMESSAGE
addToSymTbl('if', ifsym) # IF
addToSymTbl('else', elsesym) # ELSE
addToSymTbl('readint', readint) #READINT
addToSymTbl('writeint', writeint) #READINT
addToSymTbl('readch', readch) #READINT
addToSymTbl('writech', writech) #READINT
addToSymTbl('addup', addup)#ADDUP
addToSymTbl('addup(1)',addup_1)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl( '=', assignsym)
addToSymTbl( '#', notequals)
addToSymTbl( '<', lessthan) #jumplt
addToSymTbl( '>', greaterthan) #jumpgt
addToSymTbl( '{', leftbrace )
addToSymTbl( '}', rightbrace)
addToSymTbl( '(', leftbracket)
addToSymTbl( ')', rightbracket)
addToSymTbl( '+', plus )
addToSymTbl( '-', minus)
addToSymTbl( '*', mpy)
addToSymTbl( '/', div)
addToSymTbl( ';', semicolon)
addToSymTbl( '!', ex)
addToSymTbl( '%', remainder)
addToSymTbl( ',', comma)
addToSymTbl( EOF, endfile)
#multicharacter one like ">=" are still to do
addToSymTbl( '==', jumpeq)
addToSymTbl( '!=', jumpne)
addToSymTbl( '<=', lessthanequal) #jumplt
addToSymTbl( '>=', greaterthanequal) #jumpgt
addToSymTbl( 'return', returnvalue)
addToSymTbl( 'return a', return_a)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d" %\
(tokenNames[tok.token], tok.name, tok.address)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print(" *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex+1 # & move pointer for next time
else:
#line = srcfile.readline()
if line == "": line = EOF
#print "--> ",
line = raw_input() +"\n" # read new line, adding \n so it's like f.readline()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " " # A newline is a token separator
if ch == "?":
dumpSymTbl()
continue
if ch == "#":
print "#Comment Found"
srcfile.read()
print "#Read next line"
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex-1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n", "#"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
#---------------------------------------------------------------------
# If it's numeric return TOKEN=number & token.value = binary value
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
token = symbol(ch, number, value = int(ch)) # simplistic SINGLE DIGIT Ascii to Binary
return
#---------------------------------------------------------------------
# Single character tokens
elif ch in [",", "{", "}", "(", ")", "+" , "-", "*", "/", ";","%", EOF]:
token = lookup(ch) # preloaded with appropriate token
# special characters
# check ==
elif ch in ["!"]:
ch = getch()
char = "!"
nEqual = "!="
if ch == "=":
char = nEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check ==
elif ch in ["="]:
ch = getch()
char = "="
Equal = "=="
if ch == "=":
char = Equal
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check <=
elif ch in ["<"]:
ch = getch()
char = "<"
lessthanEqual = "<="
if ch == "=":
char = lessthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
# check >=
elif ch in [">"]:
ch = getch()
char = ">"
greatthanEqual = ">="
if ch == "=":
char = greatthanEqual
ch = getch()
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif ch in ["addup"]:
ch = getch()
addup_a = "addup(a)"
if ch == "(":
ch = getch()
if ch == "a":
ch = getch()
if ch == ")":
char = addup_a
else:
token = lookup(ch)
else:
token = lookup(ch)
else:
token = lookup(ch)
ungetch()
token = lookup(char)
if token is None:
token = addToSymTbl(char, idsym)
return
elif token.token ==return_a:
emit(0,"return", 0)
getoken()
else:
print "Unknown character -->%s<- decimal %d" % (ch,ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <vars > <stmtlist> }
# <vars> ::= var { <id> ; } % DECLARATIONS
# <array> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <factor> { (+ | -) <factor> } % No precedence
# <factor> ::= [+/-] ID | Number
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex,"^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr+1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#======================================================================
# VARIABLE DECLARATIONS
# <vars> ::= V { <id> ; }
#===============================================================================
def vars() :
#===============================================================================
global varptr;
getoken(); #skip VARSYM - already been recognised
while (token.token == idsym):
if token.address != 0:
print("%c already declared\n", token.name);
else:
symtbl[token.name].address = varptr;
varptr = varptr +1
getoken(); #skip past identifier
if token.token == semicolon: getoken() #skip ;
elif token.token == assignsym: getoken()
else: error("semicolon expected in declaration")
#===============================================================================
def parameters(value1):
#<parameters> ::= (<value>)
#===============================================================================
global va1;
if token.token == leftbracket:getoken();
#1st variable
if token.token == number:
emit(0, "loadv", token.value)
if token.token == rightbracket: getoken();
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token == semicolon):
getoken() #skip ;
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression> | <id> = <expression> | if <expression> | while <expression>
"""
global codeptr
# thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
if token.token == printsym:
printStmt()
elif token.token == printmsg:
printMsg()
elif token.token == addup:
addup()
elif token.token == idsym:
assignStmt()
elif token.token == assignsym:
getoken()
elif token.token == varsym:
vars()
elif token.token == ifsym:
ifStmt()
elif token.token == elsesym:
elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == readint:
readIntStmt()
elif token.token == readch:
readChStmt()
elif token.token == writeint:
writeIntStmt()
elif token.token == writech:
writeChStmt()
elif token.token == functionsym:
functionStmt()
elif token.token == rightbrace:
print("")
elif token.token == semicolon:
print("")
else:
error("Expected start of a statement")
# emit (0, "return", thisStmtAdr) # Jump DEMO
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression>"""
getoken() # skip "print"
expression() # on return, expr result (at runtime) will be in ACC
emit(0, "writeint", 0) # Memory address 0 is the ACC
if token.token == rightbrace:
print("#\n*** Compilation finished ***\n")
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
print("#Print String APPLE to memory")
emit(0, "loadv", 100)
emit(0, "store", 1)
emit(0, "call", 40)
emit(40, "load-Ind", 0)
emit(41, "jumpeq", 45)
emit(42, "writech",150)
emit(43, "increment", 1)
emit(44, "jump", 40)
emit(45, "return", 0)
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
whichidentifier = token # Remember which ID on Left
getoken() # Get token after identifier
if token.token == notequals: # skip # then read next line
srcfile.read()
getoken()
elif token.token == assignsym: #if the next token is =
expression()
elif token.token == idsym: factor()
elif token.token == jumpeq: print("#")
elif token.token == jumpne: print("#")
elif token.token == lessthanequal: print("")
elif token.token == greaterthanequal: print("")
elif token.token == semicolon: getoken()
else:
error("Expected = in assignment statement")
expression()
# Save result into LHS runtime address
#===============================================================================
def ifStmt():
#if-then-else
#===============================================================================
""" <ifStmt> ::= if <expression>"""
getoken() # skip "if"
emit(0, "compare",60)
expression()
stmt()
emit(0, "return",0)
#===============================================================================
def elseStmt():
#if-then-else
#===============================================================================
""" <elseStmt> ::= else <expression>"""
getoken()
emit(0, "store", 888)
stmt()
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken() # skip "if"
emit(0, "compare",50)
expression()
stmt()
emit(0, "increment", 1)
emit(0, "jumpi", 14)
#===============================================================================
def readIntStmt():
#===============================================================================
getoken()
expression() # skip "if"
emit(0, "readint",999)
#===============================================================================
def readChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "readch",11)
#===============================================================================
def writeIntStmt():
#===============================================================================
getoken() # skip "if"
expression()
emit(0, "writeint",50)
#===============================================================================
def writeChStmt():
#===============================================================================
getoken() # skip "if"
emit(0, "writech",51)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 998 as Temporary variables
<expression> ::= <factor> { (+ | - | * | /) <factor> }
"""
factor()
while token.token == plus or token.token == minus:
op = token # remember +/-
getoken() # skip past +/-
emit(0, "store", 1) # Save current result
factor() # Evaluate next factor
#working
if op.token == plus: #+
emit(0, "call", 27)
elif op.token == minus: # - Subtract - have to swap operand order
emit(0, "store", 998)
emit(0, "load" , 999)
emit(0, "subtract", 998) # Leaves result in Acc
emit(0, "store", 880)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= (+|-) identifier | number
"""
#Numbers
if token.token == idsym:
emit(0, "load", token.address)
getoken()
elif token.token == number:
emit(0, "loadv", token.value)
getoken()
elif token.token == assignsym:getoken()
elif token.token == jumpeq:
print("#==")
elif token.token == jumpne:
print("#!=")
elif token.token == lessthanequal:
print("#<=")
elif token.token == greaterthanequal:
print("#<=")
elif token.token == semicolon: getoken()
elif token.token == rightbrace: print("")
else: error("Start of Factor expected")
#===============================================================================
def program():
#===============================================================================
""" # PROGRAM - Start production of the grammar
# <program> <function> ::= { <id> ; <vars > <stmtlist> }
"""
if token.token == programsym:
# print "name",tokenNames[token.token]
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym: getoken()
else: error("Program error - Program name expected")
if token.token == semicolon: getoken()
else: error("Program error - Semicolon 1 expected")
if token.token == declaresym :
vars()
if token.token == varsym :
vars()
if token.token == functionsym:
functionStmt()
if token.token == addup:
functionStmt()
if token.token == rightbrace:
getoken()
else: error("program error - } expected")
if token.token == semicolon:
getoken()
if token.token == leftbrace:
getoken()
if token.token == printsym:
print("#print")
getoken()
if token.token == leftbracket: #(
getoken()
else: error("program error - ( expected")
#=================================================
# Start Function
#=================================================
if token.token == addup:
functionStmt()
#=================================================
# End Function
#=================================================
if token.token == plus:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "add", 1)
emit(0, "writeInt", 1)
#=================================================
def functionStmt():
#=================================================
# <function> ::= { <id>; <vars > <stmtlist> }
#<parameters>::= <var>, <var>
print("#Start of Function")
getoken(); #skip function - already been recognised
# function name called addup
#combine addup(a) into one token
if token.token == addup: #addup
getoken();
if token.token == leftbracket: #(
getoken()
else: error("Function error: ( expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
emit(0, "call", 27)
getoken()
if token.token == rightbracket:
emit(27, "loadv", 1)
emit(28, "add", 1)
emit(29, "add", 200)
emit(30, "add", 201)
emit(31, "store", 1)
emit(32, "return", 0)
getoken()
# else: error("Function error: rightbracket expected")
if token.token == semicolon:
emit(0, "writeInt", 0)
getoken()
# else: error("Function error: semicolon expected")
if token.token == idsym:
if token.name == "n":
tokenNames[token.token]= "addup_n"
print "#token:-",tokenNames[token.token],"\n"
getoken()
if token.token == rightbracket:getoken()
else: error("Function error: ) expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
if token.token == leftbrace:getoken()
else: error("Function error: { expected")
#c=4;
#c aka local variable;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 200)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of c=4;
#b=6;
#c aka local variable;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 201)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of c=6;
# n=n+1;
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == assignsym:getoken()
else: error("Function error: assignsym expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == number:
# emit(0, "loadv", token.value)
getoken()
else: error("Function error: assignsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end of n=n+1;
#return n+c+b;
if token.token == returnvalue:getoken()
else: error("Function error: return expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == plus:getoken()
else: error("Function error: plus expected")
if token.token == idsym:getoken()
else: error("Function error: idsym expected")
if token.token == semicolon:getoken()
else: error("Function error: semicolon expected")
#end return n+c;
#===============================================================================
def addup_a():
#===============================================================================
"""
emit(27, "add", 1)
emit(28, "return", 0)
"""
if token.token == leftbracket: #(
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "store", 1)
getoken()
elif token.token == comma:
getoken()
if token.token == idsym:
getoken()
if token.token == number:
emit(0, "loadv", token.value)
emit(0, "call", 27)
emit(0, "add", 1)
emit(0, "return", 0)
else:emit(0,"return", 0)
if token.token == rightbracket:
getoken()
# Compiler main function
#======================================================================
def main():
#======================================================================
global line
global srcfile
global outfile
global charIndex
initSymTbl()
srcfile = open('function_with_expression.txt', 'r')
line = srcfile.read() # readline
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# outfile.write(token)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program() # Call start non-terminal handler
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
srcfile = open('function_with_expression.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print "#"+repr(token)
emit(0, "load", 0)
emit(100, "constant", "'A'")
emit(101, "constant", "'P'")
emit(102, "constant", "'P'")
emit(103, "constant", "'L'")
emit(104, "constant", "'E'")
main()
#getoken()
| Python |
import re
__author__ = 'YeeHin Kwok'
""" Giovanni's MicroCompiler Demo
<program> ::= { <id> ; <varDeclare > <stmtlist> }
<varDeclare> ::= V { <id> ; } % DECLARATIONS
<stmtlist> ::= <stmt> { ; <stmt> }
<stmt> ::= P <id> | <id> = <expr>
<expr> ::= <factor> { (+ | -) <factor> } % No precedence
<factor> ::= ID | Number
"""
import sys
import shlex
#===============================================================================
# # Lexical Analyser - the "Scanner" - Define the TokenTypes
#===============================================================================
tokenNames = \
[ "unknownToken", "idsym", "assignsym", "leftbrace", "rightbrace",
"varDeclareym", "semicolon", "whilesym", "leftbracket", "rightbracket",
"printsym", "ifsym", "equals", "lessthan", "greaterthan",
"number", "plus", "minus", "mpy", "div", "elsesym", "declaresym", "forsym", "andsym", "elifsym", "dosym", "returnsym", "notsym",
"continuesym", "breaksym", "nonesym", "programsym", "functionsym", "leftsquarebracket", "rightsquarebracket",
"lessthanequal", "colon", "comma", "comment", "commentstr", "dot", " greaterthanequal", "jumpeq", "jumpne",
"andop", "orop", "quote ", "stringsym", "arraySubsym", "readsym", "endfile"]
# define the tokens as variables
unknownToken, idsym, assignsym, leftbrace, rightbrace, \
varDeclareym, semicolon, whilesym, leftbracket, rightbracket, \
printsym, ifsym, equals, lessthan, greaterthan, \
number, plus, minus, mpy, div, elsesym, declaresym, forsym, andsym, elifsym, dosym, returnsym, notsym, \
continuesym, breaksym, nonesym, programsym, functionsym, leftsquarebracket, rightsquarebracket, \
lessthanequal, colon, comma, comment, commentstr, dot, greaterthanequal, jumpeq, jumpne, \
andop, orop, quote, stringsym, arraySubsym, readsym, endfile = range(0, len(tokenNames))
#===============================================================================
class symbol:
#===============================================================================
name = None # String representation
token = None; # Corresponding token
address = 0; # For variables, their runtime address
value = None # on defined for numbers
def __init__(self, name, token, value=0):
self.name = name
self.token = token
self.address = 0 # for identifiers, their address
self.value = value # for numbers, their value
symtbl = {}; # The Symbol Table, a dictionary of symbols indexed by name
#======================================================================
# GLOBALS for output of Lexical Analyser
# Set by each call to GeToken()
token = None; # A symbol
line = "\n" # the complex source file as a string
charIndex = 0 # the position in the source
linenumber = 0 # The current number
tokennum = 0
resultnum = 0
whichidentifier = None;
identifieraddress = 0;
arraySubaddress = 0;
arrstar = 0;
returnadd = 0;
i = 700
j = 700
counterafter = i
counterafter1 = j
EOF = chr(0)
#======================================================================
# Run Time Code Generation Variables
varptr = 500 # Arbitrary base address of memory for variables
codeptr = 10 # Address to output next instruction (for code)
#===============================================================================
# Symbol Table Management Routines
#===============================================================================
#===============================================================================
def addToSymTbl (name, token):
#===============================================================================
symtbl[name] = symbol(name, token) # Add a new symbol to the dictionary
return symtbl[name]
#===============================================================================
def lookup (thisName):
#===============================================================================
"# Find a given identifier in the Symbol Table, Return the symtbl entry"
if symtbl.has_key(thisName): # thisName has been seen before
return symtbl[thisName] # return the symtbl entry
else: return None
#===============================================================================
def initSymTbl():
#===============================================================================
"# Initialise Symbol Table, and preload reserved words"
addToSymTbl('var', varDeclareym) # VAR
addToSymTbl('program', programsym)
addToSymTbl('function', functionsym)
addToSymTbl('while', whilesym) # WHILE
addToSymTbl('print', printsym) # PRINT
addToSymTbl('else', elsesym)
addToSymTbl('elif', elifsym)
addToSymTbl('if', ifsym)
addToSymTbl('declare', declaresym)
addToSymTbl('for', forsym)
addToSymTbl('None', nonesym)
addToSymTbl('continue', continuesym)
addToSymTbl('read', readsym) # READINT
addToSymTbl('do', dosym)
addToSymTbl('return', returnsym)
addToSymTbl('not', notsym)
# Now add symbols - NB only single character symbols are here
# multicharacter one like ">=" are still to do
addToSymTbl('=', assignsym)
addToSymTbl('#', comment)
addToSymTbl('<', lessthan)
addToSymTbl('>', greaterthan)
addToSymTbl('{', leftbrace)
addToSymTbl('}', rightbrace)
addToSymTbl('(', leftbracket)
addToSymTbl(')', rightbracket)
addToSymTbl('+', plus)
addToSymTbl('-', minus)
addToSymTbl(';', semicolon)
addToSymTbl('break', breaksym)
addToSymTbl('*', mpy)
addToSymTbl('/', div)
addToSymTbl('[', leftsquarebracket)
addToSymTbl(']', rightsquarebracket)
addToSymTbl(':', colon)
addToSymTbl(',', comma)
addToSymTbl('.', dot)
addToSymTbl('==', jumpeq)
addToSymTbl('!=', jumpne)
addToSymTbl('&&', andop)
addToSymTbl('||', orop)
addToSymTbl('"', quote)
addToSymTbl(EOF, endfile)
#===============================================================================
# Scanner Diagnostics
#===============================================================================
def printToken(tok):
#===============================================================================
" - display the specified token."
if tok.token == idsym:
print "Token = %10s, %-10s adr = %3d, val = %d" % \
(tokenNames[tok.token], tok.name, tok.address, tok.value)
elif tok.token == number:
print "Token = %10s %d" % (tokenNames[tok.token], tok.value)
else:
print "Token = %10s" % tokenNames[tok.token]
#==============================?=================================================
def dumpSymTbl():
#===============================================================================
""" Dump all the tokens in the symboltable """
print("# *** Symbol Table ***")
for name in symtbl.keys(): # keys is a list of the names (printable form of tokens)
tok = symtbl[name]
if tok.token == idsym:
print("#"),
printToken(tok)
#===============================================================================
def getch():
#===============================================================================
global line
global charIndex
global linenumber
while True:
if charIndex < len(line): # See if used up current line
ch = line[charIndex] # if not, get character
charIndex = charIndex + 1 # & move pointer for next time
else:
# line = f.readline()
# if line == "": line = EOF
dumpSymTbl()
print "#End of File"
print "#--> ",
line = raw_input() + "\n" # read new line, adding \n so it's like f.readline()
# line = srcfile.read()
charIndex = 0 # & reset character pointer
linenumber = linenumber + 1
continue
if ch == "\n":
ch = " "
if ch == '?':
dumpSymTbl()
continue
return ch
#===============================================================================
def ungetch():
#===============================================================================
""" Unget the next character peeked at when building variables, numbers
and when distinguishing between >= and > ...
"""
global charIndex;
charIndex = charIndex - 1;
#===============================================================================
def getoken():
#===============================================================================
""" GETOKEN - Put next token into the global TOKEN """
global token
global i
global m
global counterafter
global counterafter1
x = 0
ch = getch() # skip whitespace
while ch in ["\t", " ", "\n"]:
ch = getch()
# If ch is alphabetic then this is start of reserved word or an identifier
if ch.isalpha(): # Letter therefore it's either identifier or reserved word
name = ""
while ch.isalpha() or ch.isdigit() or ch == "_":
name = name + ch
ch = getch()
ungetch() # let terminator be used next time
token = lookup(name) # See if token's known
if token is None: # if not
token = addToSymTbl(name, idsym) # add as 'idsym'-IDENTIFIER
return # we've set token.token to either id or tokentype of reserved word
elif ch in ["{", "}", "(", ")", "[", "]", "+", "-", "*", "/", ";", ",", ":", EOF]:
token = lookup(ch) # preloaded with appropriate token
elif ch.isdigit():
# In the real version, build number and don't forget to end with ungetch()
while(ch.isdigit() == True):
x = str(x) + str(ch)
ch = getch()
ch = ungetch()
token = symbol(x, number, value=int(x)) # simplistic SINGLE DIGIT Ascii to Binary
return
elif ch == '#':
str1 = ""
ch = getch()
while ch != " ":
str1 = str(str1) + str(ch)
ch = getch()
ch = getch()
# token = symbol(str1, commentstr, value=str(str1)) # simplistic SINGLE DIGIT Ascii to Binary
print("#comment: " + str(str1))
return
elif ch == '"':
a = ""
ch = getch()
counterafter1 = counterafter
i = counterafter
if counterafter != 700:
counterafter = counterafter + 4;
counterafter = i
while (ch != '"'):
a = str(a) + str(ch)
if ch != " ":
b = "'"+ch+"'"
emit(i, "constant",b)
ch = getch()
else:
ch = getch()
i=i+1
emit(i, "constant", 13)
emit(i+1, "constant", 0)
emit(i+2, "return", '')
ch = getch()
counterafter=i+3
token = symbol(a, stringsym, value=str(a)) # simplistic SINGLE DIGIT Ascii to Binary
return
elif ch == "<":
ch = getch()
if ch == "=":
lt = ""
lt = "<" + "="
token = symbol(lt, lessthanequal, value=str(lt)) # simplistic SINGLE DIGIT Ascii to Binary
return
else:
ch == ungetch()
token = symbol("<", lessthan, value="<") # simplistic SINGLE DIGIT Ascii to Binary
return
elif ch == "!":
ne = ""
ch = getch()
if ch == "=":
ne = "!" + "="
token = symbol(ne, jumpne, value=str(ne)) # simplistic SINGLE DIGIT Ascii to Binary
return
else:
ch == ungetch()
token = symbol("!", NOT , value="!") # simplistic SINGLE DIGIT Ascii to Binary
return
elif ch == "=":
eq = ""
ch = getch()
if ch == "=":
eq = "=" + "="
token = symbol(eq, jumpeq, value=str(eq)) # simplistic SINGLE DIGIT Ascii to Binary
return
else:
ch == ungetch()
token = symbol("=", assignsym, value="=") # simplistic SINGLE DIGIT Ascii to Binary
return
elif ch == ">":
gt = ""
ch = getch()
if ch == "=":
gt = ">" + "="
token = symbol(gt, greaterthanequal, value=str(gt)) # simplistic SINGLE DIGIT Ascii to Binary
return
else:
ch == ungetch()
token = symbol(">", greaterthan, value=">") # simplistic SINGLE DIGIT Ascii to Binary
return
else:
print "Unknown character -->%s<- decimal %d" % (ch, ord(ch))
sys.exit(1) # Abort Compilation
#======================================================================
# THE GRAMMAR
# <program> ::= { <id> ; <varDeclare > <stmtlist> }
# <varDeclare> ::= var { <id> ; } % DECLARATIONS
# <arraySub> ::= [<expr>]
# <stmtlist> ::= <stmt> { ; <stmt> }
# <stmt> ::= print <id>
# <id> = <expr>
# <expr> ::= <term> { (+ | - ) <term> }
# <term> ::= <factor> { (*|/) factor}
# <factor> ::= [+/-] ID | Number | expression
#======================================================================
# Centralised Parser Error Message handler
#======================================================================
#===============================================================================
def error (msg):
#===============================================================================
print line
print "-" * charIndex, "^"
print("Error on %d - %s\n" % (number, msg))
printToken(token)
print("\n")
#===============================================================================
def emit (memadr, opcode, parameter):
#===============================================================================
"""EMIT CODE - Emit a of code with a Parameter
if first arg is zero - (the memory address), use and incr CODEPTR"""
global codeptr
if (memadr == 0):
memadr = codeptr
codeptr = codeptr + 1
print "%6d %-8s %-7s" % (memadr, opcode, parameter)
#===============================================================================
def declareList() :
# declareList ::= varDeclare {, varDeclare};
#===============================================================================
varDeclare()
while token.token != semicolon :
if token.token == comma:
varDeclare()
getoken()
# else: error("comma or semicolon expected in declaration")
#===============================================================================
def varDeclare() :
# varDeclare ::= idsym [ = number | "[" number "]"
#===============================================================================
ta = 0
tn = []
global varptr;
global whichidaddress;
global arraySubaddress;
global arrstar;
getoken();
if token.token == idsym:
ta = token.address
tn = token.name
getoken()
if token.token == leftsquarebracket:
getoken()
if token.token == number: #number
print("#The address for "+ str(tn)+ " are ")
symtbl[tn].address = varptr;
# emit(0, "constant", varptr)
print("#"+str(varptr))
while (token.value != 0):
# print("#address at " + str(varptr))
varptr = varptr + 1
token.value= token.value-1
# emit(0, "constant", varptr)
print("#"+str(varptr))
# getoken()
getoken()
if token.token == rightsquarebracket:
getoken()
else:
error("Expected rightsquarebracket at the end of arraySub declare")
else:
if ta != 0:
print("#"),
print("%c already declared\n", tn);
# assignStmt()
else:
symtbl[tn].address = varptr;
varptr = varptr + 1;
# emit(0, "load", varptr)
"""
if token.token == assignsym:
getoken()
if token.token == number:
arraySubaddress = arrstar+token.value
whichidaddress = arraySubaddress
print"#"+"arraySub address", str(arraySubaddress)
getoken()
if token.token == rightsquarebracket:
stmt()
# getoken()
getoken()
"""
# if token.token == leftsquarebracket:
# varDeclare()
# getoken()
# if token.token == rightbracket:
# getoken()
#===============================================================================
def variable():
# idsym [arraySub]
#===============================================================================
if token.token == idsym:
arraySub()
#===============================================================================
def arraySub():
# [expression]
#===============================================================================
global arraySub;
expression()
#===============================================================================
def parameters():
#===============================================================================
varDeclare()
# getoken()
#======================================================================
# STMTLIST
# <stmtlist> ::= <stmt> { ; <stmt> }
#===============================================================================
def stmtList():
#===============================================================================
stmt()
while (token.token != rightbrace):
stmt()
#======================================================================
# STMT
#===============================================================================
def stmt():
#===============================================================================
""" <stmt> ::= print <expression|string>| read <varDeclare> | <id> = <expression> |
if <condition> <stmt> [else <stmt>]| while <condition> <stmt>|
<stmtList> | do <stmsList> forever | break | continue
"""
global codeptr
thisStmtAdr = codeptr # Jump DEMO - not part of Stmt
# if token.token == arraySubsym:
# arraySub()
if token.token == varDeclare:
getoken()
if token.token == assignsym:
expression()
else:
parameter()
elif token.token == ifsym:
ifStmt()
# elif token.token == elsesym:
# elseStmt()
elif token.token == whilesym:
whileStmt()
elif token.token == stmtList:
stmtList()
elif token.token == printsym:
printStmt()
elif token.token == readsym:
readStmt()
elif token.token == declaresym:
declareList()
elif token.token == dosym:
doStmt()
elif token.token == breaksym:
emit(0, "halt", '')
elif token.token == continuesym:
continueStmt()
elif token.token == number:
expression()
elif token.token == idsym:
assignStmt()
elif token.token == functionsym:
function()
elif token.token == returnsym:
returnStmt()
else:
error("Expected start of a statement")
if token.token == semicolon or token.token == comma:
getoken()
#===============================================================================
def printStmt():
#===============================================================================
""" <printStmt> ::= print <expression|string>"""
global idaddress
getoken() # skip "print"
if token.token == leftbracket:
getoken()
else:
error("Expected leftbracket before the print-item")
# printta = token.address
print_item()
if token.token == comma:
print_item()
getoken()
if token.token == rightbracket:
getoken()
# if token.token == rightbracket:
# getoken()
# else:
# error("Expected rightbracket end the print")
if token.token == semicolon:
getoken()
# else:
# error("Expected semicolon end the print")
#===============================================================================
def print_item():
# expression | string
#===============================================================================
# expression
if token.token == idsym:
expression()
emit(0, "writeint", 0)
getoken()
# string
if token.token == stringsym:
printMsg()
getoken()
#===============================================================================
def printMsg():
#===============================================================================
""" <printMsg> ::= printMsg <expression>"""
emit(0, "loadv", counterafter1)
emit(0, "store", 1)
emit(0, "call", 400)
emit(400, "load-Ind", 0)
emit(401, "jumpeq", 405)
emit(402, "writech", 0)
emit(403, "increment", 1)
emit(404, "jump", 400)
emit(405, "return", '')
#===============================================================================
def readStmt():
#===============================================================================
""" <readStmt> ::= read variable()"""
global idaddress
getoken()
if token.token == leftbracket:
getoken()
else:
error("Expected leftbracket before the variable")
variable()
emit(0, "readint", idaddress)
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket after the variable")
#===============================================================================
def assignStmt():
#===============================================================================
"""
<id> = <expression>
"""
global tokennum
global resultnum
global whichidentifier
global whichidaddress
global arraySubaddress
whichidentifier = token.name # Remember which ID on Left
tempadd = token.address
if arraySubaddress != 0:
whichidaddress = token.address;
else:
whichidaddress = arraySubaddress;
getoken() # Get token after identifier
if token.token == assignsym:
getoken()
else:
error("Expected = in assignment statement")
expression()
passtoken = token.value
# print(str(whichidaddress))
emit(0, "store", tempadd)
"""
if whichidaddress == 0:
# print("#tokenaddress " + str(tempadd))
emit(0, "store", tempadd)
else:
symtbl[whichidentifier].value = tokennum
# print("#whichidaddress "+str(whichidaddress))
emit(0, "store", whichidaddress)
"""
getoken()
#===============================================================================
def ifStmt():
# <ifStmt> ::= if (condition) statement [else statement]
#===============================================================================
getoken() # skip "if"
if token.token == leftbracket:
getoken()
else:
error("Expected leftbracket at the start of if-condition")
condition()
# getoken()
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket at the end of if-condition")
if token.token == leftbrace:
getoken()
else:
error("Expected leftbrace at the start of if-statement")
stmt()
# emit(0, "halt", '')
getoken()
if token.token == rightbrace:
getoken()
# else:
# error("Expected rightbrace at the end of if-statement")
if token.token == elsesym:
getoken()
if token.token == leftbrace:
getoken()
else:
error("Expected leftbrace at the start of else-statement")
stmt()
# emit(0, "halt", '')
if token.token == rightbrace:
getoken()
else:
error("Expected rightbrace at the end of else-statement")
#===============================================================================
def whileStmt():
#===============================================================================
""" <whileStmt> ::= while (condition)statement"""
getoken()# skip "while"
if token.token == leftbracket:
getoken()
else:
error("Expected leftbracket at the start of while-condition")
condition()
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket at the end of while-condition")
if token.token == leftbrace:
getoken()
else:
error("Expected leftbrace at the start of while-statement")
stmt()
if token.token == rightbrace:
getoken()
else:
error("Expected rightbrace at the end of while-statement")
#===============================================================================
def doStmt():
#===============================================================================
getoken()
stmtList()
#===============================================================================
def returnStmt():
#===============================================================================
# global returnadd;
getoken()
if token.token == leftbracket:
getoken()
if token.token == idsym:
expression()
print("#"+str(token.value))
emit(0, "jump", 0)
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket for return-statement")
#===============================================================================
def condition():
# [not] conditional-expression
#===============================================================================
notsign = False;
if token.token == notsym:
notsign = True;
getoken()
if notsign == True:
emit(0, "Not", '')
conditionalexp()
else:
conditionalexp()
#===============================================================================
def conditionalexp():
#===============================================================================
expression()
relational_op()
# getoken()
# expression()
#===============================================================================
def relational_op():
#===============================================================================
if token.token == lessthan or token.token == greaterthan or token.token == lessthanequal or token.token == greaterthanequal or token.token == jumpne or token.token == jumpeq:
op = token # remember -
getoken() # skip past -
emit(0, "store", 686) # Save current expression result
term()
if op.token == lessthan:
emit(0, "store", 1)
emit(0, "load", 686)
emit(0, "compare", 1)
emit(0, "jumplt", 37)
elif op.token == greaterthan:
emit(0, "compare", 686)
emit(0, "jumpgt", 0)
# emit(0, "jump", 131)
elif op.token == lessthanequal:
emit(0, "compare", 686)
emit(0, "jumplt", 43)
emit(0, "jumpeq", 43)
elif op.token == greaterthanequal:
emit(0, "compare", 686)
emit(0, "jumpgt", 43)
emit(0, "jumpeq", 43)
elif op.token == jumpne:
emit(0, "compare", 686)
emit(0, "jumpne", 310)
elif op.token == jumpeq:
emit(0, "compare", 686)
emit(0, "jumpeq", 133)
emit(0, "jump", 138)
#===============================================================================
def expression():
#===============================================================================
"""
Leaves result in ACC at runtime
Use addresses 999 & 688 as Temporary variables
<expression> ::= <factor> { (+ | -) <factor> } <- wrong
<expression> ::= <term> { (+ | -) <term> }
"""
global whichidentifier
global idaddress
global idvalue
if whichidentifier == None:
getoken()
else:
idaddress = symtbl[whichidentifier].address
idvalue = symtbl[whichidentifier].value
if token.token == leftbracket:
getoken()
term()
## 1st start==============================================================================
while token.token == plus or token.token == minus:
op = token # remember -
getoken() # skip past -
emit(0, "store", 687) # Save current result
term()
if op.token == plus:
emit(0, "add", 687)
elif op.token == minus: # Subtract - have to swap operand order
emit(0, "store", 1)
emit(0, "load", 687)
emit(0, "subtract", 1)
#===============================================================================
def term():
#===============================================================================
"""
term::= factor {(*|/) factor}
"""
global idaddress
factor()
while token.token == mpy or token.token == div:
op = token # remember -
getoken() # skip past -
emit(0, "store", 688) # Save term result
# save here xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
factor()
if op.token == mpy:
emit(0, "mpy", 688)
elif op.token == div:
emit(0, "store", 1)
emit(0, "load",688)
emit(0, "div", 1)
#===============================================================================
def factor():
#===============================================================================
"""
# FACTOR() - leaves result in ACC at runtime
<factor> ::= [+|-] identifier | number | (expression)
"""
global tokennum
global whichidentifier
global idaddress
global idvalue
tokensign = False
# [+|-] number
if token.token == plus:
getoken()
# - (unary)
elif token.token == minus:
tokensign=True
getoken()
elif token.token == number:
if tokensign == True:
emit(0, "loadv", 0 - token.value)
getoken()
else:
emit(0, "loadv", token.value)
tokennum = token.value
getoken()
# identifier
elif token.token == idsym:
emit(0, "load", token.address)
idaddress = token.address
tempaddress = token.address
# print(str(tempaddress))
getoken()
if token.token == leftbracket:
getoken()
expression()
emit(0, "store", tempaddress+2)
emit(0, "call", 210)
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket after the factor")
else:
error("Start Of Factor Expected")
#===============================================================================
def function():
#===============================================================================
global returnadd;
global codeptr
beginaddress = codeptr
# print(str(beginaddress))
codeptr = codeptr+200
getoken()
if token.token == idsym:
getoken()
if token.token == leftbracket:
getoken()
if token.token == idsym:
parameters()
# elif token.token == number:
# print("#"+str(token.value))
else:
error("Function error : No_parameter_input_for_function")
if token.token == rightbracket:
getoken()
else:
error("Expected rightbracket for parameter")
if token.token == semicolon:
getoken()
else:
error("Expected semicolon after parameter")
if token.token == declaresym:
declareList()
"""
if token.token == semicolon:
getoken()
else:
error("Expected semicolon after declare variable")
"""
if token.token == leftbrace:
getoken()
stmtList()
if token.token == rightbrace:
getoken()
print ("#---Function Finished---")
codeptr = beginaddress
#===============================================================================
def program():
#===============================================================================
if token.token == leftbrace:
getoken()
if token.token == programsym:
getoken()
else: error("Program start with 'program' keyword")
if token.token == idsym:
getoken()
if token.token == semicolon:
getoken()
if token.token == declaresym :
declareList()
if token.token == functionsym:
function()
if token.token == leftbrace:
getoken()
stmtList()
if token.token == rightbrace:
print "#***Compilation Finished****"
#======================================================================
def main():
#======================================================================
global line
global srcfile
global charIndex
initSymTbl()
with open("test.txt") as srcfile:
# out1file = open('output.obj','w')
line = srcfile.read()
# out1file.write("hello")
# print line
charIndex = 0
debugScanner = False
if debugScanner: # Scanner Test Routine - Read a line and display the tokens
getoken()
while token.token is not None: # Skeleton for testing Scanner
printToken(token)
# y = str(token)
# out1file.write(y)
getoken()
sys.exit(1)
else:
getoken() # Parse Program according to the grammar
program()
#===============================================================================
# Main Compiler starts here
#===============================================================================
print "#Microcompiler.py v0.2"
#emit(0, "load", 0)
main()
"""
srcfile = open('test.txt', 'r')
lexer = shlex.shlex(srcfile)
for token in lexer:
print repr(token)
"""
# getoken()
#=======================================================================
# *** That's it folks - written by Giovanni Moretti - April 27, 2011 ***
#=======================================================================
| Python |
import math
def sieve_of_atkin(limit):
results = [2, 3, 5]
sieve = [False]*(limit+1)
factor = int(math.sqrt(limit))+1
for i in range(1, factor):
for j in range(1, factor):
n = 4*i**2+j**2
if (n <= limit) and (n % 12 == 1 or n % 12 == 5):
sieve[n] = not sieve[n]
n = 3*i**2+j**2
if (n <= limit) and (n % 12 == 7):
sieve[n] = not sieve[n]
if i > j:
n = 3*i**2-j**2
if (n <= limit) and (n % 12 == 11):
sieve[n] = not sieve[n]
for index in range(5, factor):
if sieve[index]:
for jndex in range(index**2, limit, index**2):
sieve[jndex] = False
for index in range(7, limit):
if sieve[index]:
results.append(index)
return results | Python |
import struct
import Atkin
import random
from array import array
class MyException (Exception): pass
#m = 11*19 # large primes should be used
#xi = 0
'''
def eratosthenes(n):
multiples = []
primes1 = []
for i in range(2, n+1):
if i not in multiples:
primes1.append(i)
for j in range(i*i, n+1, i):
multiples.append(j)
return primes1
'''
'''
primes = Atkin.sieve_of_atkin(10000)
def get_primes():
global primes
out_primes = []
while len(out_primes) < 2:
curr_prime = primes.pop()
if curr_prime % 4 == 3:
out_primes.append(curr_prime)
return out_primes
primes = get_primes()
m = primes[0]*primes[1]
'''
'''
def blum_blum_shub_generator():
global xi
xi = ((xi+1)**2)%m
return
'''
primes = Atkin.sieve_of_atkin(1000)
def gen_primes():
global primes
out_primes = []
while len(out_primes) < 2:
curr_prime = primes[random.randrange(len(primes))]
if curr_prime % 4 == 3:
out_primes.append(curr_prime)
return out_primes
# random generator must return only ONE number
x = random.randrange(1000000)
def random_generator(length1):
global x
while length1:
x += 1
p, q = gen_primes()
m1 = p * q
z = (x**2) % m1
length1 -= 1
yield str(bin(z).count('1') % 2)
def get_random_bits():
return ''.join(random_generator(1))
#for i in range(1000000):
# print(blum_blum_shub_generator())
frame_ = get_random_bits()
length = 3000000
#frame.append(get_random_bits())
#fo.write(frame)
#fo.close()
fob = open("lkmb.txt", "wb")
#foc = open("lkmc.txt", "w")
try:
#for i in range(0, 3000000):
# nn = blum_blum_shub_generator()
# fob.write(struct.pack("I", nn))
# foc.write(str(nn)+"\n")
fob.write(frame)
fob.close()
#foc.close()
except MyException: print("except, motherfucker") | Python |
import math
""""
int CACHE = 30000; // размер кэша
int M = (int)Math.sqrt(N)+1;
int primes = new int[P]; // массив простых чисел до корня из N
boolean segment = new boolean[CACHE]; // вторичное решето
for (int I=M-1; I < N; I+=CACHE) {
Arrays.fill(segment, true);
for (int i= 0; i < P; i++) {
int h = I % primes[i];
int j = h > 0 ? primes[i] - h : 0;
for (; j < CACHE; j+=primes[i])
segment[j] = false;
}
for (int i= 0; i<CACHE; i++) {
if (segment[i] && (i + I < N)) {
out.println(i+I); // выводим простое число на экран
}
}
}
"""
def sieveOfErat(end):
if end < 2: return []
#The array doesn't need to include even numbers
lng = ((end/2)-1+end%2)
# Create array and assume all numbers in array are prime
sieve = [True]*(lng+1)
# In the following code, you're going to see some funky
# bit shifting and stuff, this is just transforming i and j
# so that they represent the proper elements in the array.
# The transforming is not optimal, and the number of
# operations involved can be reduced.
# Only go up to square root of the end
for i in range(int(sqrt(end)) >> 1):
# Skip numbers that aren’t marked as prime
if not sieve[i]: continue
# Unmark all multiples of i, starting at i**2
for j in range( (i*(i + 3) << 1) + 3, lng, (i << 1) + 3):
sieve[j] = False
# Don't forget 2!
primes = [2]
# Gather all the primes into a list, leaving out the composite numbers
primes.extend([(i << 1) + 3 for i in range(lng) if sieve[i]])
return primes
n = 10
CACHE = 30000
M = int(math.sqrt(n)+1)
prime = []
segment = []
for i in range(M-1):
for tr in range(0, CACHE):
segment.append(True)
print(segment) | Python |
#====================================================================
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ====================================================================
#
# This software consists of voluntary contributions made by many
# individuals on behalf of the Apache Software Foundation. For more
# information on the Apache Software Foundation, please see
# <http://www.apache.org/>.
#
import os
import re
import tempfile
import shutil
ignore_pattern = re.compile('^(.svn|target|bin|classes)')
java_pattern = re.compile('^.*\.java')
annot_pattern = re.compile('import org\.apache\.http\.annotation\.')
def process_dir(dir):
files = os.listdir(dir)
for file in files:
f = os.path.join(dir, file)
if os.path.isdir(f):
if not ignore_pattern.match(file):
process_dir(f)
else:
if java_pattern.match(file):
process_source(f)
def process_source(filename):
tmp = tempfile.mkstemp()
tmpfd = tmp[0]
tmpfile = tmp[1]
try:
changed = False
dst = os.fdopen(tmpfd, 'w')
try:
src = open(filename)
try:
for line in src:
if annot_pattern.match(line):
changed = True
line = line.replace('import org.apache.http.annotation.', 'import net.jcip.annotations.')
dst.write(line)
finally:
src.close()
finally:
dst.close();
if changed:
shutil.move(tmpfile, filename)
else:
os.remove(tmpfile)
except:
os.remove(tmpfile)
process_dir('.')
| Python |
#!/usr/bin/python2.6
#
# Simple http server to emulate api.playfoursquare.com
import logging
import shutil
import sys
import urlparse
import SimpleHTTPServer
import BaseHTTPServer
class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
"""Handle playfoursquare.com requests, for testing."""
def do_GET(self):
logging.warn('do_GET: %s, %s', self.command, self.path)
url = urlparse.urlparse(self.path)
logging.warn('do_GET: %s', url)
query = urlparse.parse_qs(url.query)
query_keys = [pair[0] for pair in query]
response = self.handle_url(url)
if response != None:
self.send_200()
shutil.copyfileobj(response, self.wfile)
self.wfile.close()
do_POST = do_GET
def handle_url(self, url):
path = None
if url.path == '/v1/venue':
path = '../captures/api/v1/venue.xml'
elif url.path == '/v1/addvenue':
path = '../captures/api/v1/venue.xml'
elif url.path == '/v1/venues':
path = '../captures/api/v1/venues.xml'
elif url.path == '/v1/user':
path = '../captures/api/v1/user.xml'
elif url.path == '/v1/checkcity':
path = '../captures/api/v1/checkcity.xml'
elif url.path == '/v1/checkins':
path = '../captures/api/v1/checkins.xml'
elif url.path == '/v1/cities':
path = '../captures/api/v1/cities.xml'
elif url.path == '/v1/switchcity':
path = '../captures/api/v1/switchcity.xml'
elif url.path == '/v1/tips':
path = '../captures/api/v1/tips.xml'
elif url.path == '/v1/checkin':
path = '../captures/api/v1/checkin.xml'
elif url.path == '/history/12345.rss':
path = '../captures/api/v1/feed.xml'
if path is None:
self.send_error(404)
else:
logging.warn('Using: %s' % path)
return open(path)
def send_200(self):
self.send_response(200)
self.send_header('Content-type', 'text/xml')
self.end_headers()
def main():
if len(sys.argv) > 1:
port = int(sys.argv[1])
else:
port = 8080
server_address = ('0.0.0.0', port)
httpd = BaseHTTPServer.HTTPServer(server_address, RequestHandler)
sa = httpd.socket.getsockname()
print "Serving HTTP on", sa[0], "port", sa[1], "..."
httpd.serve_forever()
if __name__ == '__main__':
main()
| Python |
#!/usr/bin/python
import os
import subprocess
import sys
BASEDIR = '../main/src/com/joelapenna/foursquare'
TYPESDIR = '../captures/types/v1'
captures = sys.argv[1:]
if not captures:
captures = os.listdir(TYPESDIR)
for f in captures:
basename = f.split('.')[0]
javaname = ''.join([c.capitalize() for c in basename.split('_')])
fullpath = os.path.join(TYPESDIR, f)
typepath = os.path.join(BASEDIR, 'types', javaname + '.java')
parserpath = os.path.join(BASEDIR, 'parsers', javaname + 'Parser.java')
cmd = 'python gen_class.py %s > %s' % (fullpath, typepath)
print cmd
subprocess.call(cmd, stdout=sys.stdout, shell=True)
cmd = 'python gen_parser.py %s > %s' % (fullpath, parserpath)
print cmd
subprocess.call(cmd, stdout=sys.stdout, shell=True)
| Python |
#!/usr/bin/python
"""
Pull a oAuth protected page from foursquare.
Expects ~/.oget to contain (one on each line):
CONSUMER_KEY
CONSUMER_KEY_SECRET
USERNAME
PASSWORD
Don't forget to chmod 600 the file!
"""
import httplib
import os
import re
import sys
import urllib
import urllib2
import urlparse
import user
from xml.dom import pulldom
from xml.dom import minidom
import oauth
"""From: http://groups.google.com/group/foursquare-api/web/oauth
@consumer = OAuth::Consumer.new("consumer_token","consumer_secret", {
:site => "http://foursquare.com",
:scheme => :header,
:http_method => :post,
:request_token_path => "/oauth/request_token",
:access_token_path => "/oauth/access_token",
:authorize_path => "/oauth/authorize"
})
"""
SERVER = 'api.foursquare.com:80'
CONTENT_TYPE_HEADER = {'Content-Type' :'application/x-www-form-urlencoded'}
SIGNATURE_METHOD = oauth.OAuthSignatureMethod_HMAC_SHA1()
AUTHEXCHANGE_URL = 'http://api.foursquare.com/v1/authexchange'
def parse_auth_response(auth_response):
return (
re.search('<oauth_token>(.*)</oauth_token>', auth_response).groups()[0],
re.search('<oauth_token_secret>(.*)</oauth_token_secret>',
auth_response).groups()[0]
)
def create_signed_oauth_request(username, password, consumer):
oauth_request = oauth.OAuthRequest.from_consumer_and_token(
consumer, http_method='POST', http_url=AUTHEXCHANGE_URL,
parameters=dict(fs_username=username, fs_password=password))
oauth_request.sign_request(SIGNATURE_METHOD, consumer, None)
return oauth_request
def main():
url = urlparse.urlparse(sys.argv[1])
# Nevermind that the query can have repeated keys.
parameters = dict(urlparse.parse_qsl(url.query))
password_file = open(os.path.join(user.home, '.oget'))
lines = [line.strip() for line in password_file.readlines()]
if len(lines) == 4:
cons_key, cons_key_secret, username, password = lines
access_token = None
else:
cons_key, cons_key_secret, username, password, token, secret = lines
access_token = oauth.OAuthToken(token, secret)
consumer = oauth.OAuthConsumer(cons_key, cons_key_secret)
if not access_token:
oauth_request = create_signed_oauth_request(username, password, consumer)
connection = httplib.HTTPConnection(SERVER)
headers = {'Content-Type' :'application/x-www-form-urlencoded'}
connection.request(oauth_request.http_method, AUTHEXCHANGE_URL,
body=oauth_request.to_postdata(), headers=headers)
auth_response = connection.getresponse().read()
token = parse_auth_response(auth_response)
access_token = oauth.OAuthToken(*token)
open(os.path.join(user.home, '.oget'), 'w').write('\n'.join((
cons_key, cons_key_secret, username, password, token[0], token[1])))
oauth_request = oauth.OAuthRequest.from_consumer_and_token(consumer,
access_token, http_method='POST', http_url=url.geturl(),
parameters=parameters)
oauth_request.sign_request(SIGNATURE_METHOD, consumer, access_token)
connection = httplib.HTTPConnection(SERVER)
connection.request(oauth_request.http_method, oauth_request.to_url(),
body=oauth_request.to_postdata(), headers=CONTENT_TYPE_HEADER)
print connection.getresponse().read()
#print minidom.parse(connection.getresponse()).toprettyxml(indent=' ')
if __name__ == '__main__':
main()
| Python |
#!/usr/bin/python
import datetime
import sys
import textwrap
import common
from xml.dom import pulldom
PARSER = """\
/**
* Copyright 2009 Joe LaPenna
*/
package com.joelapenna.foursquare.parsers;
import com.joelapenna.foursquare.Foursquare;
import com.joelapenna.foursquare.error.FoursquareError;
import com.joelapenna.foursquare.error.FoursquareParseException;
import com.joelapenna.foursquare.types.%(type_name)s;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Auto-generated: %(timestamp)s
*
* @author Joe LaPenna (joe@joelapenna.com)
* @param <T>
*/
public class %(type_name)sParser extends AbstractParser<%(type_name)s> {
private static final Logger LOG = Logger.getLogger(%(type_name)sParser.class.getCanonicalName());
private static final boolean DEBUG = Foursquare.PARSER_DEBUG;
@Override
public %(type_name)s parseInner(XmlPullParser parser) throws XmlPullParserException, IOException,
FoursquareError, FoursquareParseException {
parser.require(XmlPullParser.START_TAG, null, null);
%(type_name)s %(top_node_name)s = new %(type_name)s();
while (parser.nextTag() == XmlPullParser.START_TAG) {
String name = parser.getName();
%(stanzas)s
} else {
// Consume something we don't understand.
if (DEBUG) LOG.log(Level.FINE, "Found tag that we don't recognize: " + name);
skipSubTree(parser);
}
}
return %(top_node_name)s;
}
}"""
BOOLEAN_STANZA = """\
} else if ("%(name)s".equals(name)) {
%(top_node_name)s.set%(camel_name)s(Boolean.valueOf(parser.nextText()));
"""
GROUP_STANZA = """\
} else if ("%(name)s".equals(name)) {
%(top_node_name)s.set%(camel_name)s(new GroupParser(new %(sub_parser_camel_case)s()).parse(parser));
"""
COMPLEX_STANZA = """\
} else if ("%(name)s".equals(name)) {
%(top_node_name)s.set%(camel_name)s(new %(parser_name)s().parse(parser));
"""
STANZA = """\
} else if ("%(name)s".equals(name)) {
%(top_node_name)s.set%(camel_name)s(parser.nextText());
"""
def main():
type_name, top_node_name, attributes = common.WalkNodesForAttributes(
sys.argv[1])
GenerateClass(type_name, top_node_name, attributes)
def GenerateClass(type_name, top_node_name, attributes):
"""generate it.
type_name: the type of object the parser returns
top_node_name: the name of the object the parser returns.
per common.WalkNodsForAttributes
"""
stanzas = []
for name in sorted(attributes):
typ, children = attributes[name]
replacements = Replacements(top_node_name, name, typ, children)
if typ == common.BOOLEAN:
stanzas.append(BOOLEAN_STANZA % replacements)
elif typ == common.GROUP:
stanzas.append(GROUP_STANZA % replacements)
elif typ in common.COMPLEX:
stanzas.append(COMPLEX_STANZA % replacements)
else:
stanzas.append(STANZA % replacements)
if stanzas:
# pop off the extranious } else for the first conditional stanza.
stanzas[0] = stanzas[0].replace('} else ', '', 1)
replacements = Replacements(top_node_name, name, typ, [None])
replacements['stanzas'] = '\n'.join(stanzas).strip()
print PARSER % replacements
def Replacements(top_node_name, name, typ, children):
# CameCaseClassName
type_name = ''.join([word.capitalize() for word in top_node_name.split('_')])
# CamelCaseClassName
camel_name = ''.join([word.capitalize() for word in name.split('_')])
# camelCaseLocalName
attribute_name = camel_name.lower().capitalize()
# mFieldName
field_name = 'm' + camel_name
if children[0]:
sub_parser_camel_case = children[0] + 'Parser'
else:
sub_parser_camel_case = (camel_name[:-1] + 'Parser')
return {
'type_name': type_name,
'name': name,
'top_node_name': top_node_name,
'camel_name': camel_name,
'parser_name': typ + 'Parser',
'attribute_name': attribute_name,
'field_name': field_name,
'typ': typ,
'timestamp': datetime.datetime.now(),
'sub_parser_camel_case': sub_parser_camel_case,
'sub_type': children[0]
}
if __name__ == '__main__':
main()
| Python |
#!/usr/bin/python
import logging
from xml.dom import minidom
from xml.dom import pulldom
BOOLEAN = "boolean"
STRING = "String"
GROUP = "Group"
# Interfaces that all FoursquareTypes implement.
DEFAULT_INTERFACES = ['FoursquareType']
# Interfaces that specific FoursqureTypes implement.
INTERFACES = {
}
DEFAULT_CLASS_IMPORTS = [
]
CLASS_IMPORTS = {
# 'Checkin': DEFAULT_CLASS_IMPORTS + [
# 'import com.joelapenna.foursquare.filters.VenueFilterable'
# ],
# 'Venue': DEFAULT_CLASS_IMPORTS + [
# 'import com.joelapenna.foursquare.filters.VenueFilterable'
# ],
# 'Tip': DEFAULT_CLASS_IMPORTS + [
# 'import com.joelapenna.foursquare.filters.VenueFilterable'
# ],
}
COMPLEX = [
'Group',
'Badge',
'Beenhere',
'Checkin',
'CheckinResponse',
'City',
'Credentials',
'Data',
'Mayor',
'Rank',
'Score',
'Scoring',
'Settings',
'Stats',
'Tags',
'Tip',
'User',
'Venue',
]
TYPES = COMPLEX + ['boolean']
def WalkNodesForAttributes(path):
"""Parse the xml file getting all attributes.
<venue>
<attribute>value</attribute>
</venue>
Returns:
type_name - The java-style name the top node will have. "Venue"
top_node_name - unadultured name of the xml stanza, probably the type of
java class we're creating. "venue"
attributes - {'attribute': 'value'}
"""
doc = pulldom.parse(path)
type_name = None
top_node_name = None
attributes = {}
level = 0
for event, node in doc:
# For skipping parts of a tree.
if level > 0:
if event == pulldom.END_ELEMENT:
level-=1
logging.warn('(%s) Skip end: %s' % (str(level), node))
continue
elif event == pulldom.START_ELEMENT:
logging.warn('(%s) Skipping: %s' % (str(level), node))
level+=1
continue
if event == pulldom.START_ELEMENT:
logging.warn('Parsing: ' + node.tagName)
# Get the type name to use.
if type_name is None:
type_name = ''.join([word.capitalize()
for word in node.tagName.split('_')])
top_node_name = node.tagName
logging.warn('Found Top Node Name: ' + top_node_name)
continue
typ = node.getAttribute('type')
child = node.getAttribute('child')
# We don't want to walk complex types.
if typ in COMPLEX:
logging.warn('Found Complex: ' + node.tagName)
level = 1
elif typ not in TYPES:
logging.warn('Found String: ' + typ)
typ = STRING
else:
logging.warn('Found Type: ' + typ)
logging.warn('Adding: ' + str((node, typ)))
attributes.setdefault(node.tagName, (typ, [child]))
logging.warn('Attr: ' + str((type_name, top_node_name, attributes)))
return type_name, top_node_name, attributes
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
import os
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Quad 20 in CGI"
print "</title></head>"
print "<body>"
for e in range(1,21):
print str(e*e)+'</br>'
print "</body></html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os, random, cgi, cgitb
cgitb.enable()
i = 0
c=0
richtig = 0
erg = 0
a= random.randint(1,11)
b= random.randint(1,11)
form = cgi.FieldStorage()
if "i" in form: i = int(form["i"].value)
if "erg" in form: erg = int(form["erg"].value)
if "c" in form: c = int(form["c"].value)
if "richtig" in form: richtig = int(form["richtig"].value)
print "<html>"
print "<head><title>Kopfrechner</title></head>"
print '<form action="kopfrechentrainer.cgi" method="POST">'
#print '<form action="kopfrechentrainer.cgi" method="GET">'
print "<p>"
if(i!=0):
if c == erg:
richtig+=1
if i<6:
print "Loesen sie bitte folgende Aufgabe:"
if i<3:
print a,"+",b,"= ?"
c = a+b
i+=1
else:
print a,"*",b,"= ?"
c = a*b
i+=1
else:
print "Sie haben ",richtig,"von",i," Aufgaben richtig."
if i <=6:
print '<br/>Ihre eingabe: <input type="text" name="erg">'
print '<input type="hidden" name="i" value=',i,'>'
print '<input type="hidden" name="c" value=',c,'>'
print '<input type="hidden" name="richtig" value=',richtig,'>'
print '<input type="submit" name="ok" value="ok">'
print "</p>"
print "</html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os
l = os.environ["HTTP_ACCEPT_LANGUAGE"].split(";")
if "en" in l[0]:
print "Hello World"
else:
print "Hallo Welt"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os, random, cgi, cgitb
cgitb.enable()
i = 0
c=0
richtig = 0
erg = 0
a= random.randint(1,11)
b= random.randint(1,11)
form = cgi.FieldStorage()
if "i" in form: i = int(form["i"].value)
if "erg" in form: erg = int(form["erg"].value)
if "c" in form: c = int(form["c"].value)
if "richtig" in form: richtig = int(form["richtig"].value)
print "<html>"
print "<head><title>Kopfrechner</title></head>"
print '<form action="kopfrechentrainer.cgi" method="POST">'
#print '<form action="kopfrechentrainer.cgi" method="GET">'
print "<p>"
if(i!=0):
if c == erg:
richtig+=1
if i<6:
print "Loesen sie bitte folgende Aufgabe:"
if i<3:
print a,"+",b,"= ?"
c = a+b
i+=1
else:
print a,"*",b,"= ?"
c = a*b
i+=1
else:
print "Sie haben ",richtig,"von",i," Aufgaben richtig."
if i <=6:
print '<br/>Ihre eingabe: <input type="text" name="erg">'
print '<input type="hidden" name="i" value=',i,'>'
print '<input type="hidden" name="c" value=',c,'>'
print '<input type="hidden" name="richtig" value=',richtig,'>'
print '<input type="submit" name="ok" value="ok">'
print "</p>"
print "</html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import os
form = cgi.FieldStorage()
n = 20
if "n" in form: n = form["n"].value
print "<html>"
print "<head><title>n Quadratzahlen"
print "</title></head>"
print "<body>"
for e in range(1,int(n)+1):
print str(e*e)+'</br>'
print "</body></html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os, sys, random
directory = "/usr/share/games/fortunes/"
l = os.listdir(directory)
b = []
for e in l:
if ".u8" not in e and ".dat" not in e and "de" not in e:
b.append(e)
s = ""
for e in b:
f = open(directory+e)
s+=f.read()
f.close()
bla = s.split("\n%\n")
c = []
print "<html><head><title>Little funny fortunes</title></head>"
print "<body>"
print "<form>"
if os.environ.has_key("QUERY_STRING"):
st = os.environ["QUERY_STRING"].split("m=")
if len(st)==1:
print '<p>Suchwort:<br><input name="m" type="text" size="30" maxlength="30">'
print '<input type="submit" value=" Absenden "></p>'
if len(st)==2:
print '<p>Suchwort:<br><input name="m" type="text" size="30" maxlength="30" value = ',st[1],'>'
print '<input type="submit" value=" Absenden "></p>'
for e in bla:
if st[1] in e:
c.append(e)
if len(c)>0:
print c[random.randint(0,len(c)-1)]
else:
print 'No fortune found with "',st[1],'"'
else:
print bla[random.randint(0,len(bla)-1)]
print "</form>"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo CGI-Python"
print "</title></head>"
print "<body>"
print "Hello CGI Python"
print "</body></html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
import os
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Quad 20 in CGI"
print "</title></head>"
print "<body>"
for e in range(1,21):
print str(e*e)+'</br>'
print "</body></html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "Hallo CGI-Welt"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os
l = os.environ["HTTP_ACCEPT_LANGUAGE"].split(";")
if "en" in l[0]:
print "Hello World"
else:
print "Hallo Welt"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os
for key in os.environ:
print key, "="
print os.environ[key], "<br />"
if os.environ.has_key("QUERY_STRING"):
print os.environ["QUERY_STRING"]
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os
for key in os.environ:
print key, "="
print os.environ[key], "<br />"
if os.environ.has_key("QUERY_STRING"):
print os.environ["QUERY_STRING"]
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo CGI-Python"
print "</title></head>"
print "<body>"
print "Hello CGI Python"
print "</body></html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import os
form = cgi.FieldStorage()
n = 20
if "n" in form: n = form["n"].value
print "<html>"
print "<head><title>n Quadratzahlen"
print "</title></head>"
print "<body>"
for e in range(1,int(n)+1):
print str(e*e)+'</br>'
print "</body></html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "Hallo CGI-Welt"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import os, sys, random
directory = "/usr/share/games/fortunes/"
l = os.listdir(directory)
b = []
for e in l:
if ".u8" not in e and ".dat" not in e and "de" not in e:
b.append(e)
s = ""
for e in b:
f = open(directory+e)
s+=f.read()
f.close()
bla = s.split("\n%\n")
c = []
print "<html><head><title>Little funny fortunes</title></head>"
print "<body>"
print "<form>"
if os.environ.has_key("QUERY_STRING"):
st = os.environ["QUERY_STRING"].split("m=")
if len(st)==1:
print '<p>Suchwort:<br><input name="m" type="text" size="30" maxlength="30">'
print '<input type="submit" value=" Absenden "></p>'
if len(st)==2:
print '<p>Suchwort:<br><input name="m" type="text" size="30" maxlength="30" value = ',st[1],'>'
print '<input type="submit" value=" Absenden "></p>'
for e in bla:
if st[1] in e:
c.append(e)
if len(c)>0:
print c[random.randint(0,len(c)-1)]
else:
print 'No fortune found with "',st[1],'"'
else:
print bla[random.randint(0,len(bla)-1)]
print "</form>"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
for a in range(1,21):
print str(a**2)+'<br/>'
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
import random
cgitb.enable()
form = cgi.FieldStorage()
x = random.randint(1, 10)
y = random.randint(1, 10)
z = 0
erg = 0
right = 0
if form.has_key("Zaehler"):
z = z + int(form["Zaehler"].value)
z=z+1
if z < 4 :
erg = x + y
o = '+'
else :
erg = x * y
o = '*'
if form.has_key("Richtige"):
right = right + int(form["Richtige"].value)
if form.has_key("Eingabe"):
#if "Eingabe" in form: #funktioniert auch so :D
if form["Eingabe"].value==form["Ergebnis"].value:
right = right +1
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
print "<head><title>Kopfrechner</title></head>"
if z <=6:
print "%i %s %i" % (x, o, y)
print "<form action='kopfrechner.cgi' method='POST'>"
print "Ihre Loesung:<br><input name='Eingabe' type='text' size='10' maxlength='4'/>"
print "<input type='submit' value='Senden' />"
print "<input type='hidden' name='ErsteZahl' value='%i'>" % x
print "<input type='hidden' name='ZweiteZahl' value='%i'>" % y
print "<input type='hidden' name='Zaehler' value=",z,">"
print "<input type='hidden' name='Ergebnis' value='%i'>" %erg
print "<input type='hidden' name='Richtige' value='%i'>" %right
print "</form>"
else:
print "Sie haben %i von %i Aufgaben richtig geloest." % (right, z-1)
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import os
print "Content-Type: text/html\n"
for key in os.environ:
print key, "="
print os.environ[key], "<br />" | Python |
#!/usr/bin/python
import os
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo Tim</title></head>"
print "<body>"
if os.environ["HTTP_ACCEPT_LANGUAGE"][:2]=='en':
print "Hello World!"
else:
print "Hallo Welt!"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
form = cgi.FieldStorage()
if form.has_key("n"):
n = form.getvalue("n")
for a in range(1,int(n)+1):
print str(a**2)+'<br/>'
else:
n = 21
for a in range(1,n):
print str(a**2)+'<br/>'
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
import fortune
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
print "<head><title>Fortune</title></head>"
form = cgi.FieldStorage()
if form.has_key("m"):
#m = form["m"].value //alternative
m = form.getvalue("m")
print fortune.getQuote(m)
else:
m=""
print fortune.getRandomQuote()
print "<form action='fortune.cgi'>"
print "In Zitat enthalten: <br>\n"
print "<input name='m' type='text' size='30' maxlength='30' value=",m,">"
print "<input type='Submit' value='Ok'>"
print "</form>"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
import random
cgitb.enable()
form = cgi.FieldStorage()
x = random.randint(1, 10)
y = random.randint(1, 10)
z = 0
erg = 0
right = 0
if form.has_key("Zaehler"):
z = z + int(form["Zaehler"].value)
z=z+1
if z < 4 :
erg = x + y
o = '+'
else :
erg = x * y
o = '*'
if form.has_key("Richtige"):
right = right + int(form["Richtige"].value)
if form.has_key("Eingabe"):
#if "Eingabe" in form: #funktioniert auch so :D
if form["Eingabe"].value==form["Ergebnis"].value:
right = right +1
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
print "<head><title>Kopfrechner</title></head>"
if z <=6:
print "%i %s %i" % (x, o, y)
print "<form action='kopfrechner.cgi' method='POST'>"
print "Ihre Loesung:<br><input name='Eingabe' type='text' size='10' maxlength='4'/>"
print "<input type='submit' value='Senden' />"
print "<input type='hidden' name='ErsteZahl' value='%i'>" % x
print "<input type='hidden' name='ZweiteZahl' value='%i'>" % y
print "<input type='hidden' name='Zaehler' value=",z,">"
print "<input type='hidden' name='Ergebnis' value='%i'>" %erg
print "<input type='hidden' name='Richtige' value='%i'>" %right
print "</form>"
else:
print "Sie haben %i von %i Aufgaben richtig geloest." % (right, z-1)
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
for a in range(1,21):
print str(a**2)+'<br/>'
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo Tim</title></head>"
print "<body>"
print "Hallo Welt!"
print "</body>"
print "</html>" | Python |
#!/usr/bin/python
#-*-coding: utf-8-*-
import os
import sys
import random
import string
def getRandomQuote():
files=os.listdir("/usr/share/games/fortune")
files=[f for f in files if ".dat" not in f and ".u8" not in f]
f=random.sample(files, 1)
s=file("/usr/share/games/fortune/"+f[0]).read()
quotes=s.split("\n%\n")
return (random.sample(quotes, 1))[0]
def getQuote(pat):
files=os.listdir("/usr/share/games/fortune")
files=[f for f in files if ".dat" not in f and ".u8" not in f]
random.shuffle(files)
for f in files:
s=file("/usr/share/games/fortune/"+f).read()
quotes=s.split("\n%\n")
for q in quotes:
if pat in q:
return q
return None
if __name__=="__main__":
if len(sys.argv)>1 and sys.argv[1]=="-m":
quote=getQuote(sys.argv[2])
else:
quote=getRandomQuote()
print quote
| Python |
#!/usr/bin/python
import os
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo Tim</title></head>"
print "<body>"
if os.environ["HTTP_ACCEPT_LANGUAGE"][:2]=='en':
print "Hello World!"
else:
print "Hallo Welt!"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import os
print "Content-Type: text/html\n"
for key in os.environ:
print key, "="
print os.environ[key], "<br />" | Python |
#!/usr/bin/python
#-*-coding: utf-8-*-
import os
import sys
import random
import string
def getRandomQuote():
files=os.listdir("/usr/share/games/fortune")
files=[f for f in files if ".dat" not in f and ".u8" not in f]
f=random.sample(files, 1)
s=file("/usr/share/games/fortune/"+f[0]).read()
quotes=s.split("\n%\n")
return (random.sample(quotes, 1))[0]
def getQuote(pat):
files=os.listdir("/usr/share/games/fortune")
files=[f for f in files if ".dat" not in f and ".u8" not in f]
random.shuffle(files)
for f in files:
s=file("/usr/share/games/fortune/"+f).read()
quotes=s.split("\n%\n")
for q in quotes:
if pat in q:
return q
return None
if __name__=="__main__":
if len(sys.argv)>1 and sys.argv[1]=="-m":
quote=getQuote(sys.argv[2])
else:
quote=getRandomQuote()
print quote
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
form = cgi.FieldStorage()
if form.has_key("n"):
n = form.getvalue("n")
for a in range(1,int(n)+1):
print str(a**2)+'<br/>'
else:
n = 21
for a in range(1,n):
print str(a**2)+'<br/>'
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head><title>Hallo Tim</title></head>"
print "<body>"
print "Hallo Welt!"
print "</body>"
print "</html>" | Python |
#!/usr/bin/python
import cgi
import cgitb
import fortune
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<body>"
print "<head><title>Fortune</title></head>"
form = cgi.FieldStorage()
if form.has_key("m"):
#m = form["m"].value //alternative
m = form.getvalue("m")
print fortune.getQuote(m)
else:
m=""
print fortune.getRandomQuote()
print "<form action='fortune.cgi'>"
print "In Zitat enthalten: <br>\n"
print "<input name='m' type='text' size='30' maxlength='30' value=",m,">"
print "<input type='Submit' value='Ok'>"
print "</form>"
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head>"
print "<title> ptreb quad cgi </title>"
print "</head>"
print "<body>"
print [x**2 for x in range(1,21)]
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import os
template = "<html><head><title>%s</title></head><body>%s</body></html>"
title = "Mein Titel"
content = "<h2>Hallo international</h2>"
dic = {"de":"hallo welt", "en":"hello World"}
mylan = "de"
lan = os.environ["HTTP_ACCEPT_LANGUAGE"]
if lan[:2] == "en":
mylan = "en"
content += "<p>" + dic[mylan] + "</p>"
print template % (title, content)
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# print erzeugt einen zeilunumbruch automatisch
print "Content-Type: text/html\n"
# wichtig cgi module importieren
# import ohne .py wenn im selben ordner
# fortune.methode zum benutzen einer funktion
import fortune
import cgi
import cgitb
cgitb.enable()
#main, war in fortunes.py drin
f1 = './fortunes/fortunes'
f2 = './fortunes/riddles'
f3 = './fortunes/literature'
dump = './dump.txt'
lall = []
source = list((f1,f2,f3)) # liste mit quelldateien
fortune.dumpString(fortune.getString(source), dump) # riesenstring in datei schreiben
lall = fortune.getString(source).split('\n%\n') # jedes Zitat ein Listenelement
#args = sys.argv[1:3]
#content += 'args: %s \n' % (args)
#content += printText(lall, args[1]) if len(args) >= 2 and args[0] == '-m' else printText(lall)
# alle requeststring parameter holen in form speichern
form = cgi.FieldStorage()
# m initialisieren, pattern
m = ""
# heredoc string benutzen um zeilenumbrueche im Seitenquelltext automatisch zu haben
# nicht mehr noetig \n zu setzen
template = """
<html>
<head><title>%s</title></head>
<body>\n%s</body>
</html>
"""
title = "Mein Titel"
content = "<h2>Fortunes</h2>\n"
if "m" in form:
m = form["m"].value
# benutzer darf suchwort eingeben und ok klicken
# \n um seitenquelltext lesbar zu machen
# variablen mit %s string ersetzung vormerken
content += """
<form action='fortune_ok.cgi' method='GET' >
<input type='text' name='m' size='40' maxlength='10' value='%s'><br />
<input type='submit' name='ok' value='OK' size='90' maxlength='50' ><br />
"""
content += "</form>\n"
content = content % m
# wenn m nicht gesetzt ist abfangen
if len(m) > 0:
content += fortune.printText(lall, m)
else:
content += fortune.printText(lall)
print template % (title, content)
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "<html>"
print "<head>"
print "<title> ptreb hallo cgi </title>"
print "</head>"
print "<body>"
print "Hello CGI Python "
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import random
form = cgi.FieldStorage()
#zustaende auslesen
# variablen initialisieren
# aus fieldStorage komme nur strings => immer casten
title = "CGI Rechner"
runde = int(form["runde"].value) +1 if "runde" in form else 0 # vorverarbeitung hier machen
# muss richtiges ergebnis des vorigen klicks merken
prevresult = int(form["prevresult"].value) if "prevresult" in form else None
right = int(form["right"].value) if "right" in form else 0
userresult = int(form["userresult"].value) if "userresult" in form else None
result = None
z1 = random.randint(1,10)
z2 = random.randint(1,10)
operator = None
def checkresult(prevresult, userresult):
if prevresult == userresult:
return 1
return 0
def resultpage():
content = """
<h2>Ergebnis</h2><br />
Sie haben: %d von %d Aufgaben richtig gelösst!<br />
<a href='rechner.cgi'>nochmal spielen</a>
"""
return content % (right, runde)
def aufgabenpage(operator):
content = """
<p>
Berechnen Sie: %d %s %d <br />
</p>
<form action='rechner.cgi' method='GET'>
<input type='hidden' name='runde' value='%d'>
<input type='hidden' name='right' value='%d'>
<input type='hidden' name='prevresult' value='%d'>
Lösung: <input type='text' name='userresult'><br />
<input type='submit' value='OK'>
"""
# runde erhoehen
global runde
return content % (z1, operator, z2, runde, right,result)
if runde != 0:
"""ausser in 0. runde, da gibts noch kein userinput"""
global right
right += checkresult(prevresult, userresult)
if runde < 3:
"""additionsaufgabe"""
result = z1 + z2
operator = "+"
content = aufgabenpage(operator)
elif runde < 6:
"""multiplikationsaufgabe"""
result = z1 * z2
operator = "*"
content = aufgabenpage(operator)
if runde >= 6:
content = resultpage()
tmpl = """
<html>
<head><title>%s</title></head>
<body>%s</body>
</html>
"""
# ausgabe
print tmpl % (title, content)
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
import os
cgitb.enable()
print "<html>"
print "<head>"
print "<title> ptreb quadn cgi </title>"
print "</head>"
print "<body>"
form = cgi.FieldStorage() # inhalt query string
n = 20
if "n" in form:
n = int(form["n"].value)
print [z**2 for z in range(1,n)]
print n
print "</body>"
print "</html>" | Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# alles in einem nicht modul ausgelagert
print "Content-Type: text/html\n"
# wichtig cgi module importieren
import cgi
import cgitb
cgitb.enable()
import os
import random
import string
import sys
def getString(source):
"""Gibt einen grossen String zurueck und erwartet eine Liste von
Dateinamen.
"""
collection = ''
for f in source:
file_obj = file(f, 'r') # dateiobjekt
collection += '\n%\n'+ file_obj.read()
return collection # automatisch schliessen hoffentlich
def dumpString(string, filename):
"""Schreibt den uebergebenen string in die Datei filename.
"""
handle = file(filename, 'w')
handle.write(string)
def printText(collection # liste mit Zitaten (list)
, p=None # gesuchtes pattern (String)
):
"""Liefert ein total zufaelliges oder Zitat oder ein zfaelliges, welches das Pattern enthaelt.
"""
if p is None:
return random.choice(lall)
lfilter = [text for text in collection if p in text] # listcomprehension
# wenn lfilter eine leere liste ist wurde das pattern nicht gefunden
#random.choice(seq) liefert ein zufaelliges element einer sequenz
return random.choice(lfilter) if lfilter else 'Leider kommt dieser Ausdruck niemals vor'
#main
f1 = './fortunes/fortunes'
f2 = './fortunes/riddles'
f3 = './fortunes/literature'
dump = './dump.txt'
lall = []
source = list((f1,f2,f3)) # liste mit quelldateien
dumpString(getString(source), dump) # riesenstring in datei schreiben
lall = getString(source).split('\n%\n') # jedes Zitat ein Listenelement
#args = sys.argv[1:3]
#content += 'args: %s \n' % (args)
#content += printText(lall, args[1]) if len(args) >= 2 and args[0] == '-m' else printText(lall)
# alle requeststring parameter holen in form speichern
form = cgi.FieldStorage()
# m initialisieren, pattern
m = ""
# heredoc string benutzen um zeilenumbrueche im Seitenquelltext automatisch zu haben
# nicht mehr noetig \n zu setzen
template = """
<html>
<head><title>%s</title></head>
<body>\n%s</body>
</html>
"""
title = "Mein Titel"
content = "<h2>Fortunes</h2>\n"
if "m" in form:
m = form["m"].value
# benutzer darf suchwort eingeben und ok klicken
# \n um seitenquelltext lesbar zu machen
# variablen mit %s string ersetzung vormerken
content += """
<form action='fortune.cgi' method='GET' >
<input type='text' name='m' size='40' maxlength='10' value='%s'><br />
<input type='submit' name='ok' value='OK' size='90' maxlength='50' ><br />
"""
content += "</form>\n"
content = content % m
# wenn m nicht gesetzt ist abfangen
if len(m) > 0:
content += printText(lall, m)
else:
content += printText(lall)
print template % (title, content)
| Python |
#!/usr/bin/python
import cgi
import cgitb
cgitb.enable()
print "Content-Type: text/html\n"
print "<html>"
print "<head>"
print "<title> ptreb quad cgi </title>"
print "</head>"
print "<body>"
print [x**2 for x in range(1,21)]
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# modul das nur die logik funktionen enthaelt, webanwendung und darstellung in
# cgi script
import os
import random
import string
import sys
def getString(source):
"""Gibt einen grossen String zurueck und erwartet eine Liste von
Dateinamen.
"""
collection = ''
for f in source:
file_obj = file(f, 'r') # dateiobjekt
collection += '\n%\n'+ file_obj.read()
return collection # automatisch schliessen hoffentlich
def dumpString(string, filename):
"""Schreibt den uebergebenen string in die Datei filename.
"""
handle = file(filename, 'w')
handle.write(string)
def printText(collection # liste mit Zitaten (list)
, p=None # gesuchtes pattern (String)
):
"""Liefert ein total zufaelliges oder Zitat oder ein zfaelliges, welches das Pattern enthaelt.
"""
if p is None:
return random.choice(lall)
lfilter = [text for text in collection if p in text] # listcomprehension
# wenn lfilter eine leere liste ist wurde das pattern nicht gefunden
#random.choice(seq) liefert ein zufaelliges element einer sequenz
return random.choice(lfilter) if lfilter else 'Leider kommt dieser Ausdruck niemals vor'
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import os
template = "<html><head><title>%s</title></head><body>%s</body></html>"
title = "Mein Titel"
content = "<h2>Hallo international</h2>"
dic = {"de":"hallo welt", "en":"hello World"}
mylan = "de"
lan = os.environ["HTTP_ACCEPT_LANGUAGE"]
if lan[:2] == "en":
mylan = "en"
content += "<p>" + dic[mylan] + "</p>"
print template % (title, content)
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# modul das nur die logik funktionen enthaelt, webanwendung und darstellung in
# cgi script
import os
import random
import string
import sys
def getString(source):
"""Gibt einen grossen String zurueck und erwartet eine Liste von
Dateinamen.
"""
collection = ''
for f in source:
file_obj = file(f, 'r') # dateiobjekt
collection += '\n%\n'+ file_obj.read()
return collection # automatisch schliessen hoffentlich
def dumpString(string, filename):
"""Schreibt den uebergebenen string in die Datei filename.
"""
handle = file(filename, 'w')
handle.write(string)
def printText(collection # liste mit Zitaten (list)
, p=None # gesuchtes pattern (String)
):
"""Liefert ein total zufaelliges oder Zitat oder ein zfaelliges, welches das Pattern enthaelt.
"""
if p is None:
return random.choice(lall)
lfilter = [text for text in collection if p in text] # listcomprehension
# wenn lfilter eine leere liste ist wurde das pattern nicht gefunden
#random.choice(seq) liefert ein zufaelliges element einer sequenz
return random.choice(lfilter) if lfilter else 'Leider kommt dieser Ausdruck niemals vor'
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
import cgi
import cgitb
import os
cgitb.enable()
print "<html>"
print "<head>"
print "<title> ptreb quadn cgi </title>"
print "</head>"
print "<body>"
form = cgi.FieldStorage() # inhalt query string
n = 20
if "n" in form:
n = int(form["n"].value)
print [z**2 for z in range(1,n)]
print n
print "</body>"
print "</html>" | Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# alles in einem nicht modul ausgelagert
print "Content-Type: text/html\n"
# wichtig cgi module importieren
import cgi
import cgitb
cgitb.enable()
import os
import random
import string
import sys
def getString(source):
"""Gibt einen grossen String zurueck und erwartet eine Liste von
Dateinamen.
"""
collection = ''
for f in source:
file_obj = file(f, 'r') # dateiobjekt
collection += '\n%\n'+ file_obj.read()
return collection # automatisch schliessen hoffentlich
def dumpString(string, filename):
"""Schreibt den uebergebenen string in die Datei filename.
"""
handle = file(filename, 'w')
handle.write(string)
def printText(collection # liste mit Zitaten (list)
, p=None # gesuchtes pattern (String)
):
"""Liefert ein total zufaelliges oder Zitat oder ein zfaelliges, welches das Pattern enthaelt.
"""
if p is None:
return random.choice(lall)
lfilter = [text for text in collection if p in text] # listcomprehension
# wenn lfilter eine leere liste ist wurde das pattern nicht gefunden
#random.choice(seq) liefert ein zufaelliges element einer sequenz
return random.choice(lfilter) if lfilter else 'Leider kommt dieser Ausdruck niemals vor'
#main
f1 = './fortunes/fortunes'
f2 = './fortunes/riddles'
f3 = './fortunes/literature'
dump = './dump.txt'
lall = []
source = list((f1,f2,f3)) # liste mit quelldateien
dumpString(getString(source), dump) # riesenstring in datei schreiben
lall = getString(source).split('\n%\n') # jedes Zitat ein Listenelement
#args = sys.argv[1:3]
#content += 'args: %s \n' % (args)
#content += printText(lall, args[1]) if len(args) >= 2 and args[0] == '-m' else printText(lall)
# alle requeststring parameter holen in form speichern
form = cgi.FieldStorage()
# m initialisieren, pattern
m = ""
# heredoc string benutzen um zeilenumbrueche im Seitenquelltext automatisch zu haben
# nicht mehr noetig \n zu setzen
template = """
<html>
<head><title>%s</title></head>
<body>\n%s</body>
</html>
"""
title = "Mein Titel"
content = "<h2>Fortunes</h2>\n"
if "m" in form:
m = form["m"].value
# benutzer darf suchwort eingeben und ok klicken
# \n um seitenquelltext lesbar zu machen
# variablen mit %s string ersetzung vormerken
content += """
<form action='fortune.cgi' method='GET' >
<input type='text' name='m' size='40' maxlength='10' value='%s'><br />
<input type='submit' name='ok' value='OK' size='90' maxlength='50' ><br />
"""
content += "</form>\n"
content = content % m
# wenn m nicht gesetzt ist abfangen
if len(m) > 0:
content += printText(lall, m)
else:
content += printText(lall)
print template % (title, content)
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
print "Content-Type: text/html\n"
import cgi
import cgitb
cgitb.enable()
import random
form = cgi.FieldStorage()
#zustaende auslesen
# variablen initialisieren
# aus fieldStorage komme nur strings => immer casten
title = "CGI Rechner"
runde = int(form["runde"].value) +1 if "runde" in form else 0 # vorverarbeitung hier machen
# muss richtiges ergebnis des vorigen klicks merken
prevresult = int(form["prevresult"].value) if "prevresult" in form else None
right = int(form["right"].value) if "right" in form else 0
userresult = int(form["userresult"].value) if "userresult" in form else None
result = None
z1 = random.randint(1,10)
z2 = random.randint(1,10)
operator = None
def checkresult(prevresult, userresult):
if prevresult == userresult:
return 1
return 0
def resultpage():
content = """
<h2>Ergebnis</h2><br />
Sie haben: %d von %d Aufgaben richtig gelösst!<br />
<a href='rechner.cgi'>nochmal spielen</a>
"""
return content % (right, runde)
def aufgabenpage(operator):
content = """
<p>
Berechnen Sie: %d %s %d <br />
</p>
<form action='rechner.cgi' method='GET'>
<input type='hidden' name='runde' value='%d'>
<input type='hidden' name='right' value='%d'>
<input type='hidden' name='prevresult' value='%d'>
Lösung: <input type='text' name='userresult'><br />
<input type='submit' value='OK'>
"""
# runde erhoehen
global runde
return content % (z1, operator, z2, runde, right,result)
if runde != 0:
"""ausser in 0. runde, da gibts noch kein userinput"""
global right
right += checkresult(prevresult, userresult)
if runde < 3:
"""additionsaufgabe"""
result = z1 + z2
operator = "+"
content = aufgabenpage(operator)
elif runde < 6:
"""multiplikationsaufgabe"""
result = z1 * z2
operator = "*"
content = aufgabenpage(operator)
if runde >= 6:
content = resultpage()
tmpl = """
<html>
<head><title>%s</title></head>
<body>%s</body>
</html>
"""
# ausgabe
print tmpl % (title, content)
| Python |
#!/usr/bin/python
print "Content-Type: text/html\n"
print "<html>"
print "<head>"
print "<title> ptreb hallo cgi </title>"
print "</head>"
print "<body>"
print "Hello CGI Python "
print "</body>"
print "</html>"
| Python |
#!/usr/bin/python
#-*- coding: utf-8 -*-
# print erzeugt einen zeilunumbruch automatisch
print "Content-Type: text/html\n"
# wichtig cgi module importieren
# import ohne .py wenn im selben ordner
# fortune.methode zum benutzen einer funktion
import fortune
import cgi
import cgitb
cgitb.enable()
#main, war in fortunes.py drin
f1 = './fortunes/fortunes'
f2 = './fortunes/riddles'
f3 = './fortunes/literature'
dump = './dump.txt'
lall = []
source = list((f1,f2,f3)) # liste mit quelldateien
fortune.dumpString(fortune.getString(source), dump) # riesenstring in datei schreiben
lall = fortune.getString(source).split('\n%\n') # jedes Zitat ein Listenelement
#args = sys.argv[1:3]
#content += 'args: %s \n' % (args)
#content += printText(lall, args[1]) if len(args) >= 2 and args[0] == '-m' else printText(lall)
# alle requeststring parameter holen in form speichern
form = cgi.FieldStorage()
# m initialisieren, pattern
m = ""
# heredoc string benutzen um zeilenumbrueche im Seitenquelltext automatisch zu haben
# nicht mehr noetig \n zu setzen
template = """
<html>
<head><title>%s</title></head>
<body>\n%s</body>
</html>
"""
title = "Mein Titel"
content = "<h2>Fortunes</h2>\n"
if "m" in form:
m = form["m"].value
# benutzer darf suchwort eingeben und ok klicken
# \n um seitenquelltext lesbar zu machen
# variablen mit %s string ersetzung vormerken
content += """
<form action='fortune_ok.cgi' method='GET' >
<input type='text' name='m' size='40' maxlength='10' value='%s'><br />
<input type='submit' name='ok' value='OK' size='90' maxlength='50' ><br />
"""
content += "</form>\n"
content = content % m
# wenn m nicht gesetzt ist abfangen
if len(m) > 0:
content += fortune.printText(lall, m)
else:
content += fortune.printText(lall)
print template % (title, content)
| Python |
#!python
"""Bootstrap setuptools installation
If you want to use setuptools in your package's setup.py, just include this
file in the same directory with it, and add this to the top of your setup.py::
from ez_setup import use_setuptools
use_setuptools()
If you want to require a specific version of setuptools, set a download
mirror, or use an alternate download directory, you can do so by supplying
the appropriate options to ``use_setuptools()``.
This file can also be run as a script to install or upgrade setuptools.
"""
import sys
DEFAULT_VERSION = "0.6c3"
DEFAULT_URL = "http://cheeseshop.python.org/packages/%s/s/setuptools/" % sys.version[:3]
md5_data = {
'setuptools-0.6b1-py2.3.egg': '8822caf901250d848b996b7f25c6e6ca',
'setuptools-0.6b1-py2.4.egg': 'b79a8a403e4502fbb85ee3f1941735cb',
'setuptools-0.6b2-py2.3.egg': '5657759d8a6d8fc44070a9d07272d99b',
'setuptools-0.6b2-py2.4.egg': '4996a8d169d2be661fa32a6e52e4f82a',
'setuptools-0.6b3-py2.3.egg': 'bb31c0fc7399a63579975cad9f5a0618',
'setuptools-0.6b3-py2.4.egg': '38a8c6b3d6ecd22247f179f7da669fac',
'setuptools-0.6b4-py2.3.egg': '62045a24ed4e1ebc77fe039aa4e6f7e5',
'setuptools-0.6b4-py2.4.egg': '4cb2a185d228dacffb2d17f103b3b1c4',
'setuptools-0.6c1-py2.3.egg': 'b3f2b5539d65cb7f74ad79127f1a908c',
'setuptools-0.6c1-py2.4.egg': 'b45adeda0667d2d2ffe14009364f2a4b',
'setuptools-0.6c2-py2.3.egg': 'f0064bf6aa2b7d0f3ba0b43f20817c27',
'setuptools-0.6c2-py2.4.egg': '616192eec35f47e8ea16cd6a122b7277',
'setuptools-0.6c3-py2.3.egg': 'f181fa125dfe85a259c9cd6f1d7b78fa',
'setuptools-0.6c3-py2.4.egg': 'e0ed74682c998bfb73bf803a50e7b71e',
'setuptools-0.6c3-py2.5.egg': 'abef16fdd61955514841c7c6bd98965e',
}
import sys, os
def _validate_md5(egg_name, data):
if egg_name in md5_data:
from md5 import md5
digest = md5(data).hexdigest()
if digest != md5_data[egg_name]:
print >>sys.stderr, (
"md5 validation of %s failed! (Possible download problem?)"
% egg_name
)
sys.exit(2)
return data
def use_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
download_delay=15
):
"""Automatically find/download setuptools and make it available on sys.path
`version` should be a valid setuptools version number that is available
as an egg for download under the `download_base` URL (which should end with
a '/'). `to_dir` is the directory where setuptools will be downloaded, if
it is not already available. If `download_delay` is specified, it should
be the number of seconds that will be paused before initiating a download,
should one be required. If an older version of setuptools is installed,
this routine will print a message to ``sys.stderr`` and raise SystemExit in
an attempt to abort the calling script.
"""
try:
import setuptools
if setuptools.__version__ == '0.0.1':
print >>sys.stderr, (
"You have an obsolete version of setuptools installed. Please\n"
"remove it from your system entirely before rerunning this script."
)
sys.exit(2)
except ImportError:
egg = download_setuptools(version, download_base, to_dir, download_delay)
sys.path.insert(0, egg)
import setuptools; setuptools.bootstrap_install_from = egg
import pkg_resources
try:
pkg_resources.require("setuptools>="+version)
except pkg_resources.VersionConflict, e:
# XXX could we install in a subprocess here?
print >>sys.stderr, (
"The required version of setuptools (>=%s) is not available, and\n"
"can't be installed while this script is running. Please install\n"
" a more recent version first.\n\n(Currently using %r)"
) % (version, e.args[0])
sys.exit(2)
def download_setuptools(
version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,
delay = 15
):
"""Download setuptools from a specified location and return its filename
`version` should be a valid setuptools version number that is available
as an egg for download under the `download_base` URL (which should end
with a '/'). `to_dir` is the directory where the egg will be downloaded.
`delay` is the number of seconds to pause before an actual download attempt.
"""
import urllib2, shutil
egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])
url = download_base + egg_name
saveto = os.path.join(to_dir, egg_name)
src = dst = None
if not os.path.exists(saveto): # Avoid repeated downloads
try:
from distutils import log
if delay:
log.warn("""
---------------------------------------------------------------------------
This script requires setuptools version %s to run (even to display
help). I will attempt to download it for you (from
%s), but
you may need to enable firewall access for this script first.
I will start the download in %d seconds.
(Note: if this machine does not have network access, please obtain the file
%s
and place it in this directory before rerunning this script.)
---------------------------------------------------------------------------""",
version, download_base, delay, url
); from time import sleep; sleep(delay)
log.warn("Downloading %s", url)
src = urllib2.urlopen(url)
# Read/write all in one block, so we don't create a corrupt file
# if the download is interrupted.
data = _validate_md5(egg_name, src.read())
dst = open(saveto,"wb"); dst.write(data)
finally:
if src: src.close()
if dst: dst.close()
return os.path.realpath(saveto)
def main(argv, version=DEFAULT_VERSION):
"""Install or upgrade setuptools and EasyInstall"""
try:
import setuptools
except ImportError:
egg = None
try:
egg = download_setuptools(version, delay=0)
sys.path.insert(0,egg)
from setuptools.command.easy_install import main
return main(list(argv)+[egg]) # we're done here
finally:
if egg and os.path.exists(egg):
os.unlink(egg)
else:
if setuptools.__version__ == '0.0.1':
# tell the user to uninstall obsolete version
use_setuptools(version)
req = "setuptools>="+version
import pkg_resources
try:
pkg_resources.require(req)
except pkg_resources.VersionConflict:
try:
from setuptools.command.easy_install import main
except ImportError:
from easy_install import main
main(list(argv)+[download_setuptools(delay=0)])
sys.exit(0) # try to force an exit
else:
if argv:
from setuptools.command.easy_install import main
main(argv)
else:
print "Setuptools version",version,"or greater has been installed."
print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'
def update_md5(filenames):
"""Update our built-in md5 registry"""
import re
from md5 import md5
for name in filenames:
base = os.path.basename(name)
f = open(name,'rb')
md5_data[base] = md5(f.read()).hexdigest()
f.close()
data = [" %r: %r,\n" % it for it in md5_data.items()]
data.sort()
repl = "".join(data)
import inspect
srcfile = inspect.getsourcefile(sys.modules[__name__])
f = open(srcfile, 'rb'); src = f.read(); f.close()
match = re.search("\nmd5_data = {\n([^}]+)}", src)
if not match:
print >>sys.stderr, "Internal error!"
sys.exit(2)
src = src[:match.start(1)] + repl + src[match.end(1):]
f = open(srcfile,'w')
f.write(src)
f.close()
if __name__=='__main__':
if len(sys.argv)>2 and sys.argv[1]=='--md5update':
update_md5(sys.argv[2:])
else:
main(sys.argv[1:])
| Python |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# setup.py
# Part of 21obuys, a package providing enumerated types for Python.
#
# Copyright © 2007 Ben Finney
# This is free software; you may copy, modify and/or distribute this work
# under the terms of the GNU General Public License, version 2 or later
# or, at your option, the terms of the Python license.
import ez_setup
ez_setup.use_setuptools()
from setuptools import setup, find_packages
setup(
name = "bigo55",
version = '1.0',
packages = find_packages('src'), # include all packages under src
package_dir = {'':'src'}, # tell distutils packages are under src
py_modules = ['captcha_price','choiceproxy','crawlerhttp','logfacade','pageparser','PersistentQueue','spider'],
# setuptools metadata
zip_safe = True,
#test_suite = "test.test_enum.suite",
package_data = {
'': ["*.*"],
},
# Project uses reStructuredText, so ensure that the docutils get
# installed or upgraded on the target machine
install_requires = ['chardet','enum','BeautifulSoup','threadpool'],
# PyPI metadata
# metadata for upload to PyPI
author = "zhongfeng",
author_email = "fzhong@travelsky.com",
description = "21obuys Package",
license = "PSF",
keywords = "360buy newegg crawlers",
classifiers = [
"Development Status :: 4 - Beta",
"License :: OSI Approved :: GNU General Public License (GPL)",
"License :: OSI Approved :: Python Software Foundation License",
"Programming Language :: Python",
"Topic :: Software Development :: Libraries :: Python Modules",
"Operating System :: OS Independent",
"Intended Audience :: Developers",
],
)
| Python |
"""
1. Generate ie6 module with win32/com/tools/readtlb.py from the ctypes
package
(I forget the details, but you can probably skip this and just use
ie6_gen.py that comes with ctypes in the samples directory -- change
the 'import ie6' below as appropriate.)
2. Generate a GUID and cut-n-paste it as PythonBHO._reg_clsid_. To
generate a GUID using pywin32 (aka "Python for Windows Extensions"):
import pythoncom
pythoncom.CreateGUID()
3. python bho_skel.py /regserver
4. Use DebugView or similar to see the output from print statements.
5. Run IE, watch output (IIRC dispinterface_EventReceiver prints out
messages for unimplemented events).
6. Remember to write something useful ;-)
"""
import sys
import _winreg
from ctypes import *
from ctypes.com import IUnknown, PIUnknown, REFIID, GUID, STDMETHOD, HRESULT, \
COMObject
from ctypes.com.automation import IDispatch, BSTR, VARIANT, \
dispinterface, DISPMETHOD
from ctypes.com.register import Registrar
from ctypes.com.connectionpoints import dispinterface_EventReceiver, \
GetConnectionPoint
import ie6 # module generated by ctypes/com/tools/readtlb.py
# _Logger is pinched from ctypes 0.6.2
# --------------------------------------------------------------------
from ctypes import windll
kernel32 = windll.kernel32
# Hm. We cannot redirect sys.stderr/sys.stdout in the inproc case,
# If the process is Python, the user would be pissed off if we did.
class _Logger(object):
# Redirect standard output and standard error to
# win32 Debug Messages. Output can be viewed for example
# in DebugView from www.sysinternals.com
_installed = 0
_text = ""
def write(self, text):
self._text += str(text)
if "\n" in self._text:
kernel32.OutputDebugStringA(self._text)
self._text = ""
def install(cls):
if cls._installed:
return
import sys
sys.stdout = sys.stderr = cls()
cls._installed = 1
install = classmethod(install)
def isatty(self):
return 0
# --------------------------------------------------------------------
_Logger.install() # redirect stdout to win32's OutputDebugStringA()
HKLM = _winreg.HKEY_LOCAL_MACHINE
BHO_KEY = ("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\"
"Browser Helper Objects\\")
class MyRegistrar(Registrar):
def build_table(self):
table = Registrar.build_table(self)
table.extend([(HKLM, BHO_KEY+self._reg_clsid_, "", None)])
return table
class IObjectWithSite(IUnknown):
_iid_ = GUID("{FC4801A3-2BA9-11CF-A229-00AA003D7352}")
IObjectWithSite._methods_ = IUnknown._methods_ + [
(STDMETHOD(HRESULT, "SetSite", PIUnknown)),
(STDMETHOD(HRESULT, "GetSite", POINTER(c_void_p), REFIID))]
class PythonBHO(COMObject):
_reg_clsid_ = "{693D1AC0-2D77-11D8-9B9E-FB41F7E93A45}"
_reg_progid_ = "PythonBHO"
_com_interfaces_ = [IObjectWithSite]
def _get_registrar(cls):
return MyRegistrar(cls)
_get_registrar = classmethod(_get_registrar)
def IObjectWithSite_SetSite(self, this, pUnkSite):
self.browser = POINTER(ie6.IWebBrowser2)()
hr = pUnkSite.QueryInterface(
byref(ie6.IWebBrowser2._iid_), byref(self.browser))
sink = DWebBrowserEvents2Impl()
sink.handle = sink.connect(self.browser)
class DWebBrowserEvents2Impl(dispinterface_EventReceiver):
_com_interfaces_ = [ie6.DWebBrowserEvents2]
def OnQuit(self, this, *args):
self.disconnect(self.handle)
def BeforeNavigate2(self, this, pDisp, url, Flags, TargetFrameName,
PostData, Headers, Cancel):
print "url", url
if __name__ == '__main__':
from ctypes.com.server import UseCommandLine
UseCommandLine(PythonBHO)
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
京东价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from j360buy.j360_feature import J360buy_FEATURES_MAP__
import Image
import re
import time
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_360Buy(CaptchaProfile):
def __init__(self,features_map = J360buy_FEATURES_MAP__):
super(CaptchaProfile_360Buy,self).__init__(features_map)
def __new__(cls,features_map = J360buy_FEATURES_MAP__):
return super(CaptchaProfile_360Buy, cls).__new__(cls,features_map)
def split(self, im,top = 3,bottom = 11):
matrix = {(48,12) : [(15, 3, 21, 11), (23, 3, 25, 11),(27,3,33,11),(35,3,41,11)],
(52,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,33,11),(35,3,41,11),(43,3,49,11)],
(65,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,41,11),(43,3,49,11),(51,3,57,11)],
(75,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,45,11),(47,3,49,11),(51,3,57,11),(59, 3, 65, 11)],
(80,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,45,11),(47,3,53,11),(55,3,57,11),(59, 3, 65, 11),(67,3,73,11)]
}
return [im.crop(box) for box in matrix[im.size]]
def captcha_360buy(filename):
return captcha(filename, CaptchaProfile_360Buy())
def test():
print captcha_360buy(r'c:\gp359329,2.png')
if __name__ == '__main__':
im = Image.open(r'c:\1.png')
im2 = Image.open(r'c:\1.png')
diff = ImageChops.difference(im, im2)
im = im.filter(ImageFilter.EDGE_ENHANCE_MORE).convert('L').convert('1')
dt = im.getdata()
print im.size
it1 = im.crop((15, 3, 21, 11))
it2 = im.crop((23, 3, 29, 11))
it3 = im.crop((31, 3, 37, 11))
it4 = im.crop((39, 3, 45, 11))
it5 = im.crop((47, 3, 49, 11))
it6 = im.crop((51, 3, 57, 11))
it7 = im.crop((59, 3, 65, 11))
cia = CaptchaImageAlgorithm()
s7 = cia.GetBinaryMap(it1)
print s7
profile = CaptchaProfile_360Buy()
print '+++++++++++++++++++++++++++'
for t in range(100):
print captcha_360buy(r'c:\5.png')
| Python |
#/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2011-7-29
主要用于从网站上爬取信息后，抽取页面信息；
@author: zhongfeng
'''
from j360buy.image_price import captcha_360buy
from pageparser import *
from threadpool import ThreadPool, WorkRequest
import json
import os
import re
import string
import threading
import urllib
from spiderconfigparser import SpiderConfig
from crawlerhttp import crawleRetries
j360buyRoot = ObuyUrlSummary(url=r'http://www.360buy.com/allSort.aspx', name='360buy',
isRecursed=True, catagoryLevel=0)
def translator(frm='', to='', delete='', keep=None):
if len(to) == 1:
to = to * len(frm)
trans = string.maketrans(frm, to)
if keep is not None:
allchars = string.maketrans('', '')
delete = allchars.translate(allchars, keep.translate(allchars, delete))
def translate(s):
return s.translate(trans, delete)
return translate
digits_only = translator(keep=string.digits)
class J360buyAllSortParser(RootCatagoryPageParser):
'''
从http://www.360buy.com/allSort.aspx获取所有的分类信息，
组合成ObuyUrlSummary
'''
mainHost = r'http://www.360buy.com'
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(J360buyAllSortParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def getBaseSort3UrlSums(self):
finalUrlList = []
allSort = self.soup.find(name='div', attrs={'id':'allsort'})
for t in allSort.findAll(name='div', attrs={'id':re.compile('JDS_[0-9]+')}):#一级分类
sort_1 = t.find(name='div', attrs={'class':'mt'})
name, url = ParserUtils.parserTag_A(sort_1.h2.a)
sort_1_urlsum = self.buildSort_N(url, name, self.rootUrlSummary, isCrawle=False)
sort_2 = t.find(name='div', attrs={'class':'mc'})
for tt in sort_2(name='dl'):#二级分类
name, url = ParserUtils.parserTag_A(tt.dt.a)
url = ''.join((self.mainHost, url))
sort_2_urlsum = self.buildSort_N(url, name, sort_1_urlsum, isCrawle=False)
for ttt in tt.dd(name='em'):#三级分类
name, url = ParserUtils.parserTag_A(ttt.a)
url = ''.join((self.mainHost, '/', url))
sort_3_urlsum = self.buildSort_N(url, name, sort_2_urlsum,firstFinalPage=True)
finalUrlList.append(sort_3_urlsum)
return finalUrlList
class J360buySort3PageParser(Sort3PageParser):
'''
360Buy三级页面解析类
'''
pricePageNum = 4
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(J360buySort3PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def nextPageUrlPattern(self):
urlSegs = self.rootUrlSummary.url.rsplit('.', 1)
pageSeg = '-0-0-0-0-0-0-0-1-1-{}'
return '%s%s.%s' % (urlSegs[0], pageSeg, urlSegs[1])
def getTotal(self):
pageSeg = self.soup.find(name='div', attrs={'id':'filter'}).find(attrs={'class':'pagin pagin-m fr'})
totalPage = int(pageSeg.span.string.split('/')[-1])
if totalPage > SpiderConfig.getMaxPage():
totalPage = SpiderConfig.getMaxPage()
return totalPage
def __getAdWords(self, plist):
adQueryDict = eval(re.compile(r'{.*}').search(str(plist.script)).group())
baseUrl = 'http://www.360buy.com/JdService.aspx?callback=GetJdwsmentsCallback&action=GetJdwsment'
url = '&'.join((baseUrl, urllib.urlencode(adQueryDict)))
result = crawleRetries(url)
ct = re.compile(r'{.*}').search(result.content)
if ct is None:
return []
jObj = json.loads(ct.group())
return jObj['html']
def parserPageInfos(self):
resultList = []
plist = self.soup.find(name='div', attrs={'id':'plist'})
if plist is None:
raise Exception("Page Error")
return resultList
try:
pool = ThreadPool(self.pricePageNum)
pid_ad = dict([[int(wa['Wid']), wa['AdTitle']] for wa in self.__getAdWords(plist)])
for li in plist(name='li', attrs={'sku':re.compile('[0-9]+')}):
if li['sku'].startswith('100'): #过滤非京东自营商品
continue
pid = int(li['sku'])
pName,url = ParserUtils.parserTag_A(li.find(name='div', attrs={'class':'p-name'}).a)
priceImgUrl = li.find(name='div', attrs={'class':'p-price'}).img['src']
adWords = pid_ad.get(pid, '')
imgUrlSeg = li.find(name='div',attrs={'class':'p-img'}).find(name='img')
imgUrl = ''
if imgUrlSeg:
try:
imgUrl = imgUrlSeg['src']
except Exception:
imgUrl = imgUrlSeg['src2']
evaluateNumSeg = li.find(name='span',attrs={'class':'evaluate'})
reputationSeg = li.find(name='span',attrs={'class':'reputation'}) #好评度
reputation = ParserUtils.getDigit(reputationSeg.getText())
evaluateNum = ParserUtils.getDigit(evaluateNumSeg.getText())
prodDetail = ProductDetails(productId=pid, name=pName, adWords=adWords,imageUrl=imgUrl,
reputation=reputation,evaluateNum=evaluateNum,fullUrl=url)
prodDetail.catagory = self.rootUrlSummary
pimgUrlSumm = ObuyUrlSummary(url = priceImgUrl)
req = WorkRequest(getProductPrice, [pimgUrlSumm, prodDetail, resultList, pool,captcha_360buy], None,
callback=None)
pool.putRequest(req)
pool.wait()
except Exception,e:
raise e
finally:
pool.dismissWorkers(num_workers=self.pricePageNum)
return resultList
class J360buySort4PageParser(J360buySort3PageParser):
'''
分类四级页面为列表页面，只抽取Product信息
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(J360buySort4PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def parserSubUrlSums(self):
pass
parserDict = {0:J360buyAllSortParser, 3:J360buySort3PageParser, 4:J360buySort4PageParser}
import hashlib
def getMd5Key(src):
m2 = hashlib.md5()
m2.update(src)
dest2 = int(m2.hexdigest(), 16)
return dest2
''' test '''
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir, 'test_resources')
def test360BuyAllSortPage():
fileName = os.path.join(testFilePath, 'allSort.aspx')
with open(fileName, 'r') as fInput:
content = fInput.read()
rootUrlSum = ObuyUrlSummary(url=r'http://www.360buy.com/allSort.aspx', name='360buy')
firstPage = J360buyAllSortParser(content, rootUrlSum)
s0 = set()
s1 = set()
s2 = set()
for sort_3 in firstPage.getBaseSort3UrlSums():
parentPath = sort_3.parentPath
s0.add(parentPath[1].url)
s1.add(parentPath[2].url)
s2.add(sort_3.url)
sa = set()
import itertools
for t in itertools.chain(s0,s1,s2):
sa.add(str(getMd5Key(t))[0:16])
print len(sa)
print len(s0),len(s1),len(s2)
def testSort3Page():
fileName = os.path.join(testFilePath, '360buy_2011-08-15_12-26-01.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://www.360buy.com/products/737-794-870.html', parentPath=[('test')], catagoryLevel=3)
sort3Page = J360buySort3PageParser(content, sort_3_urlsum)
for sort_4 in sort3Page.getSort4PageUrlSums():
print sort_4
def testSort3Details():
fileName = os.path.join(testFilePath, '360buy_2011-08-15_12-26-01.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://www.360buy.com/products/737-794-798-0-0-0-0-0-0-0-1-1-1-1-72-33.html', parentPath=[('test')], catagoryLevel=3)
result = crawleRetries(urlSum = sort_3_urlsum)
sort3Page = J360buySort3PageParser(result.content, sort_3_urlsum)
for prod in sort3Page.parserPageInfos():
print prod.logstr()
if __name__ == '__main__':
#test360BuyAllSortPage()
#testSort3Page()
testSort3Details()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-16
@author: zhongfeng
'''
J360buy_FEATURES_MAP__ = {
'''
__
__
__
__
__
__
##
##
'''
:
'.',
'''
_####_
##__##
#___#_
##__##
#___#_
##__##
#___##
_###__
'''
:
'0',
'''
_####_
##__##
#___#_
##__##
#___#_
##__##
##__##
_###__
'''
:
'0',
'''
__##__
_#_#__
__##__
__##__
__#___
__##__
__#___
_####_
'''
:
'1',
'''
##__##
____#_
___##_
__#___
_##___
#_____
######
'''
:
'2',
'''
_####_
##__##
____#_
___##_
__#___
_##___
#_____
######
'''
:
'2',
'''
_####_
##__##
____#_
__##__
____##
____##
##__#_
_####_
'''
:
'3',
'''
___##_
__#_#_
_#_##_
#__#__
######
____#_
___##_
'''
:
'4',
'''
____#_
___##_
__#_#_
_#_##_
#__#__
######
____#_
___##_
'''
:
'4',
'''
_#####
_#____
_##___
_#_##_
____##
____#_
##__##
_###__
'''
:
'5',
'''
__###_
_##___
#_____
#####_
#___##
##__#_
#___##
_###__
'''
:
'6',
'''
######
____#_
___##_
___#__
__##__
__#___
_##___
_#____
'''
:
'7',
'''
_####_
##__##
#___#_
_###__
##__##
##__##
#___#_
_####_
'''
:
'8',
'''
_####_
##__##
#___#_
_###__
##__##
#___##
##__#_
_####_
'''
:
'8',
'''
_####_
##__##
#___#_
##__##
_##_##
____##
___#__
_###__
'''
:
'9',
'''
_####_
##__##
#___#_
##__##
_###_#
____##
___#__
_###__
'''
:
'9',
} | Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
京东价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from j360buy.j360_feature import J360buy_FEATURES_MAP__
import Image
import re
import time
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_360Buy(CaptchaProfile):
def __init__(self,features_map = J360buy_FEATURES_MAP__):
super(CaptchaProfile_360Buy,self).__init__(features_map)
def __new__(cls,features_map = J360buy_FEATURES_MAP__):
return super(CaptchaProfile_360Buy, cls).__new__(cls,features_map)
def split(self, im,top = 3,bottom = 11):
matrix = {(48,12) : [(15, 3, 21, 11), (23, 3, 25, 11),(27,3,33,11),(35,3,41,11)],
(52,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,33,11),(35,3,41,11),(43,3,49,11)],
(65,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,41,11),(43,3,49,11),(51,3,57,11)],
(75,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,45,11),(47,3,49,11),(51,3,57,11),(59, 3, 65, 11)],
(80,12) : [(15, 3, 21, 11), (23, 3, 29, 11),(31,3,37,11),(39,3,45,11),(47,3,53,11),(55,3,57,11),(59, 3, 65, 11),(67,3,73,11)]
}
return [im.crop(box) for box in matrix[im.size]]
def captcha_360buy(filename):
return captcha(filename, CaptchaProfile_360Buy())
def test():
print captcha_360buy(r'c:\gp359329,2.png')
if __name__ == '__main__':
im = Image.open(r'c:\1.png')
im2 = Image.open(r'c:\1.png')
diff = ImageChops.difference(im, im2)
im = im.filter(ImageFilter.EDGE_ENHANCE_MORE).convert('L').convert('1')
dt = im.getdata()
print im.size
it1 = im.crop((15, 3, 21, 11))
it2 = im.crop((23, 3, 29, 11))
it3 = im.crop((31, 3, 37, 11))
it4 = im.crop((39, 3, 45, 11))
it5 = im.crop((47, 3, 49, 11))
it6 = im.crop((51, 3, 57, 11))
it7 = im.crop((59, 3, 65, 11))
cia = CaptchaImageAlgorithm()
s7 = cia.GetBinaryMap(it1)
print s7
profile = CaptchaProfile_360Buy()
print '+++++++++++++++++++++++++++'
for t in range(100):
print captcha_360buy(r'c:\5.png')
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-1
@author: zhongfeng
'''
from j360buy.j360pageparser import parserDict,j360buyRoot
from spider import main
if __name__ == '__main__':
main(j360buyRoot,parserDict)
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-16
@author: zhongfeng
'''
J360buy_FEATURES_MAP__ = {
'''
__
__
__
__
__
__
##
##
'''
:
'.',
'''
_####_
##__##
#___#_
##__##
#___#_
##__##
#___##
_###__
'''
:
'0',
'''
_####_
##__##
#___#_
##__##
#___#_
##__##
##__##
_###__
'''
:
'0',
'''
__##__
_#_#__
__##__
__##__
__#___
__##__
__#___
_####_
'''
:
'1',
'''
##__##
____#_
___##_
__#___
_##___
#_____
######
'''
:
'2',
'''
_####_
##__##
____#_
___##_
__#___
_##___
#_____
######
'''
:
'2',
'''
_####_
##__##
____#_
__##__
____##
____##
##__#_
_####_
'''
:
'3',
'''
___##_
__#_#_
_#_##_
#__#__
######
____#_
___##_
'''
:
'4',
'''
____#_
___##_
__#_#_
_#_##_
#__#__
######
____#_
___##_
'''
:
'4',
'''
_#####
_#____
_##___
_#_##_
____##
____#_
##__##
_###__
'''
:
'5',
'''
__###_
_##___
#_____
#####_
#___##
##__#_
#___##
_###__
'''
:
'6',
'''
######
____#_
___##_
___#__
__##__
__#___
_##___
_#____
'''
:
'7',
'''
_####_
##__##
#___#_
_###__
##__##
##__##
#___#_
_####_
'''
:
'8',
'''
_####_
##__##
#___#_
_###__
##__##
#___##
##__#_
_####_
'''
:
'8',
'''
_####_
##__##
#___#_
##__##
_##_##
____##
___#__
_###__
'''
:
'9',
'''
_####_
##__##
#___#_
##__##
_###_#
____##
___#__
_###__
'''
:
'9',
} | Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
from logfacade import LoggerFactory
'''
Created on 2011-10-9
@author: zhongfeng
'''
from crawlerhttp import crawle
import re
from threadpool import ThreadPool, WorkRequest
from dbproc.basedbproc import getConnect,MySQLQueryPagination
def getProdImgUrlFromProdId(*prodId):
rawId,id = prodId[0]
baseUrl = r'http://www.360buy.com/lishiset.aspx?callback=jdRecent.setData&id=%s'
url = baseUrl % rawId
result = crawle(url)
imgUrl = ''
if result.code == 200:
ct = re.compile(r'{.*}').search(result.content)
if ct != None:
jd = eval(ct.group())
imgUrl = jd['img']
imgUrl = imgUrl.replace('n5', 'n2',1)
return id,imgUrl
def proc_result(request, result):
logger = LoggerFactory.getLogger(logName='360buy')
logger.info(result)
def main_crawle(prodIdList,thread_num = 20):
try:
pool = ThreadPool(thread_num)
for prodId in prodIdList:
req = WorkRequest(getProdImgUrlFromProdId, [prodId], None,
callback=proc_result)
pool.putRequest(req)
pool.wait()
except Exception,e:
raise e
finally:
pool.dismissWorkers(num_workers=thread_num)
if __name__ == '__main__':
conn = getConnect()
queryPagin = MySQLQueryPagination(conn,numPerPage = 1000)
sql = 'SELECT raw_id,id FROM `prod_base_info_3c` where site_id = 6'
for prodIds in queryPagin.queryForList(sql):
main_crawle(prodIds)
conn.close()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
from logfacade import LoggerFactory
'''
Created on 2011-10-9
@author: zhongfeng
'''
from crawlerhttp import crawle
import re
from threadpool import ThreadPool, WorkRequest
from dbproc.basedbproc import getConnect,MySQLQueryPagination
def getProdImgUrlFromProdId(*prodId):
rawId,id = prodId[0]
baseUrl = r'http://www.360buy.com/lishiset.aspx?callback=jdRecent.setData&id=%s'
url = baseUrl % rawId
result = crawle(url)
imgUrl = ''
if result.code == 200:
ct = re.compile(r'{.*}').search(result.content)
if ct != None:
jd = eval(ct.group())
imgUrl = jd['img']
imgUrl = imgUrl.replace('n5', 'n2',1)
return id,imgUrl
def proc_result(request, result):
logger = LoggerFactory.getLogger(logName='360buy')
logger.info(result)
def main_crawle(prodIdList,thread_num = 20):
try:
pool = ThreadPool(thread_num)
for prodId in prodIdList:
req = WorkRequest(getProdImgUrlFromProdId, [prodId], None,
callback=proc_result)
pool.putRequest(req)
pool.wait()
except Exception,e:
raise e
finally:
pool.dismissWorkers(num_workers=thread_num)
if __name__ == '__main__':
conn = getConnect()
queryPagin = MySQLQueryPagination(conn,numPerPage = 1000)
sql = 'SELECT raw_id,id FROM `prod_base_info_3c` where site_id = 6'
for prodIds in queryPagin.queryForList(sql):
main_crawle(prodIds)
conn.close()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-1
@author: zhongfeng
'''
from j360buy.j360pageparser import parserDict,j360buyRoot
from spider import main
if __name__ == '__main__':
main(j360buyRoot,parserDict)
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-9-24
@author: zhongfeng
'''
import re,os,sys
import chardet
from pageparser import ObuyUrlSummary
from utils import Singleton
from ConfigParser import ConfigParser, NoOptionError
def __getUrlSumsFromSection(section):
curPath = os.path.abspath(os.path.dirname(sys.argv[0]))
fileName = os.path.join(curPath, 'urls.cfg')
print 'spider.cfg full path:%s' % fileName
urls = list()
if not os.path.exists(fileName):
return urls
regx = r'\[%s\]' % section
includeSecRegx = re.compile(regx)
otherSecRegx = re.compile(r'\[.*\]')
flag = False
with file(fileName) as inputFile:
for line in inputFile:
encoding = chardet.detect(line)['encoding']
line = line.decode(encoding,'ignore')
if (not flag) and includeSecRegx.match(line):
flag = True
elif flag:
if otherSecRegx.match(line):
break
if line.strip() != '':
line = ' '.join(line.split())
ret = line.split(',')
ret = [it.strip() for it in ret]
urlSumm = ObuyUrlSummary(name = ret[1],url = ret[0],catagoryLevel = int(ret[2]))
urls.append(urlSumm)
return urls
def getIncludeUrlSums():
return __getUrlSumsFromSection('include')
def getExcludeUrlSums():
return __getUrlSumsFromSection('exclude')
class SpiderConfig(Singleton):
@classmethod
def _init(cls):
curPath = os.path.abspath(os.path.dirname(sys.argv[0]))
fileName = os.path.join(curPath, 'spider.conf')
cls.cf = ConfigParser()
cls.cf.read(fileName)
@classmethod
def getConfig(cls,option):
if not hasattr(cls, 'cf'):
cls._init()
try:
return cls.cf.get('conf',option)
except Exception:
pass
@classmethod
def getMaxPage(cls):
ret = cls.getConfig('max_page')
if ret:
return int(ret)
return 50
@classmethod
def getThreadNum(cls):
threadNum = cls.getConfig('thread_num')
if threadNum:
return int(threadNum)
return 10
@classmethod
def getProxy(cls):
return cls.getConfig('ftp_proxy')
@classmethod
def isStartSpider(cls):
flag = int(cls.getConfig('is_spider'))
if flag is not None:
return flag
return True
@classmethod
def isUpload(cls):
flag = int(cls.getConfig('is_upload'))
if flag is not None:
return flag
return True
if __name__ == '__main__':
print SpiderConfig.getMaxPage()
print SpiderConfig.getThreadNum()
print SpiderConfig.getProxy()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
import Image
import re,itertools
import time
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaAlgorithm(object):
'''captcha algorithm'''
def LevenshteinDistance(self, m, n):
c = [[i] for i in range(0, len(m) + 1)]
c[0] = [j for j in range(0, len(n) + 1)]
for i in range(0, len(m)):
for j in range(0, len(n)):
c[i + 1].append(
min(
c[i][j + 1] + 1,
c[i + 1][j] + 1,
c[i][j] + (0 if m[i] == n[j] else 1)
)
)
return c[-1][-1]
class CaptchaImageAlgorithm(object):
'''captcha image algorithm'''
@staticmethod
def GetPixelsXEdges(im):
pixels = im.load()
xsize, ysize = im.size
state = -1
edges = []
for x in xrange(xsize):
weight = sum(1 if pixels[x, y] == 0 else 0 for y in xrange(ysize))
level = 0
if state == -1 and weight <= level:
continue
elif state == 1 and weight > level:
continue
else:
state = -state
edges.append(x)
return [(edges[x], edges[x + 1]) for x in range(0, len(edges), 2)]
@staticmethod
def GetPixelsYEdges(im):
pixels = im.load()
xsize, ysize = im.size
state = -1
edges = []
for y in xrange(ysize):
weight = sum(1 if pixels[x, y] == 0 else 0 for x in xrange(xsize))
level = 0
if state == -1 and weight <= level:
continue
elif state == 1 and weight > level:
continue
else:
state = -state
edges.append(y)
return [(edges[x], edges[x + 1]) for x in range(0, len(edges), 2)]
@staticmethod
def StripYEdge(im):
yedges = CaptchaImageAlgorithm.GetPixelsYEdges(im)
y1, y2 = yedges[0][0], yedges[-1][1]
return im.crop((0, y1, im.size[0], y2))
@staticmethod
def GetBinaryMap(im):
xsize, ysize = im.size
pixels = im.load()
return '\n'.join(''.join('#' if pixels[x, y] == 0 else '_' for x in xrange(xsize)) for y in xrange(ysize))
@staticmethod
def getBitMapIn(im):
xsize, ysize = im.size
pixels = im.load()
return tuple( 0 if pixels[x, y] == 0 else 255 for x in xrange(xsize) for y in xrange(ysize))
class CaptchaProfile(object):
def __init__(self,features_map):
self.features_map = features_map
def __new__(cls,features_map):
'''
单态实现，初始化一次
'''
if '_inst' not in vars(cls):
cls.catagory_FEATURES_MAP__ = dict([(feature_to_data(key),value) for key,value in features_map.iteritems()])
cls._inst = super(CaptchaProfile, cls).__new__(cls)
return cls._inst
def match(self, im):
#st = time.time()
imageData = feature_to_data(CaptchaImageAlgorithm.GetBinaryMap(im))
result = self.catagory_FEATURES_MAP__.get(imageData,None)
if result != None:
return result
print CaptchaImageAlgorithm.GetBinaryMap(im),'\n'
source = im.getdata()
algorithm = CaptchaAlgorithm()
minimal = min(self.features_map, key=lambda feature:algorithm.LevenshteinDistance(source, feature_to_data(feature)))
result = self.features_map[minimal]
self.catagory_FEATURES_MAP__[imageData] = result
return result
def filter(self, im):
return im.filter(ImageFilter.EDGE_ENHANCE_MORE).convert('L').convert('1')
def splitAgorim(self, im, top,bottom):
xsize, ysize = im.size
pixels = im.load()
zeroArr = []
for x in xrange(xsize):
flag = True
for y in xrange(ysize):
if pixels[x,y] != 255:
flag = False
break
if flag or x == 0:
zeroArr.append(x)
zeroArr = [(value - index ,value) for index,value in enumerate(zeroArr)]
retd = []
for key, group in itertools.groupby(zeroArr, lambda x: x[0]):
ret = [t[1] for t in group]
retd.append((ret[0],ret[-1]))
l = len(retd)
i = 0
dd = []
while i < l - 1 :
pre = retd[i][1] + 1
next = retd[i + 1][0]
# if 2 < next - pre < 7:
# nPre = retd[i + 1][1]
# nNext = retd[i + 2][0]
# if 2 < nNext - nPre < 7:
# dd.append((pre,4,nNext,16))
# i = i + 2
# continue
# print (pre,4,next,16)
dd.append((pre,top,next,bottom))
i = i + 1
return dd
def split(self, im, top,bottom):
ddArr = self.splitAgorim(im, top, bottom)
return (im.crop(idt) for idt in ddArr[1:])
def feature_to_data(feature):
feature = re.sub(r'[\t\s]', '', feature)
feature = re.sub(r'[\r\n]', '', feature)
return tuple(0 if x == '#' else 255 for x in feature)
def captcha(filename, profile):
#s = time.time()
im = Image.open(filename)
#s2 = time.time()
#print 'open',s2-s
im = profile.filter(im)
#s3 = time.time()
#print 'filter',s3 - s2
im_list = profile.split(im)
#s4 = time.time()
#print 'split',s4 - s3
result = ''.join(profile.match(im) for im in im_list)
#print 'match',time.time() - s4
return result
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
京东价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from medicine.kxr.kxr_feature import KXR_FEATURES_MAP__
import Image
import os,sys
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_kxr(CaptchaProfile):
def __init__(self,features_map = KXR_FEATURES_MAP__):
super(CaptchaProfile_kxr,self).__init__(features_map)
def __new__(cls,features_map = KXR_FEATURES_MAP__):
return super(CaptchaProfile_kxr, cls).__new__(cls,features_map)
def getStandardArrNum():
curPath = os.path.dirname(sys.argv[0])
imStand = os.path.join(curPath,'price2.png')
im = Image.open(imStand)
#print im.size
#cia = CaptchaImageAlgorithm()
cpKxr = CaptchaProfile_kxr()
ckDict = {}
for i in xrange(10):
for j in xrange(11):
xt = 14*(j+1)
if xt > 146:
xt = 146
px = (14*j,16 + (i-1)*15,xt,15 + i*15)
seg = im.crop(px)
ckDict[(px[0],px[1] - 1)] = cpKxr.match(seg)
return ckDict
class CkDict(object):
ckDict = None
@classmethod
def getCapNum(cls,px):
if cls.ckDict is None:
cls.ckDict = getStandardArrNum()
return cls.ckDict.get(px,None)
if __name__ == '__main__':
while True:
getStandardArrNum()
#===========================================================================
# im = Image.open(r'c:\1.png')
# im2 = Image.open(r'c:\1.png')
# dt = im.getdata()
# print im.size
# it1 = im.crop((15, 3, 21, 11))
# it2 = im.crop((23, 3, 29, 11))
# it3 = im.crop((31, 3, 37, 11))
# it4 = im.crop((39, 3, 45, 11))
# it5 = im.crop((47, 3, 49, 11))
# it6 = im.crop((51, 3, 57, 11))
# it7 = im.crop((59, 3, 65, 11))
# cia = CaptchaImageAlgorithm()
# s7 = cia.GetBinaryMap(it1)
# print s7
#===========================================================================
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2012-02-29
@author: zhongfeng
'''
KXR_FEATURES_MAP__ = {
'''
______
______
______
______
______
______
______
______
______
______
______
__##__
__##__
______
'''
:
'.',
'''
____####______
___##___##____
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
___##___##____
____####______
____####______
'''
:
'0',
'''
______##______
_____###______
__######______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
__#########___
____####______
'''
:
'1',
'''
___######_____
________##____
________###___
________###___
________###___
________##____
________#_____
_______#______
______________
______________
____##________
___###________
__##########__
______####____
'''
:
'2',
'''
____######____
_________##___
_________###__
_________##___
_________##___
_________#____
______####____
_________#____
__________##__
__________##__
__________##__
_________##___
____#####_____
____#####_____
'''
:
'3',
'''
________###___
_______####___
______#####___
_____#__###___
_____#__###___
____#___###___
___#____###___
__#########___
__###########_
________###___
________###___
________###___
________###___
________#_____
'''
:
'4',
'''
__#########___
__###_________
__###_________
__###_________
__###_________
__#######_____
________##____
_________##___
_________##___
_________##___
_________##___
________##____
___#####______
_______#______
'''
:
'5',
'''
______####____
____#_________
___#__________
__##__________
__##__________
__#######_____
__##_____##___
_###_____##___
__##_____##___
__##_____##___
__##_____##___
___##___##____
_____####_____
_____####_____
'''
:
'6',
'''
__#########___
_________##___
_________##___
_________#____
________##____
_______##_____
_______#______
______##______
______#_______
_____##_______
_____#________
____##________
___##_________
___##_________
'''
:
'7',
'''
____#####_____
__##____##____
__##_____##___
__##_____##___
___#__________
____#___#_____
____#####_____
_________#____
__##_____##___
_###_____##___
_###_____##___
__##_____#____
____#####_____
_____####_____
'''
:
'8',
'''
_____####_____
____#____##___
___##_____#___
__###_____##__
__###_____##__
___##_____##__
___##_____##__
____########__
__________##__
_________##___
_________##___
________##____
___#####______
______##______
'''
:
'9',
} | Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
京东价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from medicine.kxr.kxr_feature import KXR_FEATURES_MAP__
import Image
import os,sys
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_kxr(CaptchaProfile):
def __init__(self,features_map = KXR_FEATURES_MAP__):
super(CaptchaProfile_kxr,self).__init__(features_map)
def __new__(cls,features_map = KXR_FEATURES_MAP__):
return super(CaptchaProfile_kxr, cls).__new__(cls,features_map)
def getStandardArrNum():
curPath = os.path.dirname(sys.argv[0])
imStand = os.path.join(curPath,'price2.png')
im = Image.open(imStand)
#print im.size
#cia = CaptchaImageAlgorithm()
cpKxr = CaptchaProfile_kxr()
ckDict = {}
for i in xrange(10):
for j in xrange(11):
xt = 14*(j+1)
if xt > 146:
xt = 146
px = (14*j,16 + (i-1)*15,xt,15 + i*15)
seg = im.crop(px)
ckDict[(px[0],px[1] - 1)] = cpKxr.match(seg)
return ckDict
class CkDict(object):
ckDict = None
@classmethod
def getCapNum(cls,px):
if cls.ckDict is None:
cls.ckDict = getStandardArrNum()
return cls.ckDict.get(px,None)
if __name__ == '__main__':
while True:
getStandardArrNum()
#===========================================================================
# im = Image.open(r'c:\1.png')
# im2 = Image.open(r'c:\1.png')
# dt = im.getdata()
# print im.size
# it1 = im.crop((15, 3, 21, 11))
# it2 = im.crop((23, 3, 29, 11))
# it3 = im.crop((31, 3, 37, 11))
# it4 = im.crop((39, 3, 45, 11))
# it5 = im.crop((47, 3, 49, 11))
# it6 = im.crop((51, 3, 57, 11))
# it7 = im.crop((59, 3, 65, 11))
# cia = CaptchaImageAlgorithm()
# s7 = cia.GetBinaryMap(it1)
# print s7
#===========================================================================
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2012-02-29
@author: zhongfeng
'''
KXR_FEATURES_MAP__ = {
'''
______
______
______
______
______
______
______
______
______
______
______
__##__
__##__
______
'''
:
'.',
'''
____####______
___##___##____
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
__##_____##___
___##___##____
____####______
____####______
'''
:
'0',
'''
______##______
_____###______
__######______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
______##______
__#########___
____####______
'''
:
'1',
'''
___######_____
________##____
________###___
________###___
________###___
________##____
________#_____
_______#______
______________
______________
____##________
___###________
__##########__
______####____
'''
:
'2',
'''
____######____
_________##___
_________###__
_________##___
_________##___
_________#____
______####____
_________#____
__________##__
__________##__
__________##__
_________##___
____#####_____
____#####_____
'''
:
'3',
'''
________###___
_______####___
______#####___
_____#__###___
_____#__###___
____#___###___
___#____###___
__#########___
__###########_
________###___
________###___
________###___
________###___
________#_____
'''
:
'4',
'''
__#########___
__###_________
__###_________
__###_________
__###_________
__#######_____
________##____
_________##___
_________##___
_________##___
_________##___
________##____
___#####______
_______#______
'''
:
'5',
'''
______####____
____#_________
___#__________
__##__________
__##__________
__#######_____
__##_____##___
_###_____##___
__##_____##___
__##_____##___
__##_____##___
___##___##____
_____####_____
_____####_____
'''
:
'6',
'''
__#########___
_________##___
_________##___
_________#____
________##____
_______##_____
_______#______
______##______
______#_______
_____##_______
_____#________
____##________
___##_________
___##_________
'''
:
'7',
'''
____#####_____
__##____##____
__##_____##___
__##_____##___
___#__________
____#___#_____
____#####_____
_________#____
__##_____##___
_###_____##___
_###_____##___
__##_____#____
____#####_____
_____####_____
'''
:
'8',
'''
_____####_____
____#____##___
___##_____#___
__###_____##__
__###_____##__
___##_____##__
___##_____##__
____########__
__________##__
_________##___
_________##___
________##____
___#####______
______##______
'''
:
'9',
} | Python |
#/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2006-02-11
抓取核心类，用于抓取页面；
可以支持登陆抓取等；
@author: zhongfeng
'''
from __future__ import with_statement
import urllib
import urllib2
import socket
import gzip
import zlib
import cookielib
from copy import deepcopy
from threadpool import ThreadPool,makeRequests
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from enum import Enum
#设置超时
timeout = 15
socket.setdefaulttimeout(timeout)
#默认错误
UnKnownErrCode=700
#http headers
commonHeaders = {"Accept":"*/*", "User-Agent": "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; GTB6.5)"}
CrawlerType = Enum('GET_URL', 'GET_MESSAGE', 'POST_MESSAGE')
proxiesDic = {'http':'61.152.108.19:8080'}
class UrlSummary(object):
''' URLSummary 用于表示 Url信息抓取摘要信息，包括http请求的headers设定，采用get or post方式等.'''
def __init__(self, url, data=None, headers=None,
crawlerType=CrawlerType.GET_URL,retries = 2):
assert url != None #url不能为None
self.url = url
self.headers = deepcopy(commonHeaders) if headers is None else headers
self.crawlerType = crawlerType
self.data = data
self.retries = retries
def __str__(self):
return str(vars(self))
__repr__ = __str__
class CrawlResult(object):
''' 用于保存crawl page结果，包括内容，返回的状态码等 '''
def __init__(self, url=None, code=UnKnownErrCode, content='', headers=None):
self.url = url
self.code = code
self.content = content
self.headers = headers
def __str__(self):
return str(vars(self))
__repr__ = __str__
# deflate support
def deflate(data): # zlib only provides the zlib compress format, not the deflate format;
try: # so on top of all there's this workaround:
return zlib.decompress(data, - zlib.MAX_WBITS)
except zlib.error:
return zlib.decompress(data)
class ContentEncodingProcessor(urllib2.BaseHandler):
"""A handler to add gzip capabilities to urllib2 requests """
# add headers to requests
def http_request(self, req):
req.add_header("Accept-Encoding", "gzip,deflate")
return req
# decode
def http_response(self, req, resp):
old_resp = resp
if resp.headers.get("content-encoding") == "gzip":
gz = gzip.GzipFile(fileobj=StringIO(resp.read()),
mode="r")
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
resp.msg = old_resp.msg
if resp.headers.get("content-encoding") == "deflate":
gz = StringIO(deflate(resp.read()))
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
resp.msg = old_resp.msg
return resp
class HTTPRefererProcessor(urllib2.BaseHandler):
"""A handler to add Referer capabilities to urllib2 requests """
def __init__(self):
self.referer = None
def http_request(self, req):
if not req.has_header("Referer"):
if self.referer is None:
self.referer = req.get_host()
req.add_unredirected_header("Referer", self.referer)
return req
def http_response(self, req, resp):
self.referer = resp.geturl()
return resp
class SmartRedirectHandler(urllib2.HTTPRedirectHandler):
'''用于处理 301 /302 重定向,可以记录到发生了重定向行为的code'''
def http_error_301(self, req, fp, code, msg, headers):
result = urllib2.HTTPRedirectHandler.http_error_301(self, req, fp, code, msg, headers)
#result.code = code
return result
def http_error_302(self, req, fp, code, msg, headers):
result = urllib2.HTTPRedirectHandler.http_error_302(self, req, fp, code, msg, headers)
#result.code = code
return result
class DefaultErrorHandler(urllib2.HTTPDefaultErrorHandler):
''' 用于处理301，302以外的httperror '''
def http_error_default(self, req, fp, code, msg, headers):
result = urllib2.HTTPError(req.get_full_url(), code, msg, headers, fp)
result.code = code
return result
def __buildCookieProcessor():
''' 处理cookies用于登陆使用 '''
cj = cookielib.CookieJar()
return urllib2.HTTPCookieProcessor(cj)
def getHandlers(debug = False,cookies = True,proxy = None,extraHandlers = None):
smartRediHandler = urllib2.HTTPRedirectHandler() #重定向处理
defaultErrorHandler = DefaultErrorHandler() #默认错误处理
contentEncodingProc = ContentEncodingProcessor() #gzip,deflate解码
httpRefererProc = HTTPRefererProcessor() #防盗链破解，request添加referer header
handlers = [smartRediHandler, defaultErrorHandler,
contentEncodingProc, httpRefererProc]
if proxy != None:
handlers.append(urllib2.ProxyHandler(proxy)) #设置代理
if debug:
handlers.append(urllib2.HTTPHandler(debuglevel=debug)) #urllib2的调试功能
if cookies:
handlers.append(__buildCookieProcessor()) #Cookies支持，用于登陆
if extraHandlers != None:
handlers.extend(list(extraHandlers))
return handlers
def createOpener(handlers = None):
if handlers is None:
handlers = getHandlers()
#设定handlers
opener = urllib2.build_opener(*handlers)
#urllib2.install_opener(opener)
return opener
class CrawlerHttp(object):
''' 提供抓取数据服务的facade接口类 '''
def __init__(self, urlSummary, opener=None):
self.urlSummary = urlSummary
if opener is None:
self.opener = createOpener()
else:
self.opener = opener
def __createRequest(self):
request = None
url = self.urlSummary.url
data = None
if self.urlSummary.data != None:
data = urllib.urlencode(self.urlSummary.data)
if self.urlSummary.crawlerType == CrawlerType.POST_MESSAGE:
request = urllib2.Request(url, data)
elif self.urlSummary.crawlerType == CrawlerType.GET_MESSAGE :
fullUrl = ''.join([url, '?', data])
request = urllib2.Request(fullUrl)
else:
request = urllib2.Request(url)
headers = self.urlSummary.headers
if headers:
for k, v in headers.items():
request.add_header(k, v)
return request
def __getResponseStreamData(self,resp):
dataArr = []
try:
if resp != None:
while True:
data = resp.read(102400)#onetimesize 100k
if not data:
break
dataArr.append(data)
except IOError, e:
raise e
return ''.join(dataArr)
def fetch(self, isGetData = True, islogin = False, retries=0):
'''Fetch data and metadata from a URL, file, stream, or string'''
result = CrawlResult()
resp = None
try:
req = self.__createRequest()
resp = self.opener.open(req)
if isGetData: #如果为false，则不读取，仅获得response的headers等信息
result.content = self.__getResponseStreamData(resp)
except IOError, e:
print 'Couldn\'t fulfill the request.Error code:%s, Reason: %s,URL: %s' % \
(getattr(e,'code',UnKnownErrCode),getattr(e,'reason','Unknown Error'), req.get_full_url())
finally:
if resp != None:
result.headers = getattr(resp, 'headers', None)
result.url = getattr(resp, 'url', '')
result.code = getattr(resp, 'code', UnKnownErrCode)
if islogin:
result.loginResponse = resp #登陆操作时，response不能关闭，待后续操作完成后关闭
else:
resp.close()
if result.code >= 400 and retries != 0:
print 'sleep 3 seconds.try again'
self.fetch(isGetData,islogin,retries - 1)
return result
def crawle(urlSum, debug = False,proxy = None):
handlers = getHandlers(debug = debug,proxy = proxy)
opener = createOpener(handlers)
return crawleDepOpener(urlSum,opener)
def crawleRetries(urlSum, retry = 3, debug = False,proxy = None):
for i in xrange(retry):
result = crawle(urlSum, debug, proxy)
if result.code < 500 :
break
return result
def crawleDepOpener(urlSum,opener,reservelogin = False):
if not isinstance(urlSum, UrlSummary):
urlSum = UrlSummary(urlSum)# May Be Url String
crawler = CrawlerHttp(urlSum,opener)
crawlResult = crawler.fetch(islogin = reservelogin)
return crawlResult
def login(urlSum,debug = False,proxy = None):
handlers = getHandlers(debug = debug,proxy = proxy,cookies = True)
opener = createOpener(handlers)
loginResult = crawleDepOpener(urlSum,opener,reservelogin = True)
return (opener,loginResult)
def logout(loginResult):
return loginResult.loginResponse.close()
def crawleOnLogin(loginUrlSum,desUrlSum,debug = False,proxy = None):
opener,loginResult = login(loginUrlSum,debug,proxy)
try:
if loginResult.code == 200:
result = crawleDepOpener(desUrlSum,opener)
finally:
logout(loginResult)
pass
return result
class MutiDownloader(object):
''' multi-thread downloading tool '''
def __init__(self, threadNum = 1):
self.threadNum = threadNum
self.dataAll = [ t for t in range(threadNum)]
def _getResourceFileSize(self,urlSummary):
crawler = CrawlerHttp(urlSummary)
result = crawler.fetch(isGetData = False)
contentLen = None
if result.code == 200:
contentLen = result.headers.get('Content-Length')
return int(contentLen) if contentLen else -1
@staticmethod
def splitBlocks(totalsize, blockNum):
blocksize = totalsize/blockNum
ranges = []
for i in range(0, blockNum - 1):
ranges.append((i*blocksize, i*blocksize +blocksize - 1))
ranges.append(( blocksize*(blockNum - 1), totalsize -1 ))
return ranges
@staticmethod
def downloadPart(urlSum,partNum):
return crawle(urlSum,debug = True)
def save_result(self,request, result):
partNum = request.args[1]
self.dataAll[partNum] = result.content
# this will be called when an exception occurs within a thread
@staticmethod
def handle_exception(request, exc_info):
if not isinstance(exc_info, tuple):
# Something is seriously wrong...
print request
print exc_info
raise SystemExit
print "**** Exception occured in request #%s: %s" % \
(request.requestID, exc_info)
def download(self,urlSummary):
totalSize = self._getResourceFileSize(urlSummary)
ranges = MutiDownloader.splitBlocks(totalSize,self.threadNum)
urlSums = [deepcopy(urlSummary).headers.__setitem__('Range','bytes={}-{}'.format(*ranges[i]))
for i in range(self.threadNum)]
urlRequests = [([k,v],{})for k,v in enumerate(urlSums)]
requests = makeRequests(MutiDownloader.downloadPart, urlRequests,
self.save_result, MutiDownloader.handle_exception)
pool = ThreadPool(self.threadNum)
for request in requests:
pool.putRequest(request)
pool.wait()
#return ''.join(self.dataAll)
def __detectChardet(crawlResult):
import chardet
if crawlResult.code == 200:
print 'Page %s :Content code is %s' % (crawlResult.url, chardet.detect(crawlResult.content))
def getContentFromUrlSum(urlsum):
while True:
result = crawle(urlsum)
if result.code == 200:
break
content = result.content
return content
if __name__ == '__main__':
#===========================================================================
# bookKey = {'url':'search-alias=stripbooks', 'field-keywords':'Java(TM) and JMX: Building Manageable Systems'}
# firstSearchUrl = UrlSummary(url='http://www.amazon.com/s/ref=nb_sb_noss', data=bookKey, crawlerType=CrawlerType.GET_MESSAGE)
# bookSearchPageResult = crawle(firstSearchUrl)
# print bookSearchPageResult.content
# regx = r'(http://www.amazon.com/[-a-zA-Z]*/[a-z]*/[0-9]*)/ref=sr_1_1'
#
# f = file(r'c:/ff.html', 'w')
# f.write(bookSearchPageResult.content)
# f.close()
# amazonUrl = 'http://www.amazon.com/Head-First-Servlets-JSP-Certified/dp/0596516681'
# import chardet
# DEBUG = 1
#===========================================================================
urlSummary = UrlSummary(url="http://www.efeihu.com/")
while True:
result = crawle(urlSummary)
if result.code == 200:
break
print result.content
with open(r'c:efeihu.html', 'w') as outputFile:
outputFile.write(result.content)
#downloader = MutiDownloader()
#downloader.download(urlSummary)
#===========================================================================
# newSmthLoginData = {'id':'dao123mao', 'passwd':'902910','x':'38','y':'1'}
# newsmthUrlSum = UrlSummary(url='http://www.newsmth.net/bbslogin2.php', data=newSmthLoginData, crawlerType=CrawlerType.POST_MESSAGE)
# #opener = login(newsmthUrlSum,debug = True)
# desUrlSum = UrlSummary('http://www.newsmth.net/bbsmailbox.php?path=.DIR&title=%CA%D5%BC%FE%CF%E4')
# result = crawleOnLogin(newsmthUrlSum,desUrlSum,debug = True)
# print result.code, result.content
# with open(r'c:tt1.html', 'w') as outputFile:
# outputFile.write(result.content)
# import re
# regx = r'<span class="tag"><a href="(/tag/.*\?ref_=tag_dpp_cust_itdp_t)" title="([0-9]*) customers tagged this product'
# p = re.compile(regx)
# for t in p.finditer(result.content):
# print t.group(1),t.group(2)
# import os
# print os.sys.path
# bookKey = {'key':u'Java编程思想','catalog':'01'}
# bookKey['key'] = bookKey['key'].encode('gb2312')
# print bookKey['key']
# firstSearchUrl = UrlSummary(url='http://search.dangdang.com/book/search_pub.php',data=bookKey,crawlerType = CrawlerType.GET_MESSAGE)
# bookSearchPageResult = crawle(firstSearchUrl)
# from extract.pageparser import DangDangSearchPageParser ,BookDetailParser
# t = DangDangSearchPageParser(bookSearchPageResult.content)
# urlSummary = t.parserResult()
#
#===========================================================================
#bookDetailPageResult = crawle(urlSummary)
#import chardet
#print chardet.detect(bookDetailPageResult.content)
#bookDetailParser = BookDetailParser(bookDetailPageResult.content)
#bookDetail = bookDetailParser.parserResult()
#from persistence.dbsaver import insertBookDetail
#print insertBookDetail(bookDetail)
#print chardet.detect(bookDetail.contentAbs)
#print bookDetail.contentAbs.decode('GB2312')
#f = file(r'c:/ff.html','w')
#f.write(bookDetailPageResult.content)
#f.close()
| Python |
#/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2011-10-18
@author: zhongfeng
'''
from crawlerhttp import crawle
from logfacade import LoggerFactory
from urlparse import urlparse
import os,sys
import time
from multiprocessing import Pool,Queue
logger = LoggerFactory.getLogger()
def __procSubUrlRequests(parser,result,q):
'''SubUrl 入队'''
parserResult = parser.parserSubUrlSums()
if parserResult is not None:
#for subUrlSum in parserResult:
# logger.debug( 'SubUrlSum put Q: %s ,level: %s' \
# % (subUrlSum.url,subUrlSum.catagoryLevel))
# _putSpideRequest(subUrlSum,q)
return parserResult
def __procPageInfos(parser,urlsum):
'''解析页面的详细信息，例如product信息'''
resultList = parser.parserPageInfos()
if resultList is not None:
siteName = urlparse(urlsum.url).hostname.split('.')[1]
logger = LoggerFactory.getLogger(logName=siteName)
for parserResult in resultList:
if logger.isEnabledFor('INFO'):
logger.info(parserResult.logstr())
def proc_normal_result(urlsum, result, mSpider):
#if result.content == '':
# __reinqueue_proc(urlsum, result, mSpider.q)
# return
if result.code == 200:
#print "**** Result from request #%s: %d" % (urlsum.url, result.code)
ParserClass = mSpider.parserDict.get(urlsum.catagoryLevel,None)
if ParserClass is None:
return
parser = ParserClass(result.content,urlsum,urlsum.include,
urlsum.exclude)
try:
if urlsum.isRecursed:
subUrlSums = __procSubUrlRequests(parser,result,mSpider.q)
if mSpider.procDetails:
__procPageInfos(parser,urlsum)
#parentLevel1 = urlsum.parentPath[1]
#__writeStat(spider.stat,parentLevel1,retSize)
return subUrlSums
except Exception,e:
logger.error('ParserException.Reason:%s,URL:%s'% (e,urlsum.url))
else:
logger.error('Get From URL:%s Error code:' % (urlsum.url,result.code))
def main_spide(mSpider):
q = mSpider.q
while True:
try:
urlsum = q.get(timeout=30)
except Exception:
break
logger.info( "Q Size: %d|URL: %s" % (q.qsize(),urlsum.url))
result = crawle(urlsum)
subUrlSums = proc_normal_result(urlsum, result, mSpider)
for urlsum in subUrlSums:
q.put(urlsum)
class ObuySpider(object):
def __init__(self,rootUrlSummary = None,parserDict =None,threadNum = 5,
procDetails = True,include = None,exclude = None,rootPageResult = None):
self.rootUrlSummary = rootUrlSummary
self.parserDict = parserDict
self.procDetails = procDetails #是否解析页面的详细信息
self.rootUrlSummary.include = include
self.rootUrlSummary.exclude = exclude
self.pool = Pool(threadNum)
self.stat = dict()
self.rootPageResult = rootPageResult
self.q = Queue()
def spide(self):
self.q.put(self.rootUrlSummary)
self.pool.apply_async(main_spide,(self,))
self.pool.join()
self.__printStatResult()
def __printStatResult(self):
for k,v in self.stat.iteritems():
print 'Catagory:%s,Num:%d' % (k.name,v)
if __name__ == '__main__':
logger = LoggerFactory.getLogger()
| Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2011-8-27
主要用于从网站上爬取信息后，抽取页面信息；
@author: zhongfeng
'''
from pageparser import *
from spiderconfigparser import SpiderConfig
from crawlerhttp import crawleRetries
icsonRoot = ObuyUrlSummary(url=r'http://www.icson.com/portal.html', name='icson',
isRecursed=True, catagoryLevel=0)
class IcsonAllSortParser(RootCatagoryPageParser):
'''
从http://sz.icson.com/portal.html获取所有的分类信息，
组合成ObuyUrlSummary
'''
mainHost = 'http://sz.icson.com/'
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonAllSortParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def getBaseSort3UrlSums(self):
finalUrlList = []
allSort = self.soup.find(attrs={'id':'protal_list'})
for t in allSort.findAll(name='div',attrs={'class':'item_hd'}):#一级分类
name,url = ParserUtils.parserTag_A(t.find(name='a'))
sort_1_urlsum = self.buildSort_N(url, name, self.rootUrlSummary, isCrawle=False)
sort_2 = t.findNextSibling(name='div',attrs={'class':'item_bd'})
for tt in sort_2(name='dl'):#二级分类
name = tt.dt.getText()
url = ''.join((self.mainHost,name))
sort_2_urlsum = self.buildSort_N(url, name, sort_1_urlsum, isCrawle=False)
for ttt in tt.findAll(name='a'):#三级分类
name, url = ParserUtils.parserTag_A(ttt)
sort_3_urlsum = self.buildSort_N(url, name, sort_2_urlsum,firstFinalPage=True)
finalUrlList.append(sort_3_urlsum)
return finalUrlList
class IcsonSort3PageParser(Sort3PageParser):
'''
三级页面解析类
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonSort3PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def nextPageUrlPattern(self):
urlSegs = self.rootUrlSummary.url.rsplit('.', 1)
pageSeg = '-0-6-10-20-0-{}--'
return '%s%s.%s' % (urlSegs[0].replace('--------',''), pageSeg, urlSegs[1])
def getTotal(self):
nextSeg = self.soup.find(name='a',attrs={'class':'page-next'})
if nextSeg != None:
t = nextSeg.findPreviousSibling(name='a').getText()
totalPage = int(t)
else:
totalPage = 1
if totalPage > SpiderConfig.getMaxPage():
totalPage = SpiderConfig.getMaxPage()
return totalPage
def parserPageInfos(self):
plist = self.soup.findAll(name='li',attrs={'class':'item_list'})
resultList = []
for prod in plist:
pNameSeg = prod.find(attrs={'class':'wrap_info'})
pName,url = ParserUtils.parserTag_A(pNameSeg.a)
hotWords = pNameSeg.find(name='p',attrs={'class':'hot'}).getText()
adWords = hotWords
#===================================================================
# exGiftSeg = prod.find(name='ul',attrs = {'class':'list_gifts'})
# if exGiftSeg:
# allGift = []
# for index ,gift in enumerate(exGiftSeg(name = 'li')):
# eGift = '%s.%s' % (index ,gift.getText())
# allGift.append(eGift)
# adWords = '%s@%s' % (hotWords,''.join(allGift))
# print adWords
#===================================================================
pid = url.rsplit('-',1)[-1].split('.')[0]
t = prod.find(attrs={'class':'price_icson'})
if t != None:
currentPrice = ParserUtils.getPrice(t.getText())
else:
currentPrice = 0.00
commSeg = prod.find(name = 'p',attrs={'class':'comment'})
repu = 0.0
evalNum = 0
if commSeg:
repuSeg = commSeg.find(name = 'span',attrs = {'class':'icon_star'})
if repuSeg:
repu = ParserUtils.getDigit(repuSeg.b['style'])
repu = float(repu) * 5 / 100
evalNum = ParserUtils.getDigit(commSeg.a.getText())
imgSeg = prod.find(name='a',attrs={'class':'link_pic'})
imgUrl = ParserUtils.getImgUrl(imgSeg)
#evlNum = ParserUtils.getDigit(prod.find(name='p',attrs={'class':'comment'}).getText())
prodDetail = ProductDetails(productId=pid, fullUrl=url,imageUrl=imgUrl,privPrice = currentPrice,
name=pName, adWords=adWords,reputation=repu,evaluateNum=evalNum)
prodDetail.catagory = self.rootUrlSummary
resultList.append(prodDetail)
return resultList
class IcsonSort4PageParser(IcsonSort3PageParser):
'''
分类四级页面为列表页面，只抽取Product信息
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonSort4PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def parserSubUrlSums(self):
pass
parserDict = {0:IcsonAllSortParser, 3:IcsonSort3PageParser, 4:IcsonSort4PageParser}
''' test '''
import os
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir,'test_resources')
def testIcsonAllSortPage():
fileName = os.path.join(testFilePath,'portal.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
rootUrlSum = ObuyUrlSummary(url=r'http://sz.icson.com/portal.html', name='Icson')
firstPage = IcsonAllSortParser(content, rootUrlSum)
for sort_3 in firstPage.parserSubUrlSums():
print sort_3.name,sort_3.url ,sort_3.catagoryLevel
def testSort3Page():
fileName = os.path.join(testFilePath,'icson_2011-08-27_14-13-21.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://list.icson.com/311--------.html',
parentPath=[('test')], catagoryLevel=3)
sort3Page = IcsonSort3PageParser(content, sort_3_urlsum)
for sort_4 in sort3Page.getSort4PageUrlSums():
print sort_4.url
def testSort3Details():
fileName = os.path.join(testFilePath,'icson_2011-08-27_14-13-21.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://list.icson.com/311--------.html',
parentPath=[('test')], catagoryLevel=3)
result = crawleRetries(sort_3_urlsum)
fileName = os.path.join(testFilePath,'icson_test.html')
with open(fileName, 'w') as fInput:
fInput.write(result.content)
sort3Page = IcsonSort3PageParser(result.content, sort_3_urlsum)
for product in sort3Page.parserPageInfos():
print product.logstr()
if __name__ == '__main__':
#testIcsonAllSortPage()
#testSort3Page()
testSort3Details()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-25
@author: zhongfeng
'''
from icson.icsonpageparser import parserDict,icsonRoot
from spider import ObuySpider
from crawlerhttp import CrawlResult
import os,sys
from logfacade import LoggerFactory
from upload import fileUpload
from spiderconfigparser import SpiderConfig
def main(fileName):
with open(fileName, 'r') as fInput:
content = fInput.read()
rootResult = CrawlResult(code=200, content=content)
from spiderconfigparser import getIncludeUrlSums,getExcludeUrlSums
includes = getIncludeUrlSums()
excludes = getExcludeUrlSums()
spider = ObuySpider(rootUrlSummary=icsonRoot, parserDict=parserDict,include=includes,exclude = excludes,
rootPageResult=rootResult, threadNum=SpiderConfig.getThreadNum())
if SpiderConfig.isStartSpider():
spider.spide()
LoggerFactory.shutdown()
if SpiderConfig.isUpload():
fileUpload()
if __name__ == '__main__':
curPath = os.path.abspath(os.path.dirname(sys.argv[0]))
fileName = os.path.join(curPath, 'portal.html')
main(fileName)
| Python |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2011-8-27
主要用于从网站上爬取信息后，抽取页面信息；
@author: zhongfeng
'''
from pageparser import *
from spiderconfigparser import SpiderConfig
from crawlerhttp import crawleRetries
icsonRoot = ObuyUrlSummary(url=r'http://www.icson.com/portal.html', name='icson',
isRecursed=True, catagoryLevel=0)
class IcsonAllSortParser(RootCatagoryPageParser):
'''
从http://sz.icson.com/portal.html获取所有的分类信息，
组合成ObuyUrlSummary
'''
mainHost = 'http://sz.icson.com/'
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonAllSortParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def getBaseSort3UrlSums(self):
finalUrlList = []
allSort = self.soup.find(attrs={'id':'protal_list'})
for t in allSort.findAll(name='div',attrs={'class':'item_hd'}):#一级分类
name,url = ParserUtils.parserTag_A(t.find(name='a'))
sort_1_urlsum = self.buildSort_N(url, name, self.rootUrlSummary, isCrawle=False)
sort_2 = t.findNextSibling(name='div',attrs={'class':'item_bd'})
for tt in sort_2(name='dl'):#二级分类
name = tt.dt.getText()
url = ''.join((self.mainHost,name))
sort_2_urlsum = self.buildSort_N(url, name, sort_1_urlsum, isCrawle=False)
for ttt in tt.findAll(name='a'):#三级分类
name, url = ParserUtils.parserTag_A(ttt)
sort_3_urlsum = self.buildSort_N(url, name, sort_2_urlsum,firstFinalPage=True)
finalUrlList.append(sort_3_urlsum)
return finalUrlList
class IcsonSort3PageParser(Sort3PageParser):
'''
三级页面解析类
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonSort3PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def nextPageUrlPattern(self):
urlSegs = self.rootUrlSummary.url.rsplit('.', 1)
pageSeg = '-0-6-10-20-0-{}--'
return '%s%s.%s' % (urlSegs[0].replace('--------',''), pageSeg, urlSegs[1])
def getTotal(self):
nextSeg = self.soup.find(name='a',attrs={'class':'page-next'})
if nextSeg != None:
t = nextSeg.findPreviousSibling(name='a').getText()
totalPage = int(t)
else:
totalPage = 1
if totalPage > SpiderConfig.getMaxPage():
totalPage = SpiderConfig.getMaxPage()
return totalPage
def parserPageInfos(self):
plist = self.soup.findAll(name='li',attrs={'class':'item_list'})
resultList = []
for prod in plist:
pNameSeg = prod.find(attrs={'class':'wrap_info'})
pName,url = ParserUtils.parserTag_A(pNameSeg.a)
hotWords = pNameSeg.find(name='p',attrs={'class':'hot'}).getText()
adWords = hotWords
#===================================================================
# exGiftSeg = prod.find(name='ul',attrs = {'class':'list_gifts'})
# if exGiftSeg:
# allGift = []
# for index ,gift in enumerate(exGiftSeg(name = 'li')):
# eGift = '%s.%s' % (index ,gift.getText())
# allGift.append(eGift)
# adWords = '%s@%s' % (hotWords,''.join(allGift))
# print adWords
#===================================================================
pid = url.rsplit('-',1)[-1].split('.')[0]
t = prod.find(attrs={'class':'price_icson'})
if t != None:
currentPrice = ParserUtils.getPrice(t.getText())
else:
currentPrice = 0.00
commSeg = prod.find(name = 'p',attrs={'class':'comment'})
repu = 0.0
evalNum = 0
if commSeg:
repuSeg = commSeg.find(name = 'span',attrs = {'class':'icon_star'})
if repuSeg:
repu = ParserUtils.getDigit(repuSeg.b['style'])
repu = float(repu) * 5 / 100
evalNum = ParserUtils.getDigit(commSeg.a.getText())
imgSeg = prod.find(name='a',attrs={'class':'link_pic'})
imgUrl = ParserUtils.getImgUrl(imgSeg)
#evlNum = ParserUtils.getDigit(prod.find(name='p',attrs={'class':'comment'}).getText())
prodDetail = ProductDetails(productId=pid, fullUrl=url,imageUrl=imgUrl,privPrice = currentPrice,
name=pName, adWords=adWords,reputation=repu,evaluateNum=evalNum)
prodDetail.catagory = self.rootUrlSummary
resultList.append(prodDetail)
return resultList
class IcsonSort4PageParser(IcsonSort3PageParser):
'''
分类四级页面为列表页面，只抽取Product信息
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(IcsonSort4PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def parserSubUrlSums(self):
pass
parserDict = {0:IcsonAllSortParser, 3:IcsonSort3PageParser, 4:IcsonSort4PageParser}
''' test '''
import os
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir,'test_resources')
def testIcsonAllSortPage():
fileName = os.path.join(testFilePath,'portal.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
rootUrlSum = ObuyUrlSummary(url=r'http://sz.icson.com/portal.html', name='Icson')
firstPage = IcsonAllSortParser(content, rootUrlSum)
for sort_3 in firstPage.parserSubUrlSums():
print sort_3.name,sort_3.url ,sort_3.catagoryLevel
def testSort3Page():
fileName = os.path.join(testFilePath,'icson_2011-08-27_14-13-21.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://list.icson.com/311--------.html',
parentPath=[('test')], catagoryLevel=3)
sort3Page = IcsonSort3PageParser(content, sort_3_urlsum)
for sort_4 in sort3Page.getSort4PageUrlSums():
print sort_4.url
def testSort3Details():
fileName = os.path.join(testFilePath,'icson_2011-08-27_14-13-21.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://list.icson.com/311--------.html',
parentPath=[('test')], catagoryLevel=3)
result = crawleRetries(sort_3_urlsum)
fileName = os.path.join(testFilePath,'icson_test.html')
with open(fileName, 'w') as fInput:
fInput.write(result.content)
sort3Page = IcsonSort3PageParser(result.content, sort_3_urlsum)
for product in sort3Page.parserPageInfos():
print product.logstr()
if __name__ == '__main__':
#testIcsonAllSortPage()
#testSort3Page()
testSort3Details()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-25
@author: zhongfeng
'''
from icson.icsonpageparser import parserDict,icsonRoot
from spider import ObuySpider
from crawlerhttp import CrawlResult
import os,sys
from logfacade import LoggerFactory
from upload import fileUpload
from spiderconfigparser import SpiderConfig
def main(fileName):
with open(fileName, 'r') as fInput:
content = fInput.read()
rootResult = CrawlResult(code=200, content=content)
from spiderconfigparser import getIncludeUrlSums,getExcludeUrlSums
includes = getIncludeUrlSums()
excludes = getExcludeUrlSums()
spider = ObuySpider(rootUrlSummary=icsonRoot, parserDict=parserDict,include=includes,exclude = excludes,
rootPageResult=rootResult, threadNum=SpiderConfig.getThreadNum())
if SpiderConfig.isStartSpider():
spider.spide()
LoggerFactory.shutdown()
if SpiderConfig.isUpload():
fileUpload()
if __name__ == '__main__':
curPath = os.path.abspath(os.path.dirname(sys.argv[0]))
fileName = os.path.join(curPath, 'portal.html')
main(fileName)
| Python |
#/usr/bin/env python
# -*- coding: utf-8 -*-
import re
import time
import random
from BeautifulSoup import BeautifulSoup
from crawlerhttp import UrlSummary, crawle
urlsProxy = ["http://proxy.ipcn.org/proxylist.html"]
#urlsProxy = ["http://www.proxycn.com/html_proxy/http-1.html"]
desSite = 'http://www.360buy.com'
class ChoiceProxy(object):
proxyList = []
def __init__(self):
pass
def __new__(cls):
if '_inst' not in vars(cls):
cls.__initProxyList()
cls._inst = super(ChoiceProxy, cls).__new__(cls)
return cls._inst
@classmethod
def __initProxyList(cls):
ipcnProxyPageResult = crawle(urlsProxy[0])
if ipcnProxyPageResult.code == 200:
#soup = BeautifulSoup(ipcnProxyPageResult.content)
#proxyContents = soup.find('pre').contents[0]
p = re.compile(r'(\d+\.\d+\.\d+\.\d+:[0-9]+)')
for proxyIp in p.findall(ipcnProxyPageResult.content):
if(cls.__testProxy(proxyIp)):
print proxyIp
cls.proxyList.append(proxyIp)
@classmethod
def __testProxy(cls, proxy):
proxyDicts = {'http':proxy}
start = time.time()
result = crawle(desSite, proxy = proxyDicts)
end = time.time()
estime = end - start
print proxy, estime
if result.code != 200 or estime > 10:
return False
return True
@staticmethod
def choice():
if len(ChoiceProxy.proxyList) == 0:
return None
return random.choice(ChoiceProxy.proxyList)
def choiceHttpProxy():
return {'http':ChoiceProxy.choice()}
if __name__ == '__main__':
for i in range(10):
print ChoiceProxy().choice()
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-16
@author: zhongfeng
'''
SUNING_FEATURES_MAP = {
'''
__
__
__
__
__
__
__
__
__
__
__
##
##
'''
:
'.',
'''
_######_
########
########
###__###
###__###
##____##
##____##
##____##
###__###
###__###
########
########
_######_ '''
:
'0',
'''
___##
__###
#####
#####
##_##
___##
___##
___##
___##
___##
___##
___##
___##
'''
:
'1',
'''
_######_
########
########
###__###
_____###
_____###
____####
___####_
__####__
_####___
####____
########
########
'''
:
'2',
'''
_#####__
#######_
###_###_
_____##_
____###_
___####_
___#####
_____###
_____###
###__###
########
########
_######_
'''
:
'3',
'''
____###__
____###__
___####__
__#####__
__#####__
_###_##__
####_##__
###__##__
#########
#########
_____##__
_____##__
_____##__
'''
:
'4',
'''
#######_
#######_
###_____
###_____
#######_
########
###_####
_____###
______##
###__###
########
########
_######_
'''
:
'5',
'''
_######_
_#######
########
###_____
###_____
#######_
########
########
###__###
###__###
########
########
_######_
'''
:
'6',
'''
########
########
_____###
____###_
____###_
___###__
___###__
___###__
__###___
__###___
__###___
__###___
__###___
'''
:
'7',
'''
_######_
########
########
##____##
###__###
########
########
########
###__###
##___###
########
########
_######_
'''
:
'8',
'''
_######_
########
########
###__###
###__###
########
########
_#######
_____###
_____###
###_####
#######_
_######_
'''
:
'9',
} | Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
国美价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from suning.suning_feature import SUNING_FEATURES_MAP
import Image
import itertools
import re
import time
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_suning(CaptchaProfile):
def __init__(self,features_map = SUNING_FEATURES_MAP):
super(CaptchaProfile_suning,self).__init__(features_map)
def __new__(cls,features_map = SUNING_FEATURES_MAP):
return super(CaptchaProfile_suning, cls).__new__(cls,features_map)
def filter(self,im_raw):
pixdata_raw = im_raw.load()
imge_size = im_raw.size
im = Image.new('1',imge_size)
xsize,ysize = imge_size
pixdata = im.load()
for x in xrange(xsize):
for y in xrange(ysize):
if pixdata_raw[x,y] == (255,255,255,255):
pixdata[x,y] = 255
else:
pixdata[x,y] = 0
return im
def split(self, im,top = 3,bottom = 16):
ddArr = self.splitAgorim(im, top, bottom)
return (im.crop(idt) for idt in ddArr)
def captcha_suning(filename):
return captcha(filename, CaptchaProfile_suning())
import os
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir, 'test_resources')
if __name__ == '__main__':
fileName = os.path.join(testFilePath, "789.png")
im_raw = Image.open(fileName)
pixdata_raw = im_raw.load()
#r,g,b,a = im.split()
im = im_raw.filter(ImageFilter.EDGE_ENHANCE_MORE).convert('L').convert('1')
im = Image.new('1',im_raw.size)
xsize,ysize = im.size
pixdata = im.load()
for x in xrange(xsize):
for y in xrange(ysize):
if pixdata_raw[x,y] == (255,255,255,255):
pixdata[x,y] = 255
else:
pixdata[x,y] = 0
print CaptchaImageAlgorithm.GetBinaryMap(im)
print captcha_suning(fileName)
# it1 = im.crop((3, 4, 13, 16))
# print cia.GetBinaryMap(it1),'\n'
# it2 = im.crop((15,4,24,16))
# print cia.GetBinaryMap(it2)
# print '+++++++++'
# it2 = im.crop((25, 4, 34, 16))
# it3 = im.crop ((36,4,45,16))
# #it3 = im.crop((35, 4, 37, 16))
# it4 = im.crop((38, 4, 47, 16))
# it5 = im.crop((48, 4, 57, 16))
# #it6 = im.crop((51, 3, 57, 11))
# #it7 = im.crop((59, 3, 65, 11))
# multilist = [[0 for col in range(5)] for row in range(3)]
# print '\n'.join(( str(t) for t in multilist))
#profile = CaptchaProfile_360Buy()
#print captcha_360buy(r'c:\6.png')
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-7-26
国美价格图片识别模块
@author: zhongfeng
'''
import ImageFilter, ImageChops
from captcha_price import *
from suning.suning_feature import SUNING_FEATURES_MAP
import Image
import itertools
import re
import time
try:
import psyco
psyco.full()
except ImportError:
pass
class CaptchaProfile_suning(CaptchaProfile):
def __init__(self,features_map = SUNING_FEATURES_MAP):
super(CaptchaProfile_suning,self).__init__(features_map)
def __new__(cls,features_map = SUNING_FEATURES_MAP):
return super(CaptchaProfile_suning, cls).__new__(cls,features_map)
def filter(self,im_raw):
pixdata_raw = im_raw.load()
imge_size = im_raw.size
im = Image.new('1',imge_size)
xsize,ysize = imge_size
pixdata = im.load()
for x in xrange(xsize):
for y in xrange(ysize):
if pixdata_raw[x,y] == (255,255,255,255):
pixdata[x,y] = 255
else:
pixdata[x,y] = 0
return im
def split(self, im,top = 3,bottom = 16):
ddArr = self.splitAgorim(im, top, bottom)
return (im.crop(idt) for idt in ddArr)
def captcha_suning(filename):
return captcha(filename, CaptchaProfile_suning())
import os
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir, 'test_resources')
if __name__ == '__main__':
fileName = os.path.join(testFilePath, "789.png")
im_raw = Image.open(fileName)
pixdata_raw = im_raw.load()
#r,g,b,a = im.split()
im = im_raw.filter(ImageFilter.EDGE_ENHANCE_MORE).convert('L').convert('1')
im = Image.new('1',im_raw.size)
xsize,ysize = im.size
pixdata = im.load()
for x in xrange(xsize):
for y in xrange(ysize):
if pixdata_raw[x,y] == (255,255,255,255):
pixdata[x,y] = 255
else:
pixdata[x,y] = 0
print CaptchaImageAlgorithm.GetBinaryMap(im)
print captcha_suning(fileName)
# it1 = im.crop((3, 4, 13, 16))
# print cia.GetBinaryMap(it1),'\n'
# it2 = im.crop((15,4,24,16))
# print cia.GetBinaryMap(it2)
# print '+++++++++'
# it2 = im.crop((25, 4, 34, 16))
# it3 = im.crop ((36,4,45,16))
# #it3 = im.crop((35, 4, 37, 16))
# it4 = im.crop((38, 4, 47, 16))
# it5 = im.crop((48, 4, 57, 16))
# #it6 = im.crop((51, 3, 57, 11))
# #it7 = im.crop((59, 3, 65, 11))
# multilist = [[0 for col in range(5)] for row in range(3)]
# print '\n'.join(( str(t) for t in multilist))
#profile = CaptchaProfile_360Buy()
#print captcha_360buy(r'c:\6.png')
| Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-16
@author: zhongfeng
'''
SUNING_FEATURES_MAP = {
'''
__
__
__
__
__
__
__
__
__
__
__
##
##
'''
:
'.',
'''
_######_
########
########
###__###
###__###
##____##
##____##
##____##
###__###
###__###
########
########
_######_ '''
:
'0',
'''
___##
__###
#####
#####
##_##
___##
___##
___##
___##
___##
___##
___##
___##
'''
:
'1',
'''
_######_
########
########
###__###
_____###
_____###
____####
___####_
__####__
_####___
####____
########
########
'''
:
'2',
'''
_#####__
#######_
###_###_
_____##_
____###_
___####_
___#####
_____###
_____###
###__###
########
########
_######_
'''
:
'3',
'''
____###__
____###__
___####__
__#####__
__#####__
_###_##__
####_##__
###__##__
#########
#########
_____##__
_____##__
_____##__
'''
:
'4',
'''
#######_
#######_
###_____
###_____
#######_
########
###_####
_____###
______##
###__###
########
########
_######_
'''
:
'5',
'''
_######_
_#######
########
###_____
###_____
#######_
########
########
###__###
###__###
########
########
_######_
'''
:
'6',
'''
########
########
_____###
____###_
____###_
___###__
___###__
___###__
__###___
__###___
__###___
__###___
__###___
'''
:
'7',
'''
_######_
########
########
##____##
###__###
########
########
########
###__###
##___###
########
########
_######_
'''
:
'8',
'''
_######_
########
########
###__###
###__###
########
########
_#######
_____###
_____###
###_####
#######_
_######_
'''
:
'9',
} | Python |
#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 2011-8-2
@author: zhongfeng
'''
from suning.suningparser import parserDict,sunningRoot
from spider import main
if __name__ == '__main__':
main(sunningRoot,parserDict) | Python |
#/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Created on 2011-8-25
主要用于从网站上爬取信息后，抽取页面信息；
@author: zhongfeng
'''
from pageparser import *
from spiderconfigparser import SpiderConfig
from threadpool import ThreadPool
from suning.image_price import captcha_suning
sunningRoot = ObuyUrlSummary(url=ur'http://www.suning.com', name='suning')
mainHost = r'http://www.suning.com'
class SuningAllSortParser(RootCatagoryPageParser):
'''
从http://www.suning.com/获取所有的分类信息，
组合成ObuyUrlSummary
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(SuningAllSortParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def getBaseSort3UrlSums(self):
finalUrlList = []
allSort = self.soup.find(attrs = {'id':'allsortlist'})
for t in allSort.findAll(name = 'h3'):#一级
name,url = ParserUtils.parserTag_A(t.a)
if not url.startswith('http'):
url = ''.join((mainHost,url))
sort_1_urlsum = self.buildSort_N(url, name, self.rootUrlSummary, isCrawle=False)
sort_2 = t.findNextSibling(name='div')
for tt in sort_2(name='dl'):#二级分类
name,url = ParserUtils.parserTag_A(tt.dt.a)
if not url.startswith('http'):
url = ''.join((mainHost,name))
sort_2_urlsum = self.buildSort_N(url, name, sort_1_urlsum, isCrawle=False)
for ttt in tt.dd.findAll(name = 'a'):#三级分类
name, url = ParserUtils.parserTag_A(ttt)
if not url.startswith('http'):
url = ''.join((mainHost,url))
sort_3_urlsum = self.buildSort_N(url, name, sort_2_urlsum,firstFinalPage=True)
finalUrlList.append(sort_3_urlsum)
return finalUrlList
class SuningSort3PageParser(Sort3PageParser):
'''
三级页面解析类
'''
pricePageNum = 10
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(SuningSort3PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def nextPageUrlPattern(self):
#http://www.suning.com/webapp/wcs/stores/servlet/trd_10052_10051_1_20011_.html
nextPagePattern = 'http://www.suning.com/emall/thirdsearch?storeId=%s&catalogId=%s&categoryId=%s&langId=-7&ip_state=&suggestionWordList=&isCatalogSearch=1&isList=0&sortType=4¤tPage={}'
urlSegs = self.rootUrlSummary.url.rsplit('/', 1)[-1]
retArr = urlSegs.split('_')
pageSeg = nextPagePattern % (retArr[1],retArr[2],retArr[4])
return pageSeg
def getTotal(self):
pageSeg = self.soup.find(name='i',attrs={'id':'pageTotal'})
totalPage = 1
if pageSeg is not None:
totalPage = int(pageSeg.getText())
totalPage = totalPage - 1
if totalPage > SpiderConfig.getMaxPage():
totalPage = SpiderConfig.getMaxPage()
return totalPage
def parseSingleProd(self, li):
try:
aSeg = li.find(name='span').a
url = aSeg['href'].strip()
if ''.find('www') == -1:
url = '/'.join(('http://www.suning.com/emall', url))
name = aSeg['title'].strip()
adWords = li.find(name='p', attrs={'class':'sell'}).getText()
pid = url.rsplit('/', 1)[-1].split('_')[-2]
imgUrl = li.find(name='img')['src2']
priceSeg = li.find(name='p', attrs={'class':'price'})
priceImgUrl = ''
if priceSeg != None:
priceImgUrl = priceSeg.img['src2']
cityId = '9173' #默认是南京的价格
priceImgUrl = priceImgUrl.replace('~', cityId)
commentSeg = li.find(name='div', attrs={'class':'comment'})
evalSeg = None
repuSeg = None
if commentSeg is not None:
evalSeg = commentSeg.a
repuSeg = commentSeg.div
if evalSeg is not None:
evaluateNum = ParserUtils.getDigit(evalSeg.getText())
repu = ParserUtils.getDigit(repuSeg['class'])
else:
evaluateNum = '0'
repu = '0'
prodDetail = ProductDetails(productId=pid, fullUrl=url, imageUrl=imgUrl, privPrice='', name=name,
evaluateNum=evaluateNum, reputation=repu, adWords=adWords)
prodDetail.catagory = self.rootUrlSummary
return priceImgUrl,prodDetail
except Exception,e:
print e
def parserPageInfos(self):
plist = self.soup.find(name='div', attrs={'id':'proShow'})
resultList = []
if plist is None:
return resultList
try:
pool = ThreadPool(self.pricePageNum)
for li in plist(name='li'):
priceImgUrl,prodDetail = self.parseSingleProd(li)
pimgUrlSumm = ObuyUrlSummary(url = priceImgUrl)
req = WorkRequest(getProductPrice, [pimgUrlSumm, prodDetail, resultList, pool,captcha_suning], None,
callback=None)
pool.putRequest(req)
pool.wait()
except Exception,e:
raise e
finally:
pool.dismissWorkers(num_workers=self.pricePageNum)
return resultList
class SuningSort4PageParser(SuningSort3PageParser):
'''
分类四级页面为列表页面，只抽取Product信息
'''
def __init__(self, dataStr, rootUrlSummary, include=None, exclude=None):
super(SuningSort4PageParser, self).__init__(dataStr, rootUrlSummary, include, exclude)
def parserSubUrlSums(self):
pass
parserDict = {0:SuningAllSortParser, 3:SuningSort3PageParser, 4:SuningSort4PageParser}
''' test '''
import os
curModDir = os.path.dirname(os.path.abspath(__file__))
testFilePath = os.path.join(curModDir,'test_resources')
def testAllSortPage():
fileName = os.path.join(testFilePath,'suningAllSort.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
rootUrlSum = ObuyUrlSummary(url=r'http://www.suning.com/', name='suning')
excludeUrlSums = [ObuyUrlSummary(url=r'http://www.suning.com/webapp/wcs/stores/servlet/tcd_10052_22001_.html', name='suning' ,catagoryLevel=1)]
firstPage = SuningAllSortParser(content, rootUrlSum,exclude=excludeUrlSums)
for sort_3 in firstPage.parserSubUrlSums():
for index, urlsum in enumerate(sort_3.parentPath):
pass
print sort_3.name,sort_3.url ,sort_3.catagoryLevel
def testSort3Page():
fileName = os.path.join(testFilePath,'trd_10052_10051_1_20011_.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://www.suning.com/webapp/wcs/stores/servlet/trd_10052_10051_1_20011_.html',
parentPath=[('test')], catagoryLevel=3)
sort3Page = SuningSort3PageParser(content, sort_3_urlsum)
for sort_4 in sort3Page.getSort4PageUrlSums():
print sort_4.url
def testSort3Details():
fileName = os.path.join(testFilePath,'suning_2011-08-25_13-05-11.html')
with open(fileName, 'r') as fInput:
content = fInput.read()
sort_3_urlsum = ObuyUrlSummary(url=r'http://www.suning.com/emall/strd_10052_10051_1_20003_.html',
parentPath=[('test')], catagoryLevel=3)
ret = crawleRetries(sort_3_urlsum)
outputFileName = os.path.join(testFilePath,sort_3_urlsum.url.rsplit('/')[-1])
with open(outputFileName,'w') as outputFile:
outputFile.write(ret.content)
sort3Page = SuningSort3PageParser(ret.content, sort_3_urlsum)
for product in sort3Page.parserPageInfos():
print product.logstr()
if __name__ == '__main__':
#import urllib
#url = 'http://localhost/webapp/wcs/stores/servlet/odeSearch?storeId=10052&catalogId=10051&categoryId=20003&langId=-7&ip_state=c0%3ds%253A9%253Bcity_id%253B%253Aeq%253B1001B.s%253A9%253Bcity_id%253B%253Aeq%253B5006F.s%253A9%253Bcity_id%253B%253Aeq%253B5006Z.s%253A9%253Bcity_id%253B%253Ass%253B0000A%26c1%3ds%253A9%253Biphrase%2bbundle%2btaxonomy%2bid%2bfrom%2broot%253B%253Ass%253B%253A20003%26q%3d20%26a0%3diphrase%2bbundle%2btaxonomy%252F%252Fv%253A0%26i%3dsitemap%2bid%26qt%3d1313391335%26qid%3dq8GzGmE5P2Ss3%26vid%3dvSXajhCLXuWWu%26ioe%3dUTF-8%26s2%3dsitemap%2bid%252F%252F1%26qtid%3dn8GzGmE5P2Ss3%26s1%3dpublishTime%252F%252F0%26rid%3dr8OlldtbsEwdf%26s0%3drank%252F%252F0%26t%3d0%26m0%3diphrase%2bbundle%2bid%26mcmode%3dtest&suggestionWordList=&isCatalogSearch=1&isList=0&sortType=0¤tPage=1'
#print urllib.unquote(url)
#import re
#regx = re.compile('[0-9]+')
#testAllSortPage()
#testSort3Page()
testSort3Details()
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.