def eval_statement_SetNameFvalue(r, context): check_isinstance(r, CDP.SetNameFValue) 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) from .eval_lfunction_imp import eval_lfunction fv = eval_lfunction(right_side, context) ndp = context.names[fv.dp] # TODO: check that is not used anywhere current = fv.s updated = name try: ndp2 = ndp_rename_function(ndp, current=current, updated=updated) context.names[fv.dp] = ndp2 fv = CFunction(fv.dp, updated) except CouldNotRename: pass context.set_var2function(name, fv)
def check_name_not_in_use(name, context, expr): if name in context.constants: msg = 'Constant %r already set.' % name raise DPSemanticError(msg, where=expr.where) if name in context.var2resource: msg = 'Resource %r already set.' % name raise DPSemanticError(msg, where=expr.where) if name in context.var2function: msg = 'Name %r already used.' % name raise DPSemanticError(msg, where=expr.where)
def make_function(self, dp, s): assert isinstance(dp, str) if not dp in self.names: msg = 'Unknown design problem %r.' % dp raise DPSemanticError(msg) ndp = self.names[dp] if not s in ndp.get_fnames(): msg = 'Unknown function %r for design problem %r.' % (s, dp) msg += ' Known functions: %s.' % format_list(ndp.get_fnames()) raise DPSemanticError(msg) return CFunction(dp, s)
def make_resource(self, dp, s): if not isinstance(dp, str): raise DPInternalError((dp, s)) if not dp in self.names: msg = 'Unknown design problem %r.' % dp raise DPSemanticError(msg) ndp = self.names[dp] if not s in ndp.get_rnames(): msg = 'Unknown resource %r for design problem %r.' % (s, dp) msg += ' Known functions: %s.' % format_list(ndp.get_rnames()) raise DPSemanticError(msg) return CResource(dp, s)
def _load_hooks(self, load_arg, hooks, expected): errors = [] if not hooks: msg = 'Could not load %r because no loading hooks provided.' % load_arg raise_desc(DPSemanticError, msg) for hook in hooks: try: try: res = hook(load_arg, context=self) if not isinstance(res, expected): msg = 'The hook did not return the expected type.' raise_desc(DPSemanticError, msg, res=res, expected=expected) return res except TypeError: msg = 'Could not use hook %r' % hook logger.error(msg) raise except DPSemanticError as e: if len(hooks) == 1: raise else: errors.append(e) s = "\n\n".join(map(str, errors)) msg = 'Could not load %r: \n%s' % (load_arg, s) raise DPSemanticError(msg)
def eval_constant_VariableRef(op, context): if op.name in context.constants: return context.constants[op.name] if op.name in context.var2resource: res = context.var2resource[op.name] msg = 'This is a resource, not a constant.' raise_desc(NotConstant, msg, res=res) if op.name in context.var2function: # XXX: not sure this is needed res = context.var2function[op.name] msg = 'This is a function, not a constant.' raise_desc(NotConstant, msg, res=res) try: x = context.get_ndp_fun(op.name) except ValueError: pass else: msg = 'Corresponds to new function, not a constant.' raise_desc(NotConstant, msg, x=x) try: x = context.get_ndp_res(op.name) except ValueError: pass else: msg = 'Corresponds to new resource, not a constant.' raise_desc(NotConstant, msg, x=x) msg = 'Variable ref %r unknown.' % op.name raise DPSemanticError(msg, where=op.where)
def visit_to_check2(x): # print(' visit_to_check2(%s) %s %s' % (nt_string(x), type(x).__name__, x)) if isinstance(x, CDP.Resource): l = x.dp.value + '.' + x.s.value Flavors.rvalue.add(l) elif isinstance(x, CDP.Function): l = x.dp.value + '.' + x.s.value Flavors.fvalue.add(l) elif isinstance(x, CDP.VName): Flavors.either.add(x.value) elif isinstance(x, CDP.VariableRef): if x.name in functions and x.name in resources: # ambiguous Flavors.either.add(x.name) # not other flavor elif x.name in functions or x.name in deriv_resources: # print('%r contributes to Flavors.rvalue' % x.name) Flavors.rvalue.add(x.name) # not other flavor elif x.name in resources or x.name in deriv_functions: # print('%r contributes to Flavors.fvalue' % x.name) Flavors.fvalue.add(x.name) # not other flavor elif x.name in variables: # print('%r contributes to Flavors.either' % x.name) Flavors.either.add(x.name) elif si.is_constant(x.name): # print('%r constant contributes to Flavors.either' % x.name) Flavors.either.add(x.name) else: msg = 'Could not resolve reference to %r.' % x.name raise DPSemanticError(msg, where=x.where)
def bb(tokens, loc, s): where = Where(s, loc) try: try: res = b(tokens) except TypeError as e: ttokens = list(tokens) s = "\n".join("- %s " % str(x) for x in ttokens) msg = 'Cannot invoke %r\nwith %d tokens:\n%s.' % ( b, len(ttokens), s) raise_wrapped(TypeError, e, msg) except DPSyntaxError as e: if e.where is None: e.where = where raise DPSyntaxError(str(e), where=where) else: raise except DPSemanticError as e: if e.where is None: raise DPSemanticError(str(e), where=where) else: raise except BaseException as e: raise_wrapped(DPInternalError, e, "Error while parsing.", where=where.__str__(), tokens=tokens) if isnamedtupleinstance(res) and res.where is None: res = get_copy_with_where(res, where=where) return res
def eval_lfunction_variableref(lf, context): if lf.name in context.constants: c = context.constants[lf.name] assert isinstance(c, ValueWithUnits) return get_valuewithunits_as_function(c, context) if lf.name in context.uncertain_constants: c = context.uncertain_constants[lf.name] assert isinstance(c, UncertainConstant) from .helpers import get_uncertainconstant_as_function return get_uncertainconstant_as_function(c, context) if lf.name in context.var2function: return context.var2function[lf.name] try: dummy_ndp = context.get_ndp_res(lf.name) except ValueError: msg = 'Function %r not declared.' % lf.name raise DPSemanticError(msg, where=lf.where) s = dummy_ndp.get_rnames()[0] msg = ( 'Please use the more precise form "required %s" rather than simply "%s".' % (lf.name, lf.name)) warn_language(lf, MCDPWarnings.LANGUAGE_REFERENCE_OK_BUT_IMPRECISE, msg, context) return context.make_function(get_name_for_res_node(lf.name), s)
def eval_rvalue_VariableRef(rvalue, context): if rvalue.name in context.constants: c = context.constants[rvalue.name] assert isinstance(c, ValueWithUnits) return get_valuewithunits_as_resource(c, context) # return eval_rvalue(context.constants[rvalue.name], context) elif rvalue.name in context.var2resource: return context.var2resource[rvalue.name] try: dummy_ndp = context.get_ndp_fun(rvalue.name) except ValueError: # as e: msg = 'Function %r not declared.' % rvalue.name if context.fnames: msg += ' Available: %s.' % ", ".join(context.fnames) else: msg += ' No function declared so far.' raise DPSemanticError(msg, where=rvalue.where) s = dummy_ndp.get_rnames()[0] msg = ('Please use the more precise form "provided %s" rather than simply "%s".' % (rvalue.name, rvalue.name)) warn_language(rvalue, MCDPWarnings.LANGUAGE_REFERENCE_OK_BUT_IMPRECISE, msg, context) return context.make_resource(get_name_for_fun_node(rvalue.name), s)
def eval_rvalue_DerivResourceRef(rvalue, context): check_isinstance(rvalue, CDP.DerivResourceRef) _ = rvalue.drname.value if _ in context.var2resource: return context.var2resource[_] else: msg = 'Derivative resource %r not found.' % _ raise DPSemanticError(msg, where=rvalue.where) # or internal?
def eval_lfunction_DerivFunctionRef(lf, context): check_isinstance(lf, CDP.DerivFunctionRef) _ = lf.dfname.value if _ in context.var2function: return context.var2function[_] else: msg = 'Derivative functionality %r not found.' % _ raise DPSemanticError(msg, where=lf.where)
def eval_lfunction_ActualVarRef(lf, context): check_isinstance(lf, CDP.ActualVarRef) _ = lf.vname.value if _ in context.var2function: return context.var2function[_] else: msg = 'Cannot resolve variable %r.' % _ raise DPSemanticError(msg, where=lf.where)
def add_function(fname, F, context, r, repeated_ok=False): check_isinstance(fname, str) try: check_good_name_for_function(fname) except ValueError as e: msg = 'Invalid name for functionality: %s' % e raise DPSemanticError(msg, where=r.where) if fname in context.fnames: if not repeated_ok: msg = 'Repeated function name %r.' % fname raise DPSemanticError(msg, where=r.where) else: # check same or different warnings.warn('check same') else: context.add_ndp_fun_node(fname, F) return context.make_resource(get_name_for_fun_node(fname), fname)
def add_resource(rname, R, context, r, repeated_ok=False): check_isinstance(rname, str) try: check_good_name_for_resource(rname) except ValueError as e: msg = 'Invalid name for resource: %s' % e raise DPSemanticError(msg, where=r.where) if rname in context.rnames: if not repeated_ok: msg = 'Repeated resource name %r.' % rname raise DPSemanticError(msg, where=r.where) else: # check same or different warnings.warn('check same') else: context.add_ndp_res_node(rname, R) return context.make_function(get_name_for_res_node(rname), rname)
def eval_rvalue_ActualVarRef(rvalue, context): check_isinstance(rvalue, CDP.ActualVarRef) _ = rvalue.vname.value if _ in context.var2resource: return context.var2resource[_] else: msg = 'Cannot resolve variable %r not found.' % _ raise DPSemanticError(msg, where=rvalue.where) # or internal?
def eval_constant_ConstantRef(rvalue, context): check_isinstance(rvalue, CDP.ConstantRef) _ = rvalue.cname.value if _ in context.constants: c = context.constants[_] assert isinstance(c, ValueWithUnits) return c else: msg = 'Constant value %r not found.' % _ raise DPSemanticError(msg, where=rvalue.where) # or internal?
def found_rname(rname): if isinstance(rname, CDP.Placeholder): return check_isinstance(rname, CDP.RName) _ = rname.value if _ in resources: msg = 'Repeated resource %r.' % _ raise DPSemanticError(msg, where=rname.where) if _ in deriv_resources: msg = 'The name %r is already used.' % _ raise DPSemanticError(msg, where=rname.where) if _ in variables: msg = 'The name %r is already used by a variable.' % _ raise DPSemanticError(msg, where=rname.where) resources.add(rname.value)
def found_fname(fname): if isinstance(fname, CDP.Placeholder): return check_isinstance(fname, CDP.FName) infer_debug('found fname: %s' % fname.value) _ = fname.value if _ in functions: msg = 'Repeated function %r.' % _ raise DPSemanticError(msg, where=fname.where) if _ in deriv_resources: msg = 'The name %r is already used.' % _ raise DPSemanticError(msg, where=fname.where) if _ in variables: msg = 'The name %r is already used by a variable.' % _ raise DPSemanticError(msg, where=fname.where) functions.add(fname.value)
def which_line(contents, fragment, after_line): lines = contents.split('\n') after = "\n".join(lines[after_line:]) if not fragment in contents: msg = 'Cannot find fragment %r in file after line %d' % (fragment, after_line) msg += '\n' + indent(after, '| ') raise DPSemanticError(msg) i = after.index(fragment) line = len(after[:i].split('\n')) -1 return line + after_line
def eval_lfunction_ConstantRef(lf, context): check_isinstance(lf, CDP.ConstantRef) _ = lf.cname.value if _ in context.constants: c = context.constants[_] assert isinstance(c, ValueWithUnits) return get_valuewithunits_as_function(c, context) else: msg = 'Cannot resolve constant %r.' % _ raise DPSemanticError(msg, where=lf.where)
def get_rtype(self, a): """ Gets the type of a resource, raises DPSemanticError if not present. """ check_isinstance(a, CResource) if not a.dp in self.names: msg = "Cannot find design problem %r." % str(a) raise DPSemanticError(msg) ndp = self.names[a.dp] if not a.s in ndp.get_rnames(): msg = "Design problem %r does not have resource %r." % (a.dp, a.s) raise_desc(DPSemanticError, msg, rnames=ndp.get_rnames()) return ndp.get_rtype(a.s)
def get_ftype(self, a): """ Gets the type of a function, raises DPSemanticError if not present. """ check_isinstance(a, CFunction) if not a.dp in self.names: msg = "Cannot find design problem %r." % str(a) raise DPSemanticError(msg) dp = self.names[a.dp] if not a.s in dp.get_fnames(): msg = "Design problem %r does not have function %r." % (a.dp, a.s) raise_desc(DPSemanticError, msg, fnames=dp.get_fnames()) return dp.get_ftype(a.s)
def eval_constant_divide(op, context): from .eval_constant_imp import eval_constant ops = get_odd_ops(unwrap_list(op.ops)) if len(ops) != 2: raise DPSemanticError('divide by more than two') constants = [eval_constant(_, context) for _ in ops] factors = [constants[0], inv_constant(constants[1])] from .misc_math import generic_mult_constantsN return generic_mult_constantsN(factors)
def inv_constant(a): if a.unit == Nat(): raise DPNotImplementedError('division by natural number') warnings.warn('Please think more about this. Now 1/N -> 1.0/N') unit = Rcomp() else: unit = inv_unit(a.unit) if a.value == 0: raise DPSemanticError('Division by zero') # TODO: what about integers? value = 1.0 / a.value return ValueWithUnits(value=value, unit=unit)
def plus_constants2_rcompunits(a, b): """ raises ConstantsNotCompatibleForAddition """ check_isinstance(a.unit, RcompUnits) check_isinstance(b.unit, RcompUnits) R = a.unit Fs = [a.unit, b.unit] values = [a.value, b.value] try: res = sum_units(Fs, values, R) except IncompatibleUnits: msg = 'The units "%s" and "%s" are incompatible.' % (a.unit.string, b.unit.string) raise DPSemanticError(msg) return ValueWithUnits(value=res, unit=R)
def display_files(soup, defaults, raise_errors): n = 0 for element in soup.find_all('display-file'): src = element.attrs.get('src', '').strip() element.attrs['src'] = src if src.startswith('github:'): display_file(element, defaults, raise_errors) n += 1 else: msg = 'Unknown schema %r; I only know "github:".' % src if raise_errors: raise DPSemanticError(msg) else: note_error2(element, 'syntax error', msg) return n
def eval_rvalue_NewFunction(rvalue, context): check_isinstance(rvalue, CDP.NewFunction) check_isinstance(rvalue.name, CDP.FName) fname = rvalue.name.value try: dummy_ndp = context.get_ndp_fun(fname) except ValueError: msg = 'New resource name %r not declared.' % fname if context.rnames: msg += ' Available: %s.' % ", ".join(context.rnames) else: msg += ' No resources declared so far.' raise DPSemanticError(msg, where=rvalue.where) return context.make_resource(get_name_for_fun_node(fname), dummy_ndp.get_rnames()[0])
def eval_constant_collection(op, context): ops = get_odd_ops(unwrap_list(op.elements)) if len(ops) == 0: raise DPSemanticError('empty list') elements = [eval_constant(_, context) for _ in ops] e0 = elements[0] u0 = e0.unit elements = [_.cast_value(u0) for _ in elements] value = FiniteCollection(set(elements), u0) unit = FiniteCollectionsInclusion(u0) vu = ValueWithUnits(value, unit) return vu
def eval_lfunction_newresource(lf, context): check_isinstance(lf, CDP.NewResource) check_isinstance(lf.name, CDP.RName) rname = lf.name.value try: dummy_ndp = context.get_ndp_res(rname) except ValueError: msg = 'New resource name %r not declared.' % rname if context.rnames: msg += ' Available: %s.' % ", ".join(context.rnames) else: msg += ' No resources declared so far.' # msg += '\n%s' % str(e) raise DPSemanticError(msg, where=lf.where) return context.make_function(get_name_for_res_node(rname), dummy_ndp.get_fnames()[0])