def generate_tokens(self):
tokens = []
while self.current_token is not None:
if self.current_token in " \t":
self.advance()
elif self.current_token in OPERATORS:
tokens.append(Token(OPERATORS[self.current_token]))
if self.current_token in "01)":
next_ = self.peek()
if next_ is not None and next_ in string.ascii_letters + "!(":
tokens.append(Token(TokenType.AND))
self.advance()
elif self.current_token in string.ascii_letters:
next_ = self.peek()
if next_ is not None and next_ not in "+^>=*)":
tokens.append(Token(TokenType.LITERAL, self.current_token))
tokens.append(Token(TokenType.AND))
else:
tokens.append(Token(TokenType.LITERAL, self.current_token))
self.advance()
else:
print("ERR")
return None
return tokens
def __init__(self, driver, base_url, pin, phone="", description=""):
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="SMS OTP")
driver.find_element_by_id("enroll_sms_desc").clear()
driver.find_element_by_id("enroll_sms_desc").send_keys(description)
if phone:
driver.find_element_by_id("sms_phone").clear()
driver.find_element_by_id("sms_phone").send_keys(phone)
driver.find_element_by_id("sms_pin1").clear()
driver.find_element_by_id("sms_pin1").send_keys(pin)
driver.find_element_by_id("sms_pin2").clear()
driver.find_element_by_id("sms_pin2").send_keys(pin)
driver.find_element_by_id("button_enroll_enroll").click()
# Wait for API call to complete
WebDriverWait(self.driver, 10).until_not(
EC.visibility_of_element_located((By.ID, "do_waiting")))
info_boxes = driver.find_elements_by_css_selector(
"#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("LSSM"):
raise Exception("SMS token was not enrolled correctly.")
def __simplify(self):
output = deque()
for token in self.tokens:
if len(output) > 0:
if token.type == TokenType.MinusOperator and output[
-1].type == TokenType.MinusOperator:
output.pop()
output.append(Token(TokenType.PlusOperator))
continue
elif token.type == TokenType.MinusOperator and output[
-1].type == TokenType.PlusOperator:
output.pop()
output.append(Token(TokenType.MinusOperator))
continue
elif token.type == TokenType.PlusOperator and output[
-1].type == TokenType.PlusOperator:
output.pop()
continue
elif (token.type == TokenType.MulOperator
and output[-1].type == TokenType.MulOperator) or (
token.type == TokenType.DivOperator
and output[-1].type == TokenType.DivOperator):
raise ValueError("Invalid expression")
output.append(token)
self.tokens = output
def tokenizer(self, source_file):
startPos = 0
source_json = {}
source_json['lexic'] = []
i = -1
while True:
i += 1
token_match = None
for el in self.tokens_def:
token_match = el['re'].match(source_file, startPos)
token_found = el['name']
if (token_match is not None and token_match.group() != ''):
break
if (token_match == None):
print(i, ':', startPos, ':', ':Unable to find a match')
break
else:
token_value = token_match.group(0)
token = Token(token_found, token_value, startPos)
source_json['lexic'].append(token.get_json_node())
print(i, ':', startPos, ':', token_value.__len__(), ':"',
token_found, '":', token_value)
startPos += token_value.__len__()
if (startPos >= source_file.__len__()):
break
return json.dumps(source_json, indent=3)
def make_number(self, pos, line):
num_str = ''
dot_count = 0
cur_pos = 0
for i in range(pos, len(self.text)):
if self.text[i] == ".":
if dot_count == 1:
cur_pos = i
break
dot_count += 1
num_str += '.'
elif self.text[i] == ' ' or self.text[i] == '\n' or self.text[
i] in OPERATOR:
cur_pos = i
break
elif self.text[i].isalpha():
self.log.addError('1', line)
self.log.print()
self.log.panicMode()
else:
num_str += self.text[i]
cur_pos = i
self.position = cur_pos
self.flag = True
if dot_count == 0:
return Token(T_INT, int(num_str), line, pos, cur_pos, 'num')
else:
return Token(T_FLOAT, float(num_str), line, pos, cur_pos, 'num')
def check_content(self, content):
content_list = Token().analyzeCode(content)
if len(content_list) == 1 and content_list[0] not in Token(
).token_dict['key word']:
return {'number': content_list[0]}
else:
d = {}
content = ' '.join(content_list)
if any([i in content for i in [':=', '+', '-', '*', '/', 'div']]):
try:
if ':=' in content:
content_before, content_after = content.split(' := ')
if len(Token().analyzeCode(content_before)) == 1:
d['identifier'] = content_before
d['owner word'] = ':='
else:
return '\nError in operand\n{}\nUnexpected symbol'.format(
content_before)
else:
content_after = content
except:
return '\nError in operand\n{}\nUnexpected symbol'.format(
content)
if len(Token().analyzeCode(content_after)) == 1:
d['number'] = content_after
elif Token().parse_commands(content, 0) == None:
d['number'] = content_after
else:
return '\nError in operand\n{}\nUnexpected symbol'.format(
content_after)
else:
return '\nError in operand\n{}\nUnexpected symbol'.format(
content)
return d
def nextToken(self):
global maxLenghtOfIdentifier
lexeme = self.lexer.token()
if not lexeme:
# If no token was returned, EOF reached, break loop.
token = Token('tc_EOF',('','op_NONE'),'dt_NONE',self.lexer.lineno,0)
return token
if lexeme.type == 'tc_ID' and len(lexeme.value) > maxLenghtOfIdentifier:
TokenCode = 'tc_ID2LONG'
else:
TokenCode = lexeme.type
try:
opType = lexeme.OpType
except:
opType = 'op_NONE'
DataValue = lexeme.value,opType
try:
DataType = lexeme.DataType
except:
DataType = 'dt_NONE'
token = Token(TokenCode, DataValue, DataType,lexeme.lineno,self._find_tok_column(lexeme))
return token
def __init__(self, driver, base_url, url, remote_serial, pin, remote_otp_length=6):
"""Currently only supports enrolling remote tokens using the remote
serial. PIN is always checked locally.
"""
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="Remote token")
driver.find_element_by_id("remote_server").clear()
driver.find_element_by_id("remote_server").send_keys(url)
driver.find_element_by_id("remote_otplen").clear()
driver.find_element_by_id("remote_otplen").send_keys(remote_otp_length)
driver.find_element_by_id("remote_serial").clear()
driver.find_element_by_id("remote_serial").send_keys(remote_serial)
driver.find_element_by_id("remote_pin1").clear()
driver.find_element_by_id("remote_pin1").send_keys(pin)
driver.find_element_by_id("remote_pin2").clear()
driver.find_element_by_id("remote_pin2").send_keys(pin)
driver.find_element_by_id("button_enroll_enroll").click()
time.sleep(1)
info_boxes = driver.find_elements_by_css_selector("#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("LSRE"):
raise Exception("Remote token was not enrolled correctly.")
def get_next_token(self):
"""Lexical analyzer (also known as scanner or tokenizer)
This method is responsible for breaking a sentence
apart into tokens.
"""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char.isdigit():
return Token(INTEGER, self.integer())
if self.current_char == '+':
self.advance()
return Token(PLUS, '+')
if self.current_char == '-':
self.advance()
return Token(MINUS, '-')
self.error()
return Token(EOF, None)
def _scan(self) -> None:
'''Scan a expression and find out operands and operators even without blanks'''
self.tokens = []
# index of a number starting at
tokenStart = 0
# delete blanks
withoutBlank = self._sourceStr.replace(' ', '')
# read the expression
for index, char in enumerate(withoutBlank):
# meeting an operator means the end of a number
if char in Token.operator:
# negatives
if char == '-' and index == tokenStart and (
index == 0 or self.tokens[-1].isOperator()):
continue
# skip '()'
if index != tokenStart:
# append the operand
self.tokens.append(
Token(float(withoutBlank[tokenStart:index])))
# append the operator or '()'
self.tokens.append(Token(char))
# update the numberStart's index
tokenStart = index + 1
# append the last number
elif index == len(withoutBlank) - 1:
self.tokens.append(
Token(float(withoutBlank[tokenStart:index + 1])))
def string(self) -> Token:
"""Return a literal string token (STRING_CONST).
Returns:
Token: a token representing a literal string.
"""
token = Token(type=None,
value=None,
line=self.t_line,
column=self.t_column)
self.advance()
value = ""
while (self.current_char is not None and self.current_char.isalpha()
or self.current_char in self.SINGLE_CHARACTERS):
value += self.current_char
self.advance()
if self.current_char.isspace():
value += " "
self.skip_whitespace()
self.advance()
token.type = TokenType.STRING_CONST
token.value = value
return token
def __init__(self, lexer):
self.tokens = lexer.tokens
self.curToken = Token(0, '', '')
self.peekToken = Token(0, '', '')
self.tokenIdx = 1
self.prefix = 'kp'
self.vt = {}
self.ft = {}
self.ifc = 0
self.whilec = 0
self.lparen = 0
self.rparen = 0
if len(self.tokens) == 1:
self.curToken = self.tokens[0]
elif len(self.tokens) > 1:
self.curToken = self.tokens[0]
self.peekToken = self.tokens[1]
else:
self.error()
self.tab = ' '
self.start()
#self.S(0)
print ""
def __init__(self,
driver,
base_url,
pin="",
description="Selenium enrolled"):
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="Simple Pass Token")
driver.find_element_by_id("spass_pin1").clear()
driver.find_element_by_id("spass_pin1").send_keys(pin)
driver.find_element_by_id("spass_pin2").clear()
driver.find_element_by_id("spass_pin2").send_keys(pin)
driver.find_element_by_id("enroll_spass_desc").clear()
driver.find_element_by_id("enroll_spass_desc").send_keys(description)
driver.find_element_by_id("button_enroll_enroll").click()
# Wait for API call to complete
WebDriverWait(self.driver, 10).until_not(
EC.visibility_of_element_located((By.ID, "do_waiting")))
info_boxes = driver.find_elements_by_css_selector("#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("LSSP"):
raise Exception("Simple pass token was not enrolled correctly.")
def tokenize(line: str, lineno: int, symtable: SymbolTable):
current = initialNode
tokens = []
value = ''
for col, char in enumerate(line):
if current is None:
lexException(line, lineno, col - 1)
if current is initialNode and char in WHITE:
continue
nxt = current.move(char)
if nxt is not None:
value += char
current = nxt
elif current.is_final:
if current is intNode or current is floatNode:
tokens.append(Token(Sym(NUM, value), lineno, col))
else:
symbol = symtable.lookup(value)
tokens.append(Token(symbol, lineno, col))
current = initialNode if char in WHITE else initialNode.move(char)
value = '' if char in WHITE else char
else:
lexException(line, lineno, col)
if current.is_final:
if current is intNode or current is floatNode:
tokens.append(Token(Sym(NUM, value), lineno, col))
else:
symbol = symtable.lookup(value)
tokens.append(Token(symbol, lineno, col))
return tokens
def __parse_parentheses(self, par_, buf_):
buf = self.__parse_buf(buf_)
if par_ == '(':
self.tokens.append(Token(TokenType.OpenParentheses))
else:
self.tokens.append(Token(TokenType.CloseParentheses))
return buf
def __init__(self, receiver, tribe, position):
Token.__init__(self, receiver)
self.tribe = tribe
self.debug = False
self.first = Dot.FIRST
Dot.FIRST = False
self.wander = False
self.wander_steering = Dot.WanderSteering(self, distance=20,
radius=10,
jitter=1)
self.position = position
self.velocity = ZeroVector()
self.dead = False
self.health = MAX_HEALTH
self.growth = 0
self.speed = 50
self.radius = 15
self.color = tribe.color
self.targets = []
def cria_Token(self, tipoToken, lexema, linha, coluna):
# Se é um desses tipos validos, será registrado na tabela de simbolos.
if tipoToken == self.literal["Inteiro_classe"] or tipoToken == self.literal["char_classe"] or tipoToken == \
self.literal["cadeia_classe"] or tipoToken == self.literal["variavel_classe"] or tipoToken == \
self.literal["Flutuante_classe"]:
# Se o lexema não existir na tabela, insere ele.
if lexema not in self.sequencia_Simbolos.values():
# Insere o token na tabela de simbolos, e adiciona no fluxo de tokens
index = len(self.sequencia_Simbolos)
self.sequencia_Simbolos[index] = lexema
token = Token(tipoToken, lexema, linha, coluna, index)
self.sequencia_Tokens.append(token)
return
else:
# Se o token já existe, então ve como é o indice dele para inserir no fluxo de tokens
# Obs: Tem que fazer melhor!!!.
index = [chave for chave in self.sequencia_Simbolos if self.sequencia_Simbolos[chave] == lexema][0]
token = Token(tipoToken, lexema, linha, coluna, index)
self.sequencia_Tokens.append(token)
return
else:
# Se o lexema não for de um tipo que requer um "Tipo", então inserir no fluxo de tokens
token = Token(tipoToken, lexema, linha, coluna)
self.sequencia_Tokens.append(token)
return
def __init__(self):
self.ts = {}
self.ts['if'] = Token(Tag.KW_IF, 'if', 0, 0)
self.ts['else'] = Token(Tag.KW_ELSE, 'else', 0, 0)
self.ts['then'] = Token(Tag.KW_THEN, 'then', 0, 0)
self.ts['print'] = Token(Tag.KW_PRINT, 'print', 0, 0)
def Tokenize(self, source):
tokens = list()
token = ''
state = TokenizeState.DEFAULT
index = 0
while index < len(source):
chr = source[index]
if state == TokenizeState.DEFAULT:
opType = self.FindOpType(chr)
if self.IsOp(chr):
tokens.append(Token(str(chr), opType))
elif self.IsParen(chr):
parenType = self.FindParenType(chr)
tokens.append(Token(str(chr), parenType))
elif chr.isdigit():
token = token + chr
state = TokenizeState.NUMBER
# Handles multi-digit numbers
elif state == TokenizeState.NUMBER:
if chr.isdigit():
token = token + chr
else:
tokens.append(Token(token, TokenizeState.NUMBER))
token = ""
state = TokenizeState.DEFAULT
index -= 1
index += 1
return tokens
def evolve(self):
#get singleton
tok = Token().get_instance()
gen, id, level = tok.evolve()
return gen, id, level
def test_set_parselet_with_non_set(self):
sp = SetParselet()
with (self.assertRaises(Exception)):
sp.parse(None, Token(TokenType.SET, "(a, b, c)"))
sp.parse(None, Token(TokenType.SET, "a, b, c"))
sp.parse(None, Token(TokenType.SET, "[a, b, c"))
sp.parse(None, Token(TokenType.SET, "a, b, c]"))
sp.parse(None, Token(TokenType.SET, "<a, b, c>"))
def number(self):
"""recognizes and returns an integer or float token"""
integer = self.get_integer()
if self.current_char == '.':
self.advance()
floating = float(str(integer) + str(self.get_integer()))
return Token(self.tokentype['FLOAT'], floating)
return Token(self.tokentype['INT'], integer)
def test_map_parselet_with_non_map(self):
mp = MapParselet()
with (self.assertRaises(Exception)):
mp.parse(None, Token(TokenType.MAP, "(a, b, c)"))
mp.parse(None, Token(TokenType.MAP, "a, b, c"))
mp.parse(None, Token(TokenType.MAP, "{a, b, c"))
mp.parse(None, Token(TokenType.MAP, "a, b, c}"))
mp.parse(None, Token(TokenType.MAP, "<a, b, c>"))
def __init__(self, receiver, color, x, y):
Token.__init__(self, receiver)
self.dots = []
self.manager = None # Set in the GUI manager constructor.
self.color = color
self.position = Vector(x, y)
def main():
plus = Token(Token.PLUS, '+')
one = Token(Token.INT, '1')
two = Token(Token.INT, '2')
root = Ast(plus)
root.add_child(Ast(one))
root.add_child(Ast(two))
print("1+2 tree: " + str(root))
def get_next_token(self) -> Token:
"""Here the Lexical Analysis will take place, so the sentences will be broken
one at a time into smaller parts
Returns:
Token: the Token object with all informations about the found token
Raises:
ValueError: a TokenizeError when the current_token is not found in the grammar
"""
while self.current_char is not None:
if self.current_char.isspace():
self.skip_whitespace()
continue
if self.current_char == "{":
self.advance()
self.skip_comment()
continue
if self.current_char.isalpha():
return self.handle_with_id_tokens()
if self.current_char in ["'", '"']:
return self.string()
if self.current_char.isdigit():
return self.number()
if self.current_char == ":" and self.tokenize_assign_statements(
) == "=":
token = Token(
type=TokenType.ASSIGN,
value=TokenType.ASSIGN.value,
line=self.t_line,
column=self.t_column,
)
self.advance()
self.advance()
return token
try:
token_type = TokenType(self.current_char)
except ValueError:
TokenizerErrorHandler.error(self.current_char, self.t_line,
self.t_column)
else:
token = Token(
type=token_type,
value=token_type.value,
line=self.t_line,
column=self.t_column,
)
self.advance()
return token
return Token(type=TokenType.EOF, value=None)
def newgame(self):
#get singleton
tok = Token().get_instance()
exp = tok.start_game()
#return exp
return exp
def _getNextToken(self):
self._skipWhiteSpace()
if self._currentChar.isdigit():
self._currentToken = Token(self._getInteger())
elif self._currentChar == Scanner.EOE:
self._currentToken = Token(';')
else:
self._currentToken = Token(self._currentChar)
self._nextChar()
def __tokenize_strings(token_strings):
tokens = []
for token_string in token_strings:
if token_string.isdigit():
tokens.append(Token(token_types.INTEGER, int(token_string)))
elif token_string == '+':
tokens.append(Token(token_types.PLUS, token_string))
return tokens
def string(self):
"""recognizes and returns a string token"""
_string = ''
while self.current_char != '"':
_string += self.current_char
self.advance()
# return CHARACTER token if length of string is less than 2
if len(_string) == 1:
return Token(self.tokentype['CHAR'], _string)
return Token(self.tokentype['STRING'], _string)
def checkTag(self):
r = random.randint(0, 10)
if r < 6: # cache hit
print('%s cache hit' % self.name)
emitToken = Token(self, 'cacheHit')
else: # cache miss
print('%s cache miss' % self.name)
emitToken = Token(self, 'cacheMiss')
tokenPool.insert(emitToken)
def parseAction( s_txt, n_pos, o_token ):
oToken = Token( sName )
for oChild in [ o for o in o_token if isinstance( o, Token ) ]:
oToken.addChild( oChild )
lTxt = [ o for o in o_token if isinstance( o, basestring ) ]
assert len( lTxt ) < 2
if lTxt:
oToken.val = lTxt[ 0 ]
oToken.options.update( mOptions )
return oToken
def __init__(self,
driver,
base_url,
pin="",
hmac_key="",
generate_key=False,
otp_length=6,
hash_algorithm="sha1",
description="Selenium enrolled"):
"""
"""
assert bool(hmac_key) ^ bool(generate_key) # xor
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver,
select_element=select_tag,
option_text="HMAC eventbased")
wel_hmac_key_rb_gen = driver.find_element_by_id("hmac_key_rb_gen")
wel_hmac_key_rb_no = driver.find_element_by_id("hmac_key_rb_no")
wel_hmac_key = driver.find_element_by_id("hmac_key")
wel_hmac_otplen = driver.find_element_by_id("hmac_otplen")
wel_hmac_algorithm = driver.find_element_by_id("hmac_algorithm")
wel_enroll_hmac_desc = driver.find_element_by_id("enroll_hmac_desc")
if hmac_key:
wel_hmac_key_rb_no.click() # select: seed input - no random see
wel_hmac_key.clear()
wel_hmac_key.send_keys(hmac_key)
elif generate_key:
wel_hmac_key_rb_gen.click() # select: random seed
select(driver,
select_element=wel_hmac_otplen,
option_text=str(otp_length))
select(driver,
select_element=wel_hmac_algorithm,
option_text=hash_algorithm)
driver.find_element_by_id("hmac_pin1").clear()
driver.find_element_by_id("hmac_pin1").send_keys(pin)
driver.find_element_by_id("hmac_pin2").clear()
driver.find_element_by_id("hmac_pin2").send_keys(pin)
wel_enroll_hmac_desc.send_keys(description)
driver.find_element_by_id("button_enroll_enroll").click()
# Wait for API call to complete
WebDriverWait(self.driver, 10).until_not(
EC.visibility_of_element_located((By.ID, "do_waiting")))
info_boxes = driver.find_elements_by_css_selector(
"#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("OATH"):
raise Exception("HMAC/HOTP token was not enrolled correctly.")
def stack_machine_run(self, theard_fl=False, num=-1):
while self.token_count < len(self.tokens):
#print_tokens(self.tokens[self.token_count:])
if self.tokens[self.token_count].get_type(
) == 'VAR' or self.tokens[self.token_count].get_type() == 'DIGIT':
self.stack.append(self.tokens[self.token_count])
elif self.tokens[self.token_count].get_type() == 'FN_VALUE':
if theard_fl:
out = self.fun_calculate(
self.tokens[self.token_count].get_value(),
self.tokens[self.token_count + 1], True)
self.token_count += 2
return 'wait', out
else:
out = self.fun_calculate(
self.tokens[self.token_count].get_value(),
self.tokens[self.token_count + 1])
self.stack.append(out)
self.token_count += 1
elif self.tokens[self.token_count].get_type() == 'ARI_OP':
self.stack.append(self.calculate(
self.tokens[self.token_count]))
elif self.tokens[self.token_count].get_type() == 'ASSIGN_OP':
self.assign_op()
elif self.tokens[self.token_count].get_type() == 'LOG_OP':
self.stack.append(self.calculate(
self.tokens[self.token_count]))
elif self.tokens[self.token_count].get_type() == 'GO_F':
flag = self.stack.pop().get_value()
if flag == False:
self.token_count = self.tokens[
self.token_count].get_value()
elif self.tokens[self.token_count].get_type() == 'GO_A':
self.token_count = self.tokens[self.token_count].get_value()
if theard_fl and (self.tokens[self.token_count].get_type() in [
'ARI_OP', 'ASSIGN_OP', 'LOG_OP'
]) and self.token_count + 2 < len(self.tokens):
self.token_count += 1
return 'ready', []
self.token_count += 1
if theard_fl:
if self.tokens[-1].get_type() != 'RETURN':
return 'exit', self.value_table
else:
out = self.stack.pop()
if out.get_type() == 'VAR':
var = self.find_value(out.get_value())
return 'exit', Token('DIGIT', var)
else:
return 'exit', Token('DIGIT', out.get_value())
print(self.value_table)
def parse(self, tokenizer, state=None):
from token import Token
lookahead = None
lookaheadstack = []
statestack = [0]
symstack = [Token("$end", "$end")]
current_state = 0
while True:
if self.lr_table.default_reductions[current_state]:
t = self.lr_table.default_reductions[current_state]
current_state = self._reduce_production(
t, symstack, statestack, state)
continue
if lookahead is None:
if lookaheadstack:
lookahead = lookaheadstack.pop()
else:
try:
lookahead = next(tokenizer)
except StopIteration:
lookahead = None
if lookahead is None:
lookahead = Token("$end", "$end")
ltype = lookahead.gettokentype()
if ltype in self.lr_table.lr_action[current_state]:
t = self.lr_table.lr_action[current_state][ltype]
if t > 0:
statestack.append(t)
current_state = t
symstack.append(lookahead)
lookahead = None
continue
elif t < 0:
current_state = self._reduce_production(
t, symstack, statestack, state)
continue
else:
n = symstack[-1]
return n
else:
# TODO: actual error handling here
if self.error_handler is not None:
if state is None:
self.error_handler(lookahead)
else:
self.error_handler(state, lookahead)
raise AssertionError("For now, error_handler must raise.")
else:
raise ParsingError(None, lookahead.getsourcepos())
def fill(self):
while len(self.buffer) - self.typePos < self.width / 2:
n = self.lib.next()
if n[-2] == "'" and not self.useApostrophes:
n = n[:-2]
for s in list(n):
self.buffer.append(Token(s))
self.buffer.append(Token(' ', space=True))
def __init__(
self,
driver,
base_url,
pin="",
hmac_key="",
generate_key=False,
otp_length=6,
hash_algorithm="sha1",
description="Selenium enrolled",
):
"""
"""
assert bool(hmac_key) ^ bool(generate_key) # xor
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="HMAC eventbased")
wel_hmac_key_rb_gen = driver.find_element_by_id("hmac_key_rb_gen")
wel_hmac_key_rb_no = driver.find_element_by_id("hmac_key_rb_no")
wel_hmac_key = driver.find_element_by_id("hmac_key")
wel_hmac_otplen = driver.find_element_by_id("hmac_otplen")
wel_hmac_algorithm = driver.find_element_by_id("hmac_algorithm")
wel_enroll_hmac_desc = driver.find_element_by_id("enroll_hmac_desc")
if hmac_key:
wel_hmac_key_rb_no.click() # select: seed input - no random see
wel_hmac_key.clear()
wel_hmac_key.send_keys(hmac_key)
elif generate_key:
wel_hmac_key_rb_gen.click() # select: random seed
select(driver, select_element=wel_hmac_otplen, option_text=str(otp_length))
select(driver, select_element=wel_hmac_algorithm, option_text=hash_algorithm)
driver.find_element_by_id("hmac_pin1").clear()
driver.find_element_by_id("hmac_pin1").send_keys(pin)
driver.find_element_by_id("hmac_pin2").clear()
driver.find_element_by_id("hmac_pin2").send_keys(pin)
wel_enroll_hmac_desc.send_keys(description)
driver.find_element_by_id("button_enroll_enroll").click()
# Wait for API call to complete
WebDriverWait(self.driver, 10).until_not(EC.visibility_of_element_located((By.ID, "do_waiting")))
info_boxes = driver.find_elements_by_css_selector("#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("OATH"):
raise Exception("HMAC/HOTP token was not enrolled correctly.")
def tokenize_deck(self, deck): '''Place the deck onto the board. Index in various ways.''' # all tokens all_tokens = Token.make_all_tokens() # sanity check - +1 for desert assert(len(all_tokens) + 1 == len(deck)) for t in deck: # give it a NAME if t.name() != "desert": t.place(all_tokens.pop(0)) if t.number() not in self.r: self.r[t.number()] = [] # map number to name of resource self.r[t.number()].append(t.name()) # TODO consider mapping coordinates to resource # TODO map vertices to adjacent tiles # TODO add vertices here self.__tiles.append(t) return self.__tiles
def wrapped(*args, **kwargs):
if not request.json:
return abort(400)
auth = request.json.get('auth')
if not auth:
return make_response(jsonify({'error': 'Authentication needed.'}), 400)
if not Token.check_captcha(auth.get('sha'), auth.get('captcha')):
return make_response(jsonify({'error': 'Authentication failed.'}), 400)
return f(*args, **kwargs)
def __init__(self, driver, base_url, pin, phone="", description=""):
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="SMS OTP")
driver.find_element_by_id("enroll_sms_desc").clear()
driver.find_element_by_id("enroll_sms_desc").send_keys(description)
if phone:
driver.find_element_by_id("sms_phone").clear()
driver.find_element_by_id("sms_phone").send_keys(email)
driver.find_element_by_id("button_enroll_enroll").click()
self.serial = driver.find_element_by_css_selector("#info_box > #info_text > span").text
if not self.serial or not self.serial.startswith("LSSM"):
raise Exception("SMS token was not enrolled correctly.")
driver.find_element_by_id("pin1").clear()
driver.find_element_by_id("pin1").send_keys(pin)
driver.find_element_by_id("pin2").clear()
driver.find_element_by_id("pin2").send_keys(pin)
time.sleep(1)
driver.find_element_by_id("button_setpin_setpin").click()
def __init__(self, driver, base_url, pin, email="", description=""):
Token.__init__(self, driver=driver, base_url=base_url)
select_tag = driver.find_element_by_id("tokentype")
select(driver, select_element=select_tag, option_text="E-mail token")
driver.find_element_by_id("enroll_email_desc").clear()
driver.find_element_by_id("enroll_email_desc").send_keys(description)
driver.find_element_by_id("email_pin1").clear()
driver.find_element_by_id("email_pin1").send_keys(pin)
driver.find_element_by_id("email_pin2").clear()
driver.find_element_by_id("email_pin2").send_keys(pin)
if email:
driver.find_element_by_id("email_address").clear()
driver.find_element_by_id("email_address").send_keys(email)
driver.find_element_by_id("button_enroll_enroll").click()
time.sleep(1)
info_boxes = driver.find_elements_by_css_selector("#info_box > .info_box > span")
for box in info_boxes:
if box.text.startswith("created token with serial"):
self.serial = box.find_element_by_tag_name("span").text
if not self.serial or not self.serial.startswith("LSEM"):
raise Exception("E-mail token was not enrolled correctly.")
def add_command(self, command, callback, cmd_desc, token_desc):
"""
Add a command to the parse tree.
:param command: A command string.
:param cmd_desc: The description of the command.
:param token_desc: A dictionary for description of each token.
:return: None
"""
tokens = [Token.from_string(x) for x in command.split()]
cur_node = self._root
for token in tokens:
cur_node = cur_node.add(token)
cur_node.add(callback, cmd_desc)
def evaluate(self):
while self._scanner.hasNext():
currentToken = self._scanner.next()
self._expressionSoFar += str(currentToken) + " "
if currentToken.getType() == Token.INT:
self._operandStack.push(currentToken)
elif currentToken.isOperator():
if len(self._operandStack) < 2:
raise Exception, \
"Too few operands on the stack"
t2 = self._operandStack.pop()
t1 = self._operandStack.pop()
result = Token(self._computeValue(currentToken,
t1.getValue(),
t2.getValue()))
self._operandStack.push(result)
else:
raise Exception, "Unknown token type"
if len(self._operandStack) > 1:
raise Exception, "Too many operands on the stack"
result = self._operandStack.pop()
return result.getValue();
def next_token(self):
found = False
while not found and not self.eof:
ch = self._getch()
if ch.isspace():
continue
self._tokenpos = self._cline + 1, self._cpos + 1
if ch in string.letters + "_":
tok = self._read_identifier(ch)
elif ch in string.digits + "$":
tok = self._read_number(ch)
elif ch == "/":
tok = self._read_comment(ch)
elif ch in "{(":
tok = self._read_block_comment(ch)
elif ch == "'":
tok = self._read_string_const(ch)
elif ch == "#":
tok = self._read_char_const(ch)
elif ch in special:
tok = self._read_delimiter(ch)
elif ch:
self.e("Illegal character '{0}'", ch)
found = ch and tok is not None
if found and ch:
tok.line, tok.pos = self._tokenpos
else:
tok = Token(tt.eof, value="EOF")
tok.line, tok.pos = self._tokenpos
if tok.line:
tok.line -= 1
else:
tok.line += 1
self._token = tok
def tokenize(text):
i = 0
puntuation_start = map(lambda x: x[0], punctuation)
while i < len(text):
if text[i] in spacing: r = Token(eat_spacing(text[i:]), 'space or comment')
elif text[i:i+2] == '--': r = Token(eat_comment_oneline(text[i:]), 'space or comment')
elif text[i:i+2] == '/*': r = Token(eat_comment_multiline(text[i:]), 'space or comment')
elif text[i] in puntuation_start: r = Token(eat_punctuation(text[i:]), 'punctuation')
elif text[i] in "'": r = Token(eat_string(text[i:]), 'string')
elif text[i] in '"': r = Token(eat_string_doubleq(text[i:]), 'string_doubleq')
else: r = Token(eat_words(text[i:]), "id")
if r.text.lower() in keyword_list: r.type = "keyword"
i += len(r)
yield r
def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
self.preview_btn = None
self.wiki_btn = None
self.reset_btn = None
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'OsmaWebServices_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dock = OsmaWebServicesDock()
# Add dock to main window
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&OSMA Web Services')
# self.toolbar = self.iface.addToolBar(u'OsmaWebServices')
# self.toolbar.setObjectName(u'OsmaWebServices')
# Variable for layers and about/info
self.layers = None
self.about = None
self.caches = None
self.hit_osma = GetOsmaLayers()
self.token_config = Token(self.iface)
self.token_config.check_token()
# Create instance of qtreeview for wms/wmts
self.pop_wmts = PopulateTree(self.dock.ui, self.iface, self.token_config, wms=False)
self.pop_wms = PopulateTree(self.dock.ui, self.iface, self.token_config, wms=True)
def infixToPostfix(self, expr):
tokens = Token.tokenize(expr)
operatorStack = []
operandStack = []
for token in tokens:
if token.isOperand():
operandStack.append(token)
elif (token.val == OperatorType.LParen or len(operatorStack) < 1 or
OperatorType.opHierarchy(token.val) > OperatorType.opHierarchy(operatorStack[-1].val)):
operatorStack.append(token)
elif token.val == OperatorType.RParen:
# pop off both stacks building postfix expressions until LParen is found
# each postfix expression gets pushed back into the operand stack
while (operatorStack[-1].val != OperatorType.LParen):
self.__buildSinglePostfixExpr(operatorStack, operandStack)
# pop the LParen from the stack
operatorStack.pop()
elif OperatorType.opHierarchy(token.val) <= OperatorType.opHierarchy(operatorStack[-1].val):
# Continue to pop operator and operand stack, building postfix
# expressions until the stack is empty or until an operator at
# the top of the operator stack has a lower hierarchy than that
# of the token.
while (len(operatorStack) > 0 and
OperatorType.opHierarchy(token.val) <= OperatorType.opHierarchy(operatorStack[-1].val)):
print 'operators', operatorStack
print 'operands', operandStack
self.__buildSinglePostfixExpr(operatorStack, operandStack)
# push the lower prcendence operator onto stack
operatorStack.append(token)
# read in all tokens, pop stuff off the operator stack until it is empty (if it's not already)
while (len(operatorStack) > 0):
self.__buildSinglePostfixExpr(operatorStack, operandStack)
return operandStack.pop()
class OsmaWebServices:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
self.preview_btn = None
self.wiki_btn = None
self.reset_btn = None
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'OsmaWebServices_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dock = OsmaWebServicesDock()
# Add dock to main window
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&OSMA Web Services')
# self.toolbar = self.iface.addToolBar(u'OsmaWebServices')
# self.toolbar.setObjectName(u'OsmaWebServices')
# Variable for layers and about/info
self.layers = None
self.about = None
self.caches = None
self.hit_osma = GetOsmaLayers()
self.token_config = Token(self.iface)
self.token_config.check_token()
# Create instance of qtreeview for wms/wmts
self.pop_wmts = PopulateTree(self.dock.ui, self.iface, self.token_config, wms=False)
self.pop_wms = PopulateTree(self.dock.ui, self.iface, self.token_config, wms=True)
def tr(self, message):
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('OsmaWebServices', message)
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=False,
status_tip=None,
whats_this=None,
parent=None):
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToWebMenu(
self.menu,
action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/OsmaWebServices/icon.png'
self.add_action(
icon_path,
text=self.tr(u'OSMA Web Services'),
callback=self.run,
parent=self.iface.mainWindow())
# Adds 'OSMA Wiki' to the menu
self.wiki_btn = QAction("Help Wiki", self.iface.mainWindow())
QObject.connect(self.wiki_btn, SIGNAL("triggered()"), self.wiki_clicked)
self.iface.addPluginToWebMenu(u"OSMA Web Services", self.wiki_btn)
# Adds 'Reset plugin' to the menu
self.reset_btn = QAction("Reset Plugin", self.iface.mainWindow())
QObject.connect(self.reset_btn, SIGNAL("triggered()"), self.clear_token)
self.iface.addPluginToWebMenu(u"OSMA Web Services", self.reset_btn)
# Adds 'Show preview' to the menu
self.preview_btn = QAction("Preview enabled", self.iface.mainWindow(), checkable=True)
QObject.connect(self.preview_btn, SIGNAL("triggered()"),
lambda: self.change_preview(self.preview_btn.isChecked()))
self.iface.addPluginToWebMenu(u"OSMA Web Services", self.preview_btn)
# Get preview preference from registry and set column visibility
if QSettings().value("OsmaWebServices/Preview") == "False":
self.change_preview(False)
else:
self.change_preview(True)
self.preview_btn.setChecked(True)
# hookup TW logo connection to website
self.dock.ui.twLogoLabel.mousePressEvent = self.tw_logo_clicked
# Hookup 'Load layers' buttons to token function
self.dock.ui.loadLayersWmsButton.pressed.connect(self.token)
self.dock.ui.loadLayersWmtsButton.pressed.connect(self.token)
# Hookup search
self.dock.ui.wmtsSearchLineEdit.textChanged.connect(self.pop_wmts.filter_layers)
self.dock.ui.wmsSearchLineEdit.textChanged.connect(self.pop_wms.filter_layers)
def token(self):
# Runs on first push of 'Load Layers'
# Prompt for token if missing
if not self.token_config.token:
self.token_config.prompt_token()
# If token is good then change connections and load layers
if self.token_config.token:
self.load_layers()
self.populate_about()
# Break current 'Load Layers' connections ad connect to load_layers function
self.dock.ui.loadLayersWmsButton.pressed.disconnect()
self.dock.ui.loadLayersWmsButton.pressed.connect(self.load_layers)
self.dock.ui.loadLayersWmtsButton.pressed.connect(self.load_layers)
else:
pass
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginWebMenu(
self.tr(u'OSMA Web Services'),
action)
self.iface.removeToolBarIcon(action)
self.iface.removeDockWidget(self.dock)
self.iface.removePluginWebMenu(u"OSMA Web Services", self.reset_btn)
self.iface.removePluginWebMenu(u"OSMA Web Services", self.wiki_btn)
self.iface.removePluginWebMenu(u"OSMA Web Services", self.preview_btn)
def run(self):
# Display docked window
self.dock.show()
def tw_logo_clicked(self, mouse_event):
# Open tw website in browsers on logo click
webbrowser.open('http://www.thinkwhere.com')
def wiki_clicked(self):
# Open wiki in web browser
webbrowser.open('http://wms.locationcentre.co.uk/wiki/index.php/OSMA_Web_Services')
def change_preview(self, ischecked):
self.pop_wms.preview_column(ischecked)
self.pop_wmts.preview_column(ischecked)
def hit_osma_ws(self, token):
# Hi the GetCapabilities
osma = self.hit_osma.get_available_layers(token)
self.layers = osma.get('layers')
self.about = osma.get('info')
self.caches = osma.get('caches')
def load_layers(self):
# Load layers and populate treeviews
# Get layers from ws and populate tree
if self.layers is None and self.caches is None:
self.hit_osma_ws(self.token_config.token)
cache_lst = []
for cache in self.caches:
cache_lst.append(str(cache))
wmts_layers = []
# Check if is WMTS by matching with cache and adds grid to dict
for layer in self.layers:
source = layer.get('sources')[0]
if source in cache_lst:
grid = self.caches.get(source).get('grids')[0]
layer['grid'] = grid
wmts_layers.append(layer)
else:
pass
# Populate trees
self.pop_wmts.add_layers(wmts_layers)
self.pop_wms.add_layers(self.layers)
def populate_about(self):
# Populate the 'about' tab with info from the GetCapabilities
if self.about is None:
self.hit_osma_ws(self.token_config.token)
meta = self.about.get('wms').get('md')
abstract = meta.get('abstract')
email = meta.get('contact').get('email')
person = meta.get('contact').get('person')
position = meta.get('contact').get('position')
phone = meta.get('contact').get('phone')
city = meta.get('contact').get('city')
fax = meta.get('contact').get('fax')
country = meta.get('contact').get('country')
postcode = meta.get('contact').get('postcode')
address = meta.get('contact').get('address')
access = meta.get('access_constraints')
org = meta.get('contact').get('organization')
self.dock.ui.abstractLabel.setText(abstract)
self.dock.ui.emailLabel.setText("email: " + email)
self.dock.ui.personLabel.setText("Contact: " + person)
self.dock.ui.positionLabel.setText("Position: " + position)
self.dock.ui.phoneLabel.setText("Phone:" + phone)
self.dock.ui.cityLabel.setText(city)
self.dock.ui.faxLabel.setText("Fax: " + fax)
self.dock.ui.countryLabel.setText(country)
self.dock.ui.postcodeLabel.setText(postcode)
self.dock.ui.addrLabel.setText("Address: " + address)
self.dock.ui.accessLabel.setText("Access Constraint: " + access)
self.dock.ui.orgLabel.setText("organization: " + org)
def clear_token(self):
# Reset plugin to initial state
self.token_config.clear_token()
self.pop_wms.clear_tree()
self.pop_wmts.clear_tree()
self.layers = None
self.about = None
self.caches = None
# Break current 'Load Layers' connections ad re-connect to token function
self.dock.ui.loadLayersWmsButton.pressed.disconnect()
self.dock.ui.loadLayersWmsButton.pressed.connect(self.token)
self.dock.ui.loadLayersWmtsButton.pressed.connect(self.token)
# Info box
QMessageBox.information(self.iface.mainWindow(), "Reset Successful", "OSMA Web Services Plugin has been reset")
from board import Board
from token import Token
from constants import *
from PySFML import sf
import math, os, sys
window = sf.RenderWindow(sf.VideoMode(win_width, win_height), "Blackode")
InputHandler = window.GetInput()
bcircle = Token('circle', blue)
bcircle.set_center(150, win_height/2)
rcircle = Token('circle', red)
rcircle.set_center(win_width - 150, win_height/2)
b = Board(bcircle, rcircle)
running = True
tokens = []
lx = 250
rx = win_width - lx
for i in range(num_cols - 1):
y = 100 + (i * box_height * 2)
token = Token('rect', blue)
token.shape.SetPosition(lx , y)
tokens.append(token)
def to_gforth(self):
while self.get_next_token():
self.convert_symbol()
# constants
if is_ints(self.cur_token):
self.push_stack()
elif is_floats(self.cur_token):
self.f_exists = True
self.push_stack()
elif is_name(self.cur_token):
self.push_stack()
elif is_tf(self.cur_token):
self.push_stack()
elif is_strings(self.cur_token):
self.s_exists = True
temp = 's" ' + self.cur_token.value[1:-1] + '"'
token = Token(self.cur_token.type, temp, self.cur_token.line)
self.push_stack(token)
# type
elif is_type(self.cur_token):
self.push_stack()
# let statment (let (varlist))
elif is_let(self.cur_token):
while len(self.stack) > 0 and is_type(self.stack[len(self.stack)-1][0]):
typ = self.pop_stack()
var = self.pop_stack()
self.varlist.update({var.value:typ.value})
# assign (:= name oper)
elif is_assign(self.cur_token):
num = self.pop_stack()
var = self.pop_stack()
##DEBUG##
# print '===========> Varlist: ',
# print self.varlist.items()
#########
if self.varlist.has_key(var.value):
temp = num.value + ' value ' + var.value
token = Token('Assign', temp, self.cur_token.line)
if self.f_exists:
token.type = 'Assign_f'
self.push_stack(token)
self.assign = True
else:
self.error('Variable ' + var.value + ' not declared')
# print statment
elif is_print(self.cur_token):
temp = self.pop_stack().value
if self.f_exists:
temp += ' f.'
elif self.s_exists:
temp += ' type'
else:
temp += ' .'
token = Token('Printstmt', temp, self.cur_token.line)
self.push_stack(token)
self.stdout = False
# if statment
elif is_if(self.cur_token):
tmp1 = self.pop_stack()
tmp2 = self.pop_stack()
if len(self.stack) > 0:
tmp3 = self.pop_stack()
temp = tmp3.value + ' if ' + tmp2.value + ' else ' + tmp1.value
else:
temp = tmp2.value + ' if ' + tmp1.value
temp += ' endif'
token = Token('Ifstmt', temp, self.cur_token.line)
self.push_stack(token)
self.func_flag = True
# while statment
elif is_while(self.cur_token):
tmp = self.pop_stack()
temp = 'begin ' + tmp.value + ' ' + self.pop_stack().value + ' until'
token = Token('Whilestmt', temp, self.cur_token.line)
self.push_stack(token)
self.func_flag = True
# negate
elif is_negate(self.cur_token):
oper = self.pop_stack().value
if self.f_exists:
temp = oper + ' fnegate'
else:
temp = oper + ' negate'
token = Token('Negateno', temp, self.cur_token.line)
if self.f_exists:
token.type = 'Negateno_f'
self.push_stack(token)
# arithmetic calculation
elif is_binops(self.cur_token):
if self.s_exists and self.cur_token.value == '+':
binop = 's+'
elif self.f_exists and is_pmtd(self.cur_token):
binop = 'f' + self.cur_token.value
elif self.f_exists and is_power(self.cur_token):
binop = 'f**'
elif self.f_exists == False and is_power(self.cur_token):
binop = 'f**'
self.int_power = True
self.f_exists = True
else:
binop = self.cur_token.value
oper1 = self.pop_stack()
oper2 = self.pop_stack()
temp = oper2.value + ' ' + oper1.value + ' ' + binop
if self.int_power == True:
temp += ' f>s'
token = Token('Binops', temp, self.cur_token.line)
if self.f_exists:
token.type = 'Binops_f'
self.push_stack(token)
if self.int_power == True:
self.int_power = False
self.f_exists = False
# not | sin | cos | tan
elif is_unops_2(self.cur_token):
if self.f_exists and self.cur_token.value != 'not':
unop = 'f' + self.cur_token.value
else:
unop = self.cur_token.value
oper = self.pop_stack()
temp = oper.value + ' ' + unop
token = Token('Unops', temp, self.cur_token.line)
if self.f_exists:
token.type = 'Unops_f'
self.push_stack(token)
# other
elif self.cur_token.type == 'Left_Parenthesis':
self.scope += 1
elif self.cur_token.type == 'Right_Parenthesis':
self.scope -= 1
else:
self.error(self.cur_token.value)
# if len(self.varlist) != 0:
# self.output += self.declare_var()
if self.func_flag == True:
self.output += ': func '
if self.assign == True:
self.stack.reverse()
while self.stack:
self.output += self.pop_stack().value + ' '
if self.func_flag == True:
self.output += '; func '
def next_token(self):
found = False
tok = Token()
if self.eof():
tok.value=None
return tok
while not found:
if (not self.buffered) or (self.current_char == ' ') or (self.current_char == '\n'):
self.current_char = self.source_text[self.index]
self.index += 1
self.log("Current char: "+self.current_char+", EOF Status: "
+str(self.index == len(self.source_text)), self.L_DEBUG)
self.current_read = self.character_look_up(self.current_char)
# Stats
cur_stats = "Current state: "+str(self.state)+", "
cur_stats += "current_char: "+str(self.current_char)+", "
cur_stats += "current_read: "+str(self.current_read)+", "
cur_stats += "token status: "+str(self.token_under_construction)
self.log(cur_stats, self.L_DEBUG)
# Adding to token
if ((self.next_state(self.state, self.current_read) != -1) and
(self.action(self.state, self.current_read) == CONTINUE)):
self.buffered = False
self.token_under_construction += self.current_char
self.state = self.next_state(self.state, self.current_read)
# Halting
elif ((self.next_state(self.state, self.current_read) == -1) and
(self.action(self.state, self.current_read) == HALT)):
look_up = self.look_up(self.state, self.current_read)
self.log("Inside switch with state "+str(self.state), self.L_DEBUG)
self.log("The look-up value is "+str(look_up), self.L_DEBUG)
self.log("We have a buffered char of '"+self.current_char+"'", self.L_DEBUG)
self.buffered = True
self.log_token(self.token_look_up(look_up))
tok.type = int(look_up)
tok.value = self.token_under_construction
# Return to S0
self.state = 0
# Reset token
self.token_under_construction = ""
found = True
# Syntax Error
elif ((self.next_state(self.state, self.current_read) == -1) and
(self.action(self.state, self.current_read) == ERROR) and
(self.current_read != 30) and (self.current_read != 31)):
self.log("Illegal character '"+self.current_char+"'", self.L_ERROR)
raise SyntaxError("Illegal character '"+self.current_char+"'")
# End while
return tok
def read():
temp = lexer.read()
token = Token(temp[0])
token.content = temp[1]
return token
from token import Token
from guesser import Guesser
#init
guesser = Guesser()
token = Token()
for times in range(1):
guesser.reset()
token.getNewToken()
token.printToken()
guessCount = 0
while token.status == 'ALIVE':
guess = guesser.makeGuess(token.state)
print 'Guess: ' + guess
token.guess (guess)
token.printToken()
guessCount += 1
print 'Total guesses: ' + str(guessCount)
print '+'*60
def found(tokenToCheck): if Token.equalType(token, tokenToCheck): return True return False
def __init__(self, receiver, size):
Token.__init__(self, receiver)
self.size = size
