Example #1
0
def string(self, parent, cur):
    """
Verbatim string

Args:
    self (Builder): Code constructor
    parent (Node): Parent node
    start (int): Current position in code

Returns:
	int : End of string

Example:
    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "'abc'")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  "'abc'"
       0     String  misc.string          "'abc'"
    >>> builder.configure()
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1 1Block      code_block   TYPE
    1 1| Statement  code_block   TYPE
    1 1| | String     string       string
    """

    end = findend.string(self, cur)

    if "\n" in self.code[cur:end]:
        self.syntaxerror(cur, "no line-feed character in string")

    mc.collection.String(parent,
                         self.code[cur + 1:end],
                         cur=cur,
                         code=self.code[cur:end + 1])

    if self.disp:
        print "%4d     String " % cur,
        print "%-20s" % "misc.string",
        print repr(self.code[cur:end + 1])

    return end
Example #2
0
def string(self, parent, cur):
    """
Verbatim string

Args:
    self (Builder): Code constructor
    parent (Node): Parent node
    start (int): Current position in code

Returns:
	int : End of string

Example:
    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "'abc'")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  "'abc'"
       0     String  misc.string          "'abc'"
    >>> builder.configure()
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1 1Block      code_block   TYPE
    1 1| Statement  code_block   TYPE
    1 1| | String     string       string
    """

    end = findend.string(self, cur)

    if  "\n" in self.code[cur:end]:
        self.syntaxerror(cur, "no line-feed character in string")

    mc.collection.String(parent, self.code[cur+1:end], cur=cur,
            code=self.code[cur:end+1])

    if self.disp:
        print "%4d     String " % cur,
        print "%-20s" % "misc.string",
        print repr(self.code[cur:end+1])

    return end
Example #3
0
def create(self, node, start, end=None, start_opr=None):
    """
Create expression in three steps:

    1) In order, split into sub-expressions for each dividing operator
    2) Address prefixes, postfixes, parenthesises, etc.
    3) Identify the remaining singleton

Args:
    self (Builder): Code constructor.
    node (Node): Reference to the parent node
    start (int): current possition in code
    end (int, optional): end of expression. Required for space-delimited expression.
    start_opr (str, optional): At which operator the recursive process is. (For internal use)

Returns:
	int : index to end of the expression

Examples::

    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "a*b+c/d")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  'a*b+c/d'
       0     Expression  expression.create    'a*b+c/d'
       0     Expression  expression.create    'a*b'
       0     Expression  expression.create    'a'
       0     Var         variables.variable   'a'
       2     Expression  expression.create    'b'
       2     Var         variables.variable   'b'
       4     Expression  expression.create    'c/d'
       4     Expression  expression.create    'c'
       4     Var         variables.variable   'c'
       6     Expression  expression.create    'd'
       6     Var         variables.variable   'd'
    >>> builder.configure(suggest=False)
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1 1Block      code_block   TYPE
    1 1| Statement  code_block   TYPE
    1 1| | Plus       expression   TYPE
    1 1| | | Mul        expression   TYPE
    1 1| | | | Var        unknown      TYPE    a
    1 3| | | | Var        unknown      TYPE    b
    1 5| | | Matrixdivisionexpression   TYPE
    1 5| | | | Var        unknown      TYPE    c
    1 7| | | | Var        unknown      TYPE    d
    """

    if self.code[start:start + 3] == "...":
        start = findend.dots(self, start)
        start += 1
        while self.code[start] in " \t":
            start += 1

    if self.code[start] == ":":

        if self.disp:

            print "%4d     Expression " % (start),
            print "%-20s" % "expression.create",
            print repr(self.code[start:start + 1])

            print "%4d     All        " % (start),
            print "%-20s" % "expression.create",
            print repr(self.code[start:start + 1])

        mc.collection.All(node, cur=start, code=self.code[start])
        return start

    if end is None:
        end = findend.expression(self, start)

    if self.disp:
        print "%4d     Expression " % (start),
        print "%-20s" % "expression.create",
        print repr(self.code[start:end + 1])

    if self.code[start] not in c.e_start:
        self.syntaxerror(start, "expression start")

    operators = [
        "||", "&&", "|", "&", "~=", "==", ">=", ">", "<=", "<", ":", "+", "-",
        ".*", "*", "./", "/", ".\\", "\\", ".^", "^"
    ]

    if not (start_opr is None):
        operators = operators[operators.index(start_opr) + 1:]

    for opr in operators:
        # Pre-screen
        if opr not in self.code[start:end + 1]:
            continue

        starts = [start]
        last = start
        ends = []

        k = start
        while True:

            if self.code[k] == "(":
                k = last = findend.paren(self, k)

            elif self.code[k] == "[":
                k = last = findend.matrix(self, k)

            elif self.code[k] == "{":
                k = last = findend.cell(self, k)

            elif self.code[k] == "'":
                if identify.string(self, k):
                    k = last = findend.string(self, k)
                else:
                    last = k

            elif opr == self.code[k:k + len(opr)]:

                if opr in "+-":
                    # no prefixes and no (scientific) numbers
                    if self.code[last] not in c.letters+c.digits+")]}" or\
                            self.code[k-1] in "dDeE" and self.code[k-2] in\
                            c.digits+"." and self.code[k+1] in c.digits:
                        k += 1
                        continue

                k += len(opr) - 1
                while self.code[k + 1] in " \t":
                    k += 1

                # no all-operator
                if opr == ":" and self.code[k + 1] in ",;\n)]}":
                    k += 1
                    continue

                starts.append(k + 1)
                ends.append(last)

            elif self.code[k] in c.letters + c.digits + "_":
                last = k

            k += 1
            if k >= end:
                ends.append(end)
                break

        if len(ends) > 1:

            node = retrieve_operator(self, opr)(node)
            node.cur = start
            node.code = self.code[starts[0]:ends[-1] + 1]

            for s, e in zip(starts, ends):
                create(self, node, s, e, opr)

            return end

    # All operators removed at this point!

    END = end

    # Prefixes
    while self.code[start] in "-~":

        if self.code[start] == "-":

            node = mc.collection.Neg(node,
                                     cur=start,
                                     code=self.code[start:end + 1])
            start += 1

        if self.code[start] == "~":

            node = mc.collection.Not(node,
                                     cur=start,
                                     code=self.code[start:end + 1])
            start += 1

        while self.code[start] in " \t":
            start += 1

    # Postfixes
    if self.code[end] == "'" and not self.code[start] == "'":
        if self.code[end - 1] == ".":
            node = mc.collection.Transpose(node,
                                           cur=start,
                                           code=self.code[start:end + 1])
            end -= 2
        else:
            node = mc.collection.Ctranspose(node,
                                            cur=start,
                                            code=self.code[start:end + 1])
            node.cur = start
            node.code = self.code[start:end + 1]
            end -= 1

        while self.code[end] in " \t":
            end -= 1

    # Parenthesis
    if self.code[start] == "(":
        if self.code[end] != ")":
            self.syntaxerror(end, "parenthesis end")

        node = mc.collection.Paren(node,
                                   cur=start,
                                   code=self.code[start:end + 1])

        start += 1
        while self.code[start] in " \t":
            start += 1

        end -= 1
        while self.code[end] in " \t":
            end -= 1

        return create(self, node, start, end)

    # Reserved keywords
    elif self.code[start:start +
                   3] == "end" and self.code[start + 3] in " +-:\t" + c.e_end:
        node = mc.collection.End(node,
                                 cur=start,
                                 code=self.code[start:start + 3])

    elif self.code[start:start + 6] == "return" and self.code[start +
                                                              6] in " ,;\n":
        node = mc.collection.Return(node,
                                    cur=start,
                                    code=self.code[start:start + 6])

    elif self.code[start:start + 5] == "break" and self.code[start +
                                                             5] in " ,;\n":
        node = mc.collection.Break(node,
                                   cur=start,
                                   code=self.code[start:start + 5])

    # Rest
    elif self.code[start] == "'":
        if self.code[end] != "'":
            self.syntaxerror(end, "string end")

        if "\n" in self.code[start:end]:
            self.syntaxerror(end, "non line-feed characters in string")

        mc.collection.String(node,
                             self.code[start + 1:end],
                             cur=start,
                             code=self.code[start:end + 1])

    elif self.code[start] in c.digits or\
            self.code[start] == "." and self.code[start+1] in c.digits:
        cur = self.create_number(node, start)

    elif self.code[start] == "[":
        cur = self.create_matrix(node, start)

    elif self.code[start] == "{":
        cur = self.create_cell(node, start)

    else:
        if self.code[start] not in c.letters + "@":
            self.syntaxerror(start, "variable name")

        cur = self.create_variable(node, start)

    return END
Example #4
0
def codeblock(self, parent, start):
    '''
If-ifelse-else branch

Args:
    self (Builder): Code constructor
    parent (Node): Parent node
    cur (int): Current position in code

Returns:
	int: Index to end of codeblock

Example:
    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "a; 'b'; 3")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  'a'
       0     Expression  expression.create    'a'
       0     Var         variables.variable   'a'
       3   Statement     codeblock.codeblock  "'b'"
       3     String  misc.string          "'b'"
       8   Statement     codeblock.codeblock  '3'
       8     Expression  expression.create    '3'
       8     Int         misc.number          '3'
    >>> builder.configure()
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1  1Block      code_block   TYPE
    1  1| Statement  code_block   TYPE
    1  1| | Var        unknown      TYPE    a
    1  4| Statement  code_block   TYPE
    1  4| | String     string       string
    1  9| Statement  code_block   TYPE
    1  9| | Int        int          int
    '''

    cur = start
    block = mc.collection.Block(parent, cur=cur)

    if self.disp:
        print "%4d Codeblock  " % cur,
        print "%-20s" % "codeblock.codeblock"

    while True:

        if self.code[cur] in " \t;":
            pass

        elif self.code[cur] == "\n":
            if len(self.code)-cur < 3:
                break

        #%%PARFOR token
        elif self.code[cur:cur+8] == "%%PARFOR":
            cur = self.create_pragma_parfor(block, cur)
            
        elif self.code[cur] == "%":
            cur = self.create_comment(block, cur)

        elif self.code[cur:cur+3] == "___":
            cur = self.create_verbatim(block, cur)

        elif self.code[cur] == "[":

            # Divide between statement and assignment
            eq_loc = findend.matrix(self, cur)+1

            while self.code[eq_loc] in " \t":
                eq_loc += 1

            if self.code[eq_loc] == "=" and self.code[eq_loc+1] != "=":

                cur = self.create_assigns(block, cur, eq_loc)

            else:

                statement = mc.collection.Statement(block, cur=cur)

                end = findend.expression(self, cur)
                if self.disp:
                    print "%4d   Statement    " % cur,
                    print "%-20s" % "codeblock.codeblock",
                    print repr(self.code[cur:end+1])

                statement.code = self.code[cur:end+1]

                cur = self.create_expression(
                        statement, cur, end=end)


        elif self.code[cur] == "'":

            end = findend.string(self, cur)
            if self.disp:
                print "%4d   Statement    " % cur,
                print "%-20s" % "codeblock.codeblock",
                print repr(self.code[cur:end+1])

            statement = mc.collection.Statement(block, cur=cur,
                    code=self.code[cur:end+1])

            cur = self.create_string(statement, cur)

        elif self.code[cur:cur+4] == "case" and self.code[cur+4] in c.k_end:
            break

        elif self.code[cur:cur+5] == "catch" and self.code[cur+5] in c.k_end:
            break

        elif self.code[cur:cur+3] == "end" and self.code[cur+3] in c.k_end:
            cur += 3
            break

        elif self.code[cur:cur+4] == "else" and self.code[cur+4] in c.k_end:
            break

        elif self.code[cur:cur+6] == "elseif" and self.code[cur+6] in c.k_end:
            break

        elif self.code[cur:cur+6] == "parfor" and self.code[cur+6] in c.k_end:
            cur = self.create_parfor(block, cur)

        elif self.code[cur:cur+3] == "for" and self.code[cur+3] in c.k_end:
            cur = self.create_for(block, cur)

        elif self.code[cur:cur+8] == "function" and\
                self.code[cur+8] in c.k_end + "[":
            cur -= 1
            break

        elif self.code[cur:cur+2] == "if" and self.code[cur+2] in c.k_end:
            cur = self.create_if(block, cur)

        elif self.code[cur:cur+9] == "otherwise" and self.code[cur+9] in c.k_end:
            break

        elif self.code[cur:cur+6] == "switch" and self.code[cur+6] in c.k_end:
            cur = self.create_switch(block, cur)

        elif self.code[cur:cur+3] == "try" and self.code[cur+3] in c.k_end:
            cur = self.create_try(block, cur)

        elif self.code[cur:cur+5] == "while" and self.code[cur+5] in c.k_end:
            cur = self.create_while(block, cur)

        elif self.code[cur:cur+4] == "hold" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur:cur+4] == "grid" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur] in c.e_start:
            j = findend.expression(self, cur)

            j += 1
            while self.code[j] in " \t":
                j += 1
            eq_loc = j

            if self.code[eq_loc] == "=": # and self.code[eq_loc+1] != "=":

                j = eq_loc +1
                while self.code[j] in " \t":
                    j += 1
                if self.code[j] == "@":
                    cur = self.create_lambda_assign(block, cur, eq_loc)
                else:
                    cur = self.create_assign(block, cur, eq_loc)

            else:
                end = findend.expression(self, cur)
                if self.disp:
                    print "%4d   Statement    " % cur,
                    print "%-20s" % "codeblock.codeblock",
                    print repr(self.code[cur:end+1])

                statement = mc.collection.Statement(block, cur=cur,
                        code=self.code[cur:end+1])

                cur = self.create_expression(statement,
                        cur, end=end)

        cur += 1

        if len(self.code)-cur<3:
            break

    block.code = self.code[start:cur+1]
    return cur
Example #5
0
def codeblock(self, parent, start):
    '''
If-ifelse-else branch

Args:
    self (Builder): Code constructor
    parent (Node): Parent node
    cur (int): Current position in code

Returns:
	int: Index to end of codeblock

Example:
    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "a; 'b'; 3")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  'a'
       0     Expression  expression.create    'a'
       0     Var         variables.variable   'a'
       3   Statement     codeblock.codeblock  "'b'"
       3     String  misc.string          "'b'"
       8   Statement     codeblock.codeblock  '3'
       8     Expression  expression.create    '3'
       8     Int         misc.number          '3'
    >>> builder.configure()
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1  1Block      code_block   TYPE
    1  1| Statement  code_block   TYPE
    1  1| | Var        unknown      TYPE    a
    1  4| Statement  code_block   TYPE
    1  4| | String     string       string
    1  9| Statement  code_block   TYPE
    1  9| | Int        int          int
    '''
    cur = start
    block = mc.collection.Block(parent, cur=cur)

    if self.disp:
        print "%4d Codeblock  " % cur,
        print "%-20s" % "codeblock.codeblock"

    is_end_terminated = False

    while True:
        #print self.code[cur:cur+5]
        if self.code[cur] in " \t;":
            pass

        elif self.code[cur] == "\n":
            if len(self.code) - cur < 3:
                break

        #%#PARFOR token
        elif self.code[cur:cur + 8] == "%#PARFOR":
            cur = self.create_pragma_parfor(block, cur)

        elif self.code[cur] == "%":
            cur = self.create_comment(block, cur)

        elif self.code[cur:cur + 3] == "___":
            cur = self.create_verbatim(block, cur)

        elif self.code[cur] == "[":
            # Divide between statement and assignment
            eq_loc = findend.matrix(self, cur) + 1

            while self.code[eq_loc] in " \t":
                eq_loc += 1

            if self.code[eq_loc] == "=" and self.code[eq_loc + 1] != "=":
                cur = self.create_assigns(block, cur, eq_loc)

            else:
                statement = mc.collection.Statement(block, cur=cur)

                end = findend.expression(self, cur)
                if self.disp:
                    print "%4d   Statement    " % cur,
                    print "%-20s" % "codeblock.codeblock",
                    print repr(self.code[cur:end + 1])

                statement.code = self.code[cur:end + 1]

                cur = self.create_expression(statement, cur, end=end)

        elif self.code[cur] == "'":
            end = findend.string(self, cur)
            if self.disp:
                print "%4d   Statement    " % cur,
                print "%-20s" % "codeblock.codeblock",
                print repr(self.code[cur:end + 1])

            statement = mc.collection.Statement(block,
                                                cur=cur,
                                                code=self.code[cur:end + 1])

            cur = self.create_string(statement, cur)

        elif self.code[cur:cur + 4] == "case" and self.code[cur +
                                                            4] in c.k_end:
            break

        elif self.code[cur:cur + 5] == "catch" and self.code[cur +
                                                             5] in c.k_end:
            break

        elif self.code[cur:cur + 3] == "end" and self.code[cur + 3] in c.k_end:
            cur += 3
            is_end_terminated = True
            break

        elif self.code[cur:cur + 4] == "else" and self.code[cur +
                                                            4] in c.k_end:
            break

        elif self.code[cur:cur + 6] == "elseif" and self.code[cur +
                                                              6] in c.k_end:
            break

        elif self.code[cur:cur + 6] == "parfor" and self.code[cur +
                                                              6] in c.k_end:
            cur = self.create_parfor(block, cur)

        elif self.code[cur:cur + 3] == "for" and self.code[cur + 3] in c.k_end:
            cur = self.create_for(block, cur)

        elif self.code[cur:cur+8] == "function" and\
                self.code[cur+8] in c.k_end + "[":
            cur -= 1
            break

        elif self.code[cur:cur + 2] == "if" and self.code[cur + 2] in c.k_end:
            cur = self.create_if(block, cur)

        elif self.code[cur:cur + 9] == "otherwise" and self.code[cur +
                                                                 9] in c.k_end:
            break

        elif self.code[cur:cur + 6] == "switch" and self.code[cur +
                                                              6] in c.k_end:
            cur = self.create_switch(block, cur)

        elif self.code[cur:cur + 3] == "try" and self.code[cur + 3] in c.k_end:
            cur = self.create_try(block, cur)

        elif self.code[cur:cur + 5] == "while" and self.code[cur +
                                                             5] in c.k_end:
            cur = self.create_while(block, cur)

        elif self.code[cur:cur+4] == "hold" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur:cur+4] == "load" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur:cur+4] == "disp" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur:cur+4] == "grid" and \
            self.code[cur+4] not in c.letters+c.digits+"_":
            cur = self.create_reserved(block, cur)

        elif self.code[cur] in c.e_start:
            j = findend.expression(self, cur)

            j += 1
            while self.code[j] in " \t":
                j += 1
            eq_loc = j

            if self.code[eq_loc] == "=":  # and self.code[eq_loc+1] != "=":

                j = eq_loc + 1
                while self.code[j] in " \t":
                    j += 1
                if self.code[j] == "@":
                    cur = self.create_lambda_assign(block, cur, eq_loc)
                else:
                    cur = self.create_assign(block, cur, eq_loc)

            else:
                end = findend.expression(self, cur)
                if self.disp:
                    print "%4d   Statement    " % cur,
                    print "%-20s" % "codeblock.codeblock",
                    print repr(self.code[cur:end + 1])

                statement = mc.collection.Statement(block,
                                                    cur=cur,
                                                    code=self.code[cur:end +
                                                                   1])

                cur = self.create_expression(statement, cur, end=end)

        cur += 1

        if len(self.code) - cur < 3:
            break
    block.is_end_terminated = is_end_terminated
    block.code = self.code[start:cur + 1]
    return cur
Example #6
0
def space_delimited(self, start):
    """
Check if list is space-delimited

Args:
    self (Builder): Code constructor
    start (int): Current position in code

Returns:
	bool: True if list consists of whitespace delimiters
    """

    if self.code[start] not in c.l_start:
        self.syntaxerror(start, "list start")

    k = start + 1
    while self.code[k] in " \t":
        k += 1

    if self.code[k] in c.l_end:
        return False

    if self.code[k] not in c.e_start:
        self.syntaxerror(k, "expression start")

    if self.code[k] == "'":
        k = findend.string(self, k) + 1

        while self.code[k] in " \t":
            k += 1

    while True:

        if self.code[k] == "(":
            k = findend.paren(self, k)

        elif self.code[k] == "[":
            k = findend.matrix(self, k)

        elif self.code[k] == "{":
            k = findend.cell(self, k)

        elif self.code[k] == "'":
            # if self.code[k-1] in c.s_start:
            return True

        elif self.code[k : k + 3] == "...":
            k = findend.dots(self, k)

        elif self.code[k] in " \t":
            if space_delimiter(self, k):
                return True
            while self.code[k + 1] in " \t":
                k += 1

        elif self.code[k] in c.e_end:
            if self.code[k] == ",":
                return False
            elif self.code[k] in c.l_end:
                return False
            elif self.code[k] != ";":
                return True

            while self.code[k + 1] in " \t":
                k += 1

        elif self.code[k + 1] in c.letters + c.digits + "_@":
            while self.code[k + 1] in c.letters + c.digits + "_@":
                k += 1
        k += 1
Example #7
0
def create(self, node, start, end=None, start_opr=None):
    """
Create expression in three steps:

    1) In order, split into sub-expressions for each dividing operator
    2) Address prefixes, postfixes, parenthesises, etc.
    3) Identify the remaining singleton

Args:
    self (Builder): Code constructor.
    node (Node): Reference to the parent node
    start (int): current possition in code
    end (int, optional): end of expression. Required for space-delimited expression.
    start_opr (str, optional): At which operator the recursive process is. (For internal use)

Returns:
	int : index to end of the expression

Examples::

    >>> builder = mc.Builder(True)
    >>> builder.load("unnamed", "a*b+c/d")
    loading unnamed
         Program     functions.program
       0 Main        functions.main
       0 Codeblock   codeblock.codeblock 
       0   Statement     codeblock.codeblock  'a*b+c/d'
       0     Expression  expression.create    'a*b+c/d'
       0     Expression  expression.create    'a*b'
       0     Expression  expression.create    'a'
       0     Var         variables.variable   'a'
       2     Expression  expression.create    'b'
       2     Var         variables.variable   'b'
       4     Expression  expression.create    'c/d'
       4     Expression  expression.create    'c'
       4     Var         variables.variable   'c'
       6     Expression  expression.create    'd'
       6     Var         variables.variable   'd'
    >>> builder.configure(suggest=False)
    >>> print mc.qtree(builder, core=True) # doctest: +NORMALIZE_WHITESPACE
    1 1Block      code_block   TYPE
    1 1| Statement  code_block   TYPE
    1 1| | Plus       expression   TYPE
    1 1| | | Mul        expression   TYPE
    1 1| | | | Var        unknown      TYPE    a
    1 3| | | | Var        unknown      TYPE    b
    1 5| | | Matrixdivisionexpression   TYPE
    1 5| | | | Var        unknown      TYPE    c
    1 7| | | | Var        unknown      TYPE    d
    """

    if self.code[start:start+3] == "...":
        start = findend.dots(self, start)
        start += 1
        while self.code[start] in " \t":
            start += 1

    if self.code[start] == ":":

        if self.disp:

            print "%4d     Expression " % (start),
            print "%-20s" % "expression.create",
            print repr(self.code[start:start+1])

            print "%4d     All        " % (start),
            print "%-20s" % "expression.create",
            print repr(self.code[start:start+1])

        mc.collection.All(node, cur=start, code=self.code[start])
        return start

    if end is None:
        end = findend.expression(self, start)

    if self.disp:
        print "%4d     Expression " % (start),
        print "%-20s" % "expression.create",
        print repr(self.code[start:end+1])

    if  self.code[start] not in c.e_start:
        self.syntaxerror(start, "expression start")


    operators = [
        "||", "&&", "|", "&",
        "~=", "==", ">=", ">", "<=", "<",
        ":", "+", "-",
        ".*", "*", "./", "/", ".\\", "\\",
        ".^", "^"]

    if not (start_opr is None):
        operators = operators[operators.index(start_opr)+1:]

    for opr in operators:
        # Pre-screen
        if opr not in self.code[start:end+1]:
            continue

        starts = [start]
        last = start
        ends = []

        k = start
        while True:

            if self.code[k] == "(":
                k = last = findend.paren(self, k)

            elif self.code[k] == "[":
                k = last = findend.matrix(self, k)

            elif self.code[k] == "{":
                k = last = findend.cell(self, k)

            elif self.code[k] == "'":
                if identify.string(self, k):
                    k = last = findend.string(self, k)
                else:
                    last = k

            elif opr == self.code[k:k+len(opr)]:

                if opr in "+-":
                    # no prefixes and no (scientific) numbers
                    if self.code[last] not in c.letters+c.digits+")]}" or\
                            self.code[k-1] in "dDeE" and self.code[k-2] in\
                            c.digits+"." and self.code[k+1] in c.digits:
                        k += 1
                        continue


                k += len(opr)-1
                while self.code[k+1] in " \t":
                    k += 1

                # no all-operator
                if opr == ":" and self.code[k+1] in ",;\n)]}":
                    k += 1
                    continue

                starts.append(k+1)
                ends.append(last)

            elif self.code[k] in c.letters+c.digits+"_":
                last = k

            k += 1
            if k >= end:
                ends.append(end)
                break

        if len(ends)>1:

            node = retrieve_operator(self, opr)(node)
            node.cur = start
            node.code = self.code[starts[0]:ends[-1]+1]

            for s,e in zip(starts, ends):
                create(self, node, s, e, opr)

            return end


    # All operators removed at this point!

    END = end

    # Prefixes
    while self.code[start] in "-~":

        if self.code[start] == "-":

            node = mc.collection.Neg(node, cur=start, code=self.code[start:end+1])
            start += 1

        if self.code[start] == "~":

            node = mc.collection.Not(node, cur=start, code=self.code[start:end+1])
            start += 1

        while self.code[start] in " \t":
            start += 1

    # Postfixes
    if self.code[end] == "'" and not self.code[start] == "'":
        if self.code[end-1] == ".":
            node = mc.collection.Transpose(node, cur=start,
                    code=self.code[start:end+1])
            end -= 2
        else:
            node = mc.collection.Ctranspose(node, cur=start,
                    code=self.code[start:end+1])
            node.cur = start
            node.code = self.code[start:end+1]
            end -= 1

        while self.code[end] in " \t":
            end -= 1

    # Parenthesis
    if self.code[start] == "(":
        if self.code[end] != ")":
            self.syntaxerror(end, "parenthesis end")

        node = mc.collection.Paren(node, cur=start, code=self.code[start:end+1])

        start += 1
        while self.code[start] in " \t":
            start += 1

        end -= 1
        while self.code[end] in " \t":
            end -= 1

        return create(self, node, start, end)

    # Reserved keywords
    elif self.code[start:start+3] == "end": # and self.code[start+3] in " \t" + c.e_end:
        node = mc.collection.End(node, cur=start, code=self.code[start:start+3])

    elif self.code[start:start+6] == "return" and self.code[start+6] in " ,;\n":
        node = mc.collection.Return(node, cur=start, code=self.code[start:start+6])

    elif self.code[start:start+5] == "break" and self.code[start+5] in " ,;\n":
        node = mc.collection.Break(node, cur=start, code=self.code[start:start+5])


    # Rest
    elif self.code[start] == "'":
        if self.code[end] != "'":
            self.syntaxerror(end, "string end")

        if "\n" in self.code[start:end]:
            self.syntaxerror(end, "non line-feed characters in string")

        mc.collection.String(node, self.code[start+1:end], cur=start,
                code=self.code[start:end+1])

    elif self.code[start] in c.digits or\
            self.code[start] == "." and self.code[start+1] in c.digits:
        cur = self.create_number(node, start)

    elif self.code[start] == "[":
        cur = self.create_matrix(node, start)

    elif self.code[start] == "{":
        cur = self.create_cell(node, start)

    else:
        if self.code[start] not in c.letters+"@":
            self.syntaxerror(start, "variable name")

        cur = self.create_variable(node, start)

    return END
Example #8
0
def space_delimited(self, start):
    """
Check if list is space-delimited

Args:
    self (Builder): Code constructor
    start (int): Current position in code

Returns:
	bool: True if list consists of whitespace delimiters
    """

    if self.code[start] not in c.l_start:
        self.syntaxerror(start, "list start")

    k = start + 1
    while self.code[k] in " \t":
        k += 1

    if self.code[k] in c.l_end:
        return False

    if self.code[k] not in c.e_start:
        self.syntaxerror(k, "expression start")

    if self.code[k] == "'":
        k = findend.string(self, k) + 1

        while self.code[k] in " \t":
            k += 1

    while True:

        if self.code[k] == "(":
            k = findend.paren(self, k)

        elif self.code[k] == "[":
            k = findend.matrix(self, k)

        elif self.code[k] == "{":
            k = findend.cell(self, k)

        elif self.code[k] == "'" and string(self, k):
            #k = findend.string(self, k)
            #if self.code[k-1] in c.s_start:
            return True

        elif self.code[k:k + 3] == "...":
            k = findend.dots(self, k)

        elif self.code[k] in " \t":
            if space_delimiter(self, k):
                return True
            while self.code[k + 1] in " \t":
                k += 1

        elif self.code[k] in c.e_end:
            if self.code[k] == ",":
                return False
            elif self.code[k] in c.l_end:
                return False
            elif self.code[k] != ";":
                return True

            while self.code[k + 1] in " \t":
                k += 1

        elif self.code[k + 1] in c.letters + c.digits + "_@":
            while self.code[k + 1] in c.letters + c.digits + "_@":
                k += 1
        k += 1
Example #9
0
def reserved(self, node, start):
    """Reserved keywords
    """

    k = start

    l = k

    while self.code[l] not in ";\n":
        l += 1
    newline = l

    if self.disp:
        print "%4d     reserved       " % k,
        print "%-20s" % "misc.reserved",
        print repr(self.code[k:newline])

    if self.code[k:k+4] == "disp":
        statement = mc.collection.Statement(node, cur=start,
                                            code=self.code[start:newline])

        l = k+4
        while self.code[l] in " \t":
            l += 1

        if self.code[l] == "(":
            return expression.create(self, statement, k)

        k += 4
        while self.code[k] in " \t":
            k += 1

        name = ""
        if self.code[k] == "\'":
            l = findend.string(self, k)
            name = str(self.code[k+1:l])
        else:
            l = k
            while self.code[l] not in " \t\n":
                l += 1
            name = str(self.code[k:l])

        get = mc.collection.Get(statement, name="disp", cur=start, value=self.code[k:l])

        #name = str(self.code[k+1:l])
        node = mc.collection.String(get, name)
        #node.create_declare()

        while self.code[k] not in ";\n":
            k += 1


        return k


    if self.code[k:k+4] == "load":

        statement = mc.collection.Statement(node, cur=start,
                                            code=self.code[start:newline])

        l = k+4
        while self.code[l] in " \t":
            l += 1

        if self.code[l] == "(":
            return expression.create(self, statement, k)

        k += 4
        while self.code[k] in " \t\n'":
            k += 1

        l = k
        while self.code[l] not in " \t\n":
            l += 1

        get = mc.collection.Get(statement, name="load", cur=start, value=self.code[k:l])

        name = str(self.code[k:l]).split(".")[0]
        node = mc.collection.Var(get, name)
        node.create_declare()

        while self.code[k] not in ";\n":
            k += 1


        return k
    
    if self.code[k:k+4] == "hold":

        statement = mc.collection.Statement(node, cur=start,
                                            code=self.code[start:newline])
        
        l = k+4
        while self.code[l] in " \t":
            l += 1
        
        if self.code[l] == "(":
            return expression.create(self, statement, k)

        k += 4
        while self.code[k] in " \t":
            k += 1

        get = mc.collection.Get(statement, name="hold", cur=start)

        if self.code[k:k+2] == "on"  and (self.code[k+2] in c.k_end):
            mc.collection.String(get, "on")
            return k+2
    
        if self.code[k:k+3] == "off"  and (self.code[k+3] in c.k_end):
            mc.collection.String(get, "off")
            return k+3

        if self.code[k:k+3] == "all"  and (self.code[k+3] in c.k_end):
            mc.collection.String(get, "all")
            return k+3

        while self.code[k] not in ";\n":
            k += 1

        return k

    if self.code[k:k+4] == "grid":

        statement = mc.collection.Statement(node, cur=start,
                                            code=self.code[k:newline])
        
        l = k+4
        while self.code[l] in " \t":
            l += 1
            
        if self.code[l] == "(":
            return expression.create(self, statement, k)

        k += 4
        while self.code[k] in " \t":
            k += 1

        get = mc.collection.Get(statement, name="grid", cur=start)

        if self.code[k:k+2] == "on"  and (self.code[k+2] in c.k_end):
            mc.collection.String(get, "on", cur=k)
            return k+2

        if self.code[k:k+3] == "off"  and (self.code[k+3] in c.k_end):
            mc.collection.String(get, "off", cur=k)
            return k+3

        if self.code[k:k+5] == "minor"  and (self.code[k+5] in c.k_end):
            mc.collection.String(get, "minor", cur=k)
            return k+5

        while self.code[k] not in ";\n":
            k += 1

        return k
        
        
    if self.code[k:k+5] == "clear":
        pass