#! /usr/bin/python
import sys
def parse_string(token_array):
END = 0; # EOL (end of line) token.
LIT = 1; # Literal token.
PLUS = 2; # Addition operator token.
TIMES = 3; # Multiplication operator token.
# Loop through token array for syntax check.
for i in range(0,len(token_array)):
# If we're on the first token of the line, check to make sure the first token
# is a literal. Lines cannot begin with a PLUS, TIMES, or END, unless the end
# symbol is say...a newline...at which point maybe END should be allowed? For
# now however, it isn't. This is also nice to have as an early escape.
if i == 0:
# If the first token isn't 1 (LIT)...
if locals()[(token_array[i])] != 1:
# ...throw an error at the user (not at the head!)...
print("Error: Line must begin with literal.");
# ...then die badly.
sys.exit(1);
else:
# So that it's delcared, just not AS anything, that comes later.
previous_token = "";
# If this is the final token, and it isn't an END, we die right away and notify
# the user of this error, as well as reporting the final token type.
if locals()[(token_array[len(token_array)-1])] != 0 :
print("Error: This line doesn't appear to end in an END (0). Dying.");
sys.exit(1);
# This will check for consecutive matches or two tokens in a row. This should
# not happen at the moment, as in this example, having two or more consecutive
# matches should be impossible.
#if i > 0 and locals()[(token_array[i])] == previous_token:
# # Notify the user of the impending impossibility...or rather...improbability?
# print("Error: Two consecutive matching tokens. This is, for the moment, impossible.");
# # Die badly.
# sys.exit(1);
# Check if token is END.
if locals()[(token_array[i])] == 0:
# Print if an END is found.
print("Okay: Found END.");
# In most languages, you would continue on a line even if you encounter
# a mid-line END, however for the sake of parsing a single line, lets not
# do that for now.
break;
# Check if token is LIT.
if locals()[(token_array[i])] == 1:
print("Okay: Found LIT.");
# If the previous token was a literal too, then this is disallowed for
# the time being, throw an error because of the consecutive literals.
if locals()[(token_array[i])] == 1 and previous_token == 1:
print("Error: Two literals in a row. Stray space perhaps?");
sys.exit(1);
# Check if token is PLUS.
if locals()[(token_array[i])] == 2:
print("Okay: Found PLUS.");
if previous_token == 1 and locals()[(token_array[i+1])] == 1:
print("Okay: Valid addition between two literals.");
else:
print("Error: Attempt to add tokens of type "+str(previous_token)+" and type "+str(locals()[(token_array[i+1])])+". These are incompatible.");
sys.exit(1);
# Check if token is TIMES.
if locals()[(token_array[i])] == 3:
print("Okay: Found TIMES.");
if previous_token == 1 and locals()[(token_array[i+1])] == 1:
print("Okay: Valid multiplication between two literals.");
else:
print("Error: Attempt to multiply tokens of type "+str(previous_token)+" and type "+str(locals()[(token_array[i+1])])+". These are incompatible.");
sys.exit(1);
# It would be useful to take note of the token after we're done parsing it so
# that we can compare what should be next depending upon the previous token
# so as to catch syntax errors. Token is stored as an integer.
previous_token = locals()[(token_array[i])];
print("Okay: Previous token: "+str(previous_token));
# If you've made it to this point, then that means that no errors of a major kind
# have been caught above, and you're probably safe to start generating trees from
# the given token lines.
print("Okay: All clear.");
return 0;
if __name__ == "__main__":
# An array of correctly ordered strings.
string_correct = ["LIT","PLUS","LIT","TIMES","LIT","END"];
#string_incorrect = ["LIT","PLUS","LIT","TIMES","END"];
#string_incorrect_begin = ["PLUS","LIT","END"];
#string_incorrect_no_end = ["LIT","PLUS","LIT"];
parse_string(string_correct);
#parse_string(string_incorrect);
#parse_string(string_incorrect_begin);
#parse_string(string_incorrect_no_end);