def check_tuples2(): s = "<1g, 5J>" parsed = parse_wrap(Syntax.rvalue, s)[0] context = Context() _ret = eval_rvalue(parsed, context) #print(ret) same("take(<1g, 5J>, 1)", "5 J")
def check_tuples2(): #s = "take(<1g, 5J>, 1)" s = "<1g, 5J>" parsed = parse_wrap(Syntax.rvalue, s)[0] context = Context() ret = eval_rvalue(parsed, context) print(ret) same("take(<1g, 5J>, 1)", "5 J")
def eval_statement_ResShortcut2(r, context): # requires rname >= (rvalue) from mcdp_lang.eval_resources_imp import eval_rvalue if isinstance(r.prep, CDP.geq): msg = 'This is deprecated, and should be "=".' warn_language(r.prep, MCDPWarnings.LANGUAGE_CONSTRUCT_DEPRECATED, msg, context) A = eval_rvalue(r.rvalue, context) check_isinstance(A, CResource) R = context.get_rtype(A) B = add_resource(r.rname.value, R, context, r) # B >= A add_constraint(context, resource=A, function=B)
def eval_statement_ResShortcut2(r, context): # requires rname >= (rvalue) from mcdp_lang.eval_resources_imp import eval_rvalue if isinstance(r.prep, CDP.geq): msg = 'This is deprecated, and should be "=".' warn_language( r.prep, MCDPWarnings.LANGUAGE_CONSTRUCT_DEPRECATED, msg, context) A = eval_rvalue(r.rvalue, context) check_isinstance(A, CResource) R = context.get_rtype(A) B = add_resource(r.rname.value, R, context, r) # B >= A add_constraint(context, resource=A, function=B)
def eval_rvalue_MakeTuple(mt, context): from mcdp_lang.eval_resources_imp import eval_rvalue ops = get_odd_ops(unwrap_list(mt.ops)) resources = [eval_rvalue(_, context) for _ in ops] Fs = [context.get_rtype(_) for _ in resources] F = PosetProduct(tuple(Fs)) # Now it's easy - this corresponds to a simple Mux operation n = len(Fs) coords = list(range(n)) dp = TakeFun(F, coords) return create_operation(context, dp=dp, resources=resources, name_prefix='_make_tuple', op_prefix='_factors', res_prefix='_result')
def eval_statement(r, context): check_isinstance(context, ModelBuildingContext) from .eval_resources_imp import eval_rvalue from .eval_lfunction_imp import eval_lfunction invalid = (CDP.ConstraintInvalidRR, CDP.ConstraintInvalidFF, CDP.ConstraintInvalidSwapped) if isinstance(r, invalid): msg = 'This constraint is invalid. ' if isinstance(r, CDP.ConstraintInvalidRR): msg += 'Both sides are resources.' if isinstance(r, CDP.ConstraintInvalidFF): msg += 'Both sides are functionalities.' if isinstance(r, CDP.ConstraintInvalidSwapped): msg += ('Functionality and resources are on the wrong side ' 'of the inequality.') raise DPSemanticError(msg) if isinstance(r, Connection): context.add_connection(r) elif isinstance(r, CDP.Constraint): resource = eval_rvalue(r.rvalue, context) function = eval_lfunction(r.fvalue, context) try: add_constraint(context, resource, function) except MCDPExceptionWithWhere as e: _, _, tb = sys.exc_info() where = r.prep.where # indicate preposition "<=" raise_with_info(e, where, tb) elif isinstance(r, CDP.VarStatement): P = eval_space(r.unit, context) vnames = get_odd_ops(unwrap_list(r.vnames)) for v in vnames: vname = v.value where = v.where add_variable(vname, P, where, context) elif isinstance(r, CDP.SetNameNDPInstance): name = r.name.value ndp = eval_ndp(r.dp_rvalue, context) context.add_ndp(name, ndp) elif isinstance(r, CDP.SetNameMCDPType): name = r.name.value right_side = r.right_side x = eval_ndp(right_side, context) context.set_var2model(name, x) elif isinstance(r, CDP.SetNameRValue): return eval_statement_SetNameRValue(r, context) elif isinstance(r, CDP.SetNameConstant): return eval_statement_SetNameConstant(r, context) elif isinstance(r, CDP.SetNameFValue): return eval_statement_SetNameFvalue(r,context) elif isinstance(r, CDP.IgnoreFun): # equivalent to f >= any-of(Minimals S) lf = eval_lfunction(r.fvalue, context) F = context.get_ftype(lf) values = F.get_minimal_elements() dp = ConstantMinimals(F, values) ndp = SimpleWrap(dp, fnames=[], rnames='_out') name = context.new_name('_constant') context.add_ndp(name, ndp) r = context.make_resource(name, '_out') add_constraint(context, resource=r, function=lf) elif isinstance(r, CDP.IgnoreRes): # equivalent to r <= any-of(Maximals S) rv = eval_rvalue(r.rvalue, context) R = context.get_rtype(rv) try: values = R.get_maximal_elements() except NotImplementedError as e: # pragma: no cover msg = 'Could not call get_maximal_elements().' raise_wrapped(DPInternalError, e, msg, R=R) dp = LimitMaximals(R, values) ndp = SimpleWrap(dp, fnames='_limit', rnames=[]) name = context.new_name('_limit') context.add_ndp(name, ndp) f = context.make_function(name, '_limit') add_constraint(context, resource=rv, function=f) else: cases = { CDP.ResStatement: eval_statement_ResStatement, CDP.FunStatement: eval_statement_FunStatement, CDP.FunShortcut5: eval_statement_FunShortcut5, CDP.ResShortcut5: eval_statement_ResShortcut5, CDP.ResShortcut4: eval_statement_ResShortcut4, CDP.FunShortcut4: eval_statement_FunShortcut4, CDP.FunShortcut1m: eval_statement_FunShortcut1m, CDP.ResShortcut1m: eval_statement_ResShortcut1m, CDP.FunShortcut2: eval_statement_FunShortcut2, CDP.ResShortcut2: eval_statement_ResShortcut2, CDP.FunShortcut1: eval_statement_FunShortcut1, CDP.ResShortcut1: eval_statement_ResShortcut1, } for klass, hook in cases.items(): if isinstance(r, klass): return hook(r, context) if True: # pragma: no cover msg = 'eval_statement(): cannot interpret.' r2 = recursive_print(r) raise_desc(DPInternalError, msg, r=r2) # where=r.where.__repr__())
def eval_statement_SetNameRValue(r, context): """ This is a special case, because it is the place where the syntax is ambiguous. x = Nat: 1 + r could be interpreted with r being a functionality or a resource. By default it is parsed as SetNameRValue, and so we get here. We check whether it could be parsed as setname_fvalue, and warn about that. """ from .eval_resources_imp import eval_rvalue from .eval_constant_imp import NotConstant from .eval_lfunction_imp import eval_lfunction from .syntax import Syntax check_isinstance(r, CDP.SetNameRValue) # Check to see if this could have been interpreted using # setname_fvalue # Try to have an alternative parsing of the string as # Syntax.setname_fvalue try: w = r.where s = w.string[w.character:w.character_end] alt = parse_wrap(Syntax.setname_fvalue, s)[0] # print('alternative: %s' % recursive_print(alt)) except Exception as _: # XXX: which one? #print "No, it does not parse: %s" % traceback.format_exc(e) alt = None name = r.name.value right_side = r.right_side if name in context.constants: msg = 'Constant %r already set.' % name raise DPSemanticError(msg, where=r.where) if name in context.var2resource: msg = 'Resource %r already set.' % name raise DPSemanticError(msg, where=r.where) if name in context.var2function: msg = 'Name %r already used.' % name raise DPSemanticError(msg, where=r.where) try: x = eval_constant(right_side, context) context.set_constant(name, x) used_constant = True except NotConstant: used_constant = False try: x = eval_rvalue(right_side, context) ndp1 = context.names[x.dp] current = x.s updated = name try: ndp2 = ndp_rename_resource(ndp1, current=current, updated=updated) context.names[x.dp] = ndp2 x = CResource(x.dp, updated) except CouldNotRename: pass context.set_var2resource(name, x) used_rvalue = True except DPSemanticError as e: if 'not declared' in str(e) and alt is not None: # XXX: this seems not to be used anymore # after we implemented the interpretation at the syntax level raise NotImplementedError x = eval_lfunction(alt.right_side, context) context.set_var2function(name, x) used_rvalue = False else: raise if alt is not None: msg = ('This expression could be parsed both as a functionality ' 'and as a resource.') if used_constant: pass # msg += ' I parsed it as a constant.' else: if used_rvalue: msg += ' I parsed it as a resource.' else: msg += ' I parsed it as a function.' warn_language(r, MCDPWarnings.LANGUAGE_AMBIGUOS_EXPRESSION, msg, context)
def eval_statement_SetNameRValue(r, context): """ This is a special case, because it is the place where the syntax is ambiguous. x = Nat: 1 + r could be interpreted with r being a functionality or a resource. By default it is parsed as SetNameRValue, and so we get here. We check whether it could be parsed as setname_fvalue, and warn about that. """ from .eval_resources_imp import eval_rvalue from .eval_constant_imp import NotConstant from .syntax import Syntax check_isinstance(r, CDP.SetNameRValue) # Check to see if this could have been interpreted using # setname_fvalue # Try to have an alternative parsing of the string as # Syntax.setname_fvalue try: w = r.where s = w.string[w.character:w.character_end] alt = parse_wrap(Syntax.setname_fvalue, s)[0] # print('alternative: %s' % recursive_print(alt)) except Exception as _: # XXX: which one? # print "No, it does not parse: %s" % traceback.format_exc(e) alt = None name = r.name.value right_side = r.right_side if name in context.constants: msg = 'Constant %r already set.' % name raise DPSemanticError(msg, where=r.where) if name in context.var2resource: msg = 'Resource %r already set.' % name raise DPSemanticError(msg, where=r.where) if name in context.var2function: msg = 'Name %r already used.' % name raise DPSemanticError(msg, where=r.where) try: x = eval_constant(right_side, context) context.set_constant(name, x) used_constant = True except NotConstant: used_constant = False try: x = eval_rvalue(right_side, context) ndp1 = context.names[x.dp] current = x.s updated = name try: ndp2 = ndp_rename_resource( ndp1, current=current, updated=updated) context.names[x.dp] = ndp2 x = CResource(x.dp, updated) except CouldNotRename: pass context.set_var2resource(name, x) used_rvalue = True except DPSemanticError: # as e: # if 'not declared' in str(e) and alt is not None: # # XXX: this seems not to be used anymore # # after we implemented the interpretation at the syntax level # msg = 'This should not happen...' # raise_wrapped(DPNotImplementedError, e, msg) # x = eval_lfunction(alt.right_side, context) # context.set_var2function(name, x) # used_rvalue = False # else: raise if alt is not None: msg = ('This expression could be parsed both as a functionality ' 'and as a resource.') if used_constant: pass # msg += ' I parsed it as a constant.' else: if used_rvalue: msg += ' I parsed it as a resource.' else: msg += ' I parsed it as a function.' warn_language(r, MCDPWarnings.LANGUAGE_AMBIGUOS_EXPRESSION, msg, context)
def eval_statement(r, context): check_isinstance(context, ModelBuildingContext) from .eval_resources_imp import eval_rvalue from .eval_lfunction_imp import eval_lfunction invalid = (CDP.ConstraintInvalidRR, CDP.ConstraintInvalidFF, CDP.ConstraintInvalidSwapped) if isinstance(r, invalid): msg = 'This constraint is invalid. ' if isinstance(r, CDP.ConstraintInvalidRR): msg += 'Both sides are resources.' if isinstance(r, CDP.ConstraintInvalidFF): msg += 'Both sides are functionalities.' if isinstance(r, CDP.ConstraintInvalidSwapped): msg += ('Functionality and resources are on the wrong side ' 'of the inequality.') raise DPSemanticError(msg) if isinstance(r, Connection): context.add_connection(r) elif isinstance(r, CDP.Constraint): resource = eval_rvalue(r.rvalue, context) function = eval_lfunction(r.fvalue, context) try: add_constraint(context, resource, function) except MCDPExceptionWithWhere as e: _, _, tb = sys.exc_info() where = r.prep.where # indicate preposition "<=" raise_with_info(e, where, tb) elif isinstance(r, CDP.VarStatement): P = eval_space(r.unit, context) vnames = get_odd_ops(unwrap_list(r.vnames)) for v in vnames: vname = v.value where = v.where add_variable(vname, P, where, context) elif isinstance(r, CDP.SetNameNDPInstance): name = r.name.value ndp = eval_ndp(r.dp_rvalue, context) if name in context.names: msg = 'Repeated identifier "%s".' % name raise DPSemanticError(msg, where=r.name.where) context.add_ndp(name, ndp) elif isinstance(r, CDP.SetNameMCDPType): name = r.name.value right_side = r.right_side x = eval_ndp(right_side, context) context.set_var2model(name, x) elif isinstance(r, CDP.SetNameRValue): return eval_statement_SetNameRValue(r, context) elif isinstance(r, CDP.SetNameConstant): return eval_statement_SetNameConstant(r, context) elif isinstance(r, CDP.SetNameFValue): return eval_statement_SetNameFvalue(r, context) elif isinstance(r, CDP.Implements): return eval_statement_implements(r, context) elif isinstance(r, CDP.IgnoreFun): # equivalent to f >= any-of(Minimals S) lf = eval_lfunction(r.fvalue, context) F = context.get_ftype(lf) values = F.get_minimal_elements() dp = ConstantMinimals(F, values) ndp = SimpleWrap(dp, fnames=[], rnames='_out') name = context.new_name('_constant') context.add_ndp(name, ndp) r = context.make_resource(name, '_out') add_constraint(context, resource=r, function=lf) elif isinstance(r, CDP.IgnoreRes): # equivalent to r <= any-of(Maximals S) rv = eval_rvalue(r.rvalue, context) R = context.get_rtype(rv) try: values = R.get_maximal_elements() except NotImplementedError as e: # pragma: no cover msg = 'Could not call get_maximal_elements().' raise_wrapped(DPInternalError, e, msg, R=R) dp = LimitMaximals(R, values) ndp = SimpleWrap(dp, fnames='_limit', rnames=[]) name = context.new_name('_limit') context.add_ndp(name, ndp) f = context.make_function(name, '_limit') add_constraint(context, resource=rv, function=f) else: cases = { CDP.ResStatement: eval_statement_ResStatement, CDP.FunStatement: eval_statement_FunStatement, CDP.FunShortcut5: eval_statement_FunShortcut5, CDP.ResShortcut5: eval_statement_ResShortcut5, CDP.ResShortcut4: eval_statement_ResShortcut4, CDP.FunShortcut4: eval_statement_FunShortcut4, CDP.FunShortcut1m: eval_statement_FunShortcut1m, CDP.ResShortcut1m: eval_statement_ResShortcut1m, CDP.FunShortcut2: eval_statement_FunShortcut2, CDP.ResShortcut2: eval_statement_ResShortcut2, CDP.FunShortcut1: eval_statement_FunShortcut1, CDP.ResShortcut1: eval_statement_ResShortcut1, CDP.SetNameUncertainConstant: eval_statement_SetNameUncertainConstant, } for klass, hook in cases.items(): if isinstance(r, klass): return hook(r, context) if True: # pragma: no cover msg = 'eval_statement(): cannot interpret.' r2 = recursive_print(r) raise_desc(DPInternalError, msg, r=r2) # where=r.where.__repr__())
def parse_as_rvalue(s): """ returns rvalue, context """ parsed = parse_wrap(Syntax.rvalue, s)[0] context = Context() r = eval_rvalue(parsed, context) return r, context