Beispiel #1
0
    def add_text_atomic(self, expression):
        """

        :param expression:
        :return:
        """
        temp = expression.replace("(", " ")
        temp = temp.replace(")", " ")
        temp = cleaning.strip_white_space(temp)
        temp = temp.replace("`", "")
        args = temp.split(",")
        return_type = ""
        func_name = ""
        # Find the return type
        for arg in args:
            if arg in self.sorts.keys():
                return_type = arg
                args.remove(arg)
                break
        # Find the function name
        for arg in args:
            if arg not in self.sorts.keys():
                func_name = arg
                args.remove(arg)
                break
        return self.add_code_atomic(func_name, return_type)
Beispiel #2
0
def tokenize_random_dcec(expression, namespace=None):
    """
    This function creates a token representation of a random DCEC statement.
    It returns the token as well as sorts of new atomics and functions.
    """
    # Default DCEC Functions
    if namespace is None:
        namespace = prototypes.Namespace()
        namespace.add_basic_dcec()
    else:
        namespace = namespace
    # Remove Comments
    temp = remove_comments(expression)
    # Check for an empty string
    if temp == "()":
        return "", {}, {}, {}
    # Check for a parentheses mismatch error
    if not cleaning.check_parens(expression):
        print("ERROR: parentheses mismatch error.")
        return False, False, False, False
    # Make symbols into functions
    temp = functorize_symbols(temp)
    # Strip comments
    temp = cleaning.strip_comments(temp)
    # Strip whitespace so you can do the rest of the parsing
    temp = cleaning.strip_white_space(temp)
    # Tuck the functions inside thier parentheses
    temp = cleaning.tuck_functions(temp)
    # Strip whitespace again
    temp = cleaning.strip_white_space(temp)
    # Consolidate Parentheses
    temp = cleaning.consolidate_parens(temp)
    quantifiers = []
    # These are the tokens that should be added to the namespace
    add_atomics = {}
    add_functions = {}
    add_quants = {}
    return_token = token_tree(temp, namespace, quantifiers, add_quants,
                              add_atomics, add_functions)
    # check for errors that occur in the lower level
    if isinstance(return_token, bool) and return_token is False:
        return False, False, False, False
    # Add quantifiers to the TokenTree
    return_token = tokenize_quantifiers(return_token, quantifiers)
    return return_token, add_quants, add_atomics, add_functions
Beispiel #3
0
    def add_text_sort(self, expression):
        """

        :param expression:
        :return:
        """
        temp = expression.replace("(", " ")
        temp = temp.replace(")", " ")
        temp = cleaning.strip_white_space(temp)
        temp = temp.replace("`", "")
        args = temp.split(",")
        if len(args) == 2:
            self.add_code_sort(args[1])
        elif len(args) > 2:
            self.add_code_sort(args[1], args[2:])
        else:
            print("ERROR: Cannot define the sort")
            return False
Beispiel #4
0
    def add_text_function(self, expression):
        """

        :param expression:
        :return:
        """
        temp = expression.replace("(", " ")
        temp = temp.replace(")", " ")
        temp = cleaning.strip_white_space(temp)
        temp = temp.replace("`", "")
        args = temp.split(",")
        if args[0].lower() == "typedef":
            return self.add_text_sort(expression)
        elif len(args) == 2:
            return self.add_text_atomic(expression)
        return_type = ""
        func_name = ""
        func_args = []
        # Find the return type
        if args[0] in self.sorts.keys():
            return_type = args[0]
            args.remove(args[0])
        # Find the function name
        for arg in args:
            if arg not in self.sorts.keys():
                func_name = arg
                args.remove(arg)
                break
        # Find the function args
        for arg in args:
            if arg in self.sorts.keys():
                func_args.append(arg)
        # Error Checking
        if return_type == "" or func_name == "" or func_args == []:
            print("ERROR: The function prototype was not formatted correctly.")
            return False
        # Add the function
        return self.add_code_function(func_name, return_type, func_args)
Beispiel #5
0
if __name__ == "__main__":
    import doctest
    doctest.testmod()

    # pylint: disable=invalid-name
    inputin = input("Enter an expression: ")
    # Make symbols into functions
    inputin = remove_comments(inputin)
    print(inputin)
    inputin = functorize_symbols(inputin)
    print(inputin)
    # Strip comments
    inputin = cleaning.strip_comments(inputin)
    print(inputin)
    # Strip whitespace so you can do the rest of the parsing
    inputin = cleaning.strip_white_space(inputin)
    print(inputin)
    # Tuck the functions inside thier parentheses
    inputin = cleaning.tuck_functions(inputin)
    print(inputin)
    # Consolidate Parentheses
    inputin = cleaning.consolidate_parens(inputin)
    print(inputin)
    test_namespace = prototypes.Namespace()
    test_namespace.add_basic_dcec()
    test_namespace.add_basic_numerics()
    test_namespace.add_basic_logic()
    test_namespace.add_text_function("ActionType heal Agent")
    # testNAMESPACE.addTextFunction("Boolean B Agent Moment Boolean Certainty")
    add_quant = {}
    add_atomic = {}