// Parse English sentence and try and convert it into propositional logic
static String ParseEnglish(const String& input)
{
std::cout << input << std::endl;
EnglishTokenizer tokenizer;
tokenizer.AddEndChars(";");
tokenizer.AddKeyword("and");
tokenizer.AddKeyword("or");
tokenizer.AddKeyword("not");
tokenizer.AddKeyword("then");
tokenizer.LoadNouns("res/nounlist.txt");
tokenizer.LoadAdjectives("res/adjectives.txt");
tokenizer.AddWhitespaceChars(" \n\r\t");
tokenizer.SetString(input);
Statement* statement = new Statement();
EnglishToken token;
String string;
while (tokenizer.Next(token))
{
switch (token.type)
{
case EnglishToken::Type::IDENTIFIER:
statement->identifiers.push_back(token.token);
string += token.token + " ";
break;
case EnglishToken::Type::OPERATOR:
statement->operators.push_back(ParseEnglishOperator(token.token));
Operator op = ParseEnglishOperator(token.token);
string += OperatorToString(op);
if (op != Operator::NEGATION)
string += " ";
break;
}
}
std::cout << string << std::endl;
delete statement;
return string;
}
const ErrorListRef BinaryExpression::Validate(
const shared_ptr<ExecutionContext> execution_context,
const_shared_ptr<TypeSpecifier> valid_left,
const_shared_ptr<TypeSpecifier> valid_right) const {
ErrorListRef errors = ErrorList::GetTerminator();
const OperatorType op = GetOperator();
auto left = GetLeft();
auto left_errors = left->Validate(execution_context);
if (ErrorList::IsTerminator(left_errors)) {
auto left_type_specifier_result = left->GetTypeSpecifier(
execution_context);
auto left_type_specifier_errors =
left_type_specifier_result.GetErrors();
if (ErrorList::IsTerminator(left_type_specifier_errors)) {
auto left_type_specifier = left_type_specifier_result.GetData();
auto left_analysis = left_type_specifier->AnalyzeAssignmentTo(
valid_left, execution_context->GetTypeTable());
if (left_analysis != EQUIVALENT && left_analysis != UNAMBIGUOUS) {
errors = ErrorList::From(
make_shared<Error>(Error::SEMANTIC,
Error::INVALID_LEFT_OPERAND_TYPE,
left->GetLocation().begin,
OperatorToString(op)), errors);
}
} else {
errors = ErrorList::Concatenate(errors, left_type_specifier_errors);
}
} else {
errors = ErrorList::Concatenate(errors, left_errors);
}
auto right = GetRight();
auto right_errors = right->Validate(execution_context);
if (ErrorList::IsTerminator(right_errors)) {
auto right_type_specifier_result = GetRight()->GetTypeSpecifier(
execution_context);
auto right_type_specifier_errors =
right_type_specifier_result.GetErrors();
if (ErrorList::IsTerminator(right_type_specifier_errors)) {
auto right_type_specifier = right_type_specifier_result.GetData();
auto right_analysis = right_type_specifier->AnalyzeAssignmentTo(
valid_right, execution_context->GetTypeTable());
if (right_analysis != EQUIVALENT && right_analysis != UNAMBIGUOUS) {
errors = ErrorList::From(
make_shared<Error>(Error::SEMANTIC,
Error::INVALID_RIGHT_OPERAND_TYPE,
right->GetLocation().begin,
OperatorToString(op)), errors);
}
} else {
errors = ErrorList::Concatenate(errors,
right_type_specifier_errors);
}
} else {
errors = ErrorList::Concatenate(errors, right_errors);
}
return errors;
}
