Python FORA.parseStringToExpression方法代码示例

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
 def assertInvalidParse(self, foraExpressionText):
     result = ForaNative.parseStringToExpression(
         foraExpressionText,
         ForaNative.CodeDefinitionPoint.ExternalFromStringList([]),
         ""
         )
     self.assertTrue(isinstance(result, ForaNative.FunctionParseError),
         "'%s' parsed and shouldn't have" % foraExpressionText
         )

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
 def assertValidParse(self, foraExpressionText):
     result = ForaNative.parseStringToExpression(
         foraExpressionText,
         ForaNative.CodeDefinitionPoint.ExternalFromStringList([]),
         ""
         )
     self.assertTrue(isinstance(result, ForaNative.Expression),
         "'%s' didn't parse: %s" % (foraExpressionText, result)
         )

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
    def parse(textToParse, codeDefinitionPoint = None, nameScope = "<eval>", parseAsModule=False):
        """parse a string to an Expression object or throw a FunctionParseError.

        textToParse - a string containing the FORA expression
        parsePath - a list of strings containing the path to the
            code being parsed. this will show up in any stacktraces
            thrown by this expression or by code called by this expression
        nameScope - the name that functions and objects should descend from. If the
            expression is a simple 'fun' or 'object', this will be its name
        """

        if codeDefinitionPoint is None:
            codeDefinitionPoint = \
                ForaNative.CodeDefinitionPoint.ExternalFromStringList(
                    [nameScope]
                    )

        if parseAsModule:
            nativeExpressionOrParseError = \
                ForaNative.parseObjectDefinitionBodyToExpression(
                    textToParse,
                    ["Tsunami", nameScope + ".fora"],
                    False,
                    nameScope,
                    nameScope
                    )
        else:
            nativeExpressionOrParseError = \
                ForaNative.parseStringToExpression(
                    textToParse,
                    codeDefinitionPoint,
                    nameScope
                    )

        if isinstance(nativeExpressionOrParseError, ForaNative.FunctionParseError):
            raise ParseException.ParseException(
                nativeExpressionOrParseError, 
                codeDefinitionPoint
                )

        return Expression(nativeExpressionOrParseError, codeDefinitionPoint)

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
    def parseStringToFunction(self, expr):
        expression = ForaNative.parseStringToExpression(
            expr, emptyCodeDefinitionPoint, "")

        return expression.extractRootLevelCreateFunctionPredicate()

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
 def parse(self, exprStr):
     e = ForaNative.parseStringToExpression(exprStr, emptyCodeDefinitionPoint, "")
     self.assertIsInstance(e, ForaNative.Expression, 'Parse error: ' + str(e))
     return e

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
import ast
import pyfora
import pyfora.pyAst.PyAstUtil as PyAstUtil
import pyfora.TypeDescription as TypeDescription

import ufora.native.FORA as ForaNative

from collections import namedtuple


ImplValObjectAndMemberToObjectIdMap = namedtuple('ImplValObjectAndMemberToObjectIdMap',
                                                 ['implVal', 'memberToObjectIdMap'])
emptyCodeDefinitionPoint = ForaNative.CodeDefinitionPoint.ExternalFromStringList([])
empytObjectExpression = ForaNative.parseStringToExpression(
    "object {}",
    emptyCodeDefinitionPoint,
    ""
    )
Symbol_Call = ForaNative.makeSymbol("Call")
Symbol_CreateInstance = ForaNative.makeSymbol("CreateInstance")
Symbol_unconvertible = ForaNative.makeSymbol("PyforaUnconvertibleValue")


def convertNativePythonToForaConversionError(err, path):
    """Convert a ForaNative.PythonToForaConversionError to a python version of the exception"""
    return pyfora.PythonToForaConversionError(
        err.error,
        trace=[{
            'path': path,
            'line': err.range.start.line
            }]

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
 def parseStringToExpression(self, string):
     return ForaNative.parseStringToExpression(
         string,
         ForaNative.CodeDefinitionPoint(),
         "<eval>"
         )

# 需要导入模块: from ufora.native import FORA [as 别名]
# 或者: from ufora.native.FORA import parseStringToExpression [as 别名]
                            if t not in self.finishedValues_:
                                deps.add(t)
                        self.dependencies_[node] = deps

                if not deps:
                    #we could go again
                    with self.lock_:
                        self.completable_.put(node)
                return


callAndReturnExpr = FORANative.parseStringToExpression(
    """object {
    ...(f, *args) {
        try { (f`(*args), (f, *args), 'callAndReturnExpr') }
        catch from stacktrace (e) {  throw from stacktrace (e, (f, *args)) }
        }
    }""",
    FORANative.CodeDefinitionPoint(),
    "cdp"
    )

callAndReturn = FORANative.evaluateRootLevelCreateObjectExpression(callAndReturnExpr, {}, True)

def areAllArgumentsConst(*args):
    """Returns True if all ImplValContainer arguments in the specified list are const."""
    for arg in args:
        if not arg.isCST():
            return False
    return True

class LocalEvaluator(EvaluatorBase.EvaluatorBase):