resource.write("".join([ str(self.resolve(funcEnv, self.semplify(funcEnv, x))) for x in args ])) return types.NullValue() def resolve(self, funcEnv, arg): """ Override Function.resolve to manage the <Symbol:crlf> conversion to NEWLINE and to remove quotes in types.String values """ if isinstance(arg, types.Symbol) and arg.pyEqual("crlf"): return "\n" else: return Function.resolve(self, funcEnv, arg) # Function definition Printout.DEFINITION = FunctionDefinition( "?SYSTEM?", "printout", Printout(), types.NullValue, Printout.do, [ Constraint_MinArgsLength(2), Constraint_ArgType(types.Symbol, 0), ], forward=False)
values=[ self.semplify(theEnv, v) # resolve to BaseParsedTypes if needed for v in arg.values ], moduleName=theEnv.modulesManager.currentScope.moduleName) elif isinstance(arg, types.TemplateRhsPattern): # convert it in a new Template Fact # the fact value is a dict with (slotName, slotValue) where slotValue # need to be resolved return TemplateFact( templateName=arg.templateName, values=dict([(v.slotName, self.semplify(theEnv, v.slotValue)) for v in arg.templateSlots]), moduleName=theEnv.modulesManager.currentScope.templates. getDefinition(arg.templateName).moduleName) else: raise InvalidArgValueError("Invalid fact format") Assert.DEFINITION = FunctionDefinition("?SYSTEM?", "assert", Assert(), (WME, types.Symbol), Assert.do, [ Constraint_MinArgsLength(1), ], forward=False)
args = list(args) args.reverse() try: for theModule in args: theModule = self.resolve( theEnv, self.semplify(theEnv, theModule, types.Symbol, ("ALL", "symbol"))) if not theEnv.modulesManager.isDefined(theModule): raise InvalidArgValueError("Unable to find defmodule %s" % theModule) else: theEnv.network.agenda.focusStack.append(theModule) return types.Symbol("TRUE") except IndexError: return types.Symbol("FALSE") Focus.DEFINITION = FunctionDefinition( "?SYSTEM?", "focus", Focus(), types.Symbol, Focus.do, [Constraint_MinArgsLength(1), Constraint_ArgType(types.Symbol)], forward=False)
Function.__init__(self, *args, **kwargs) def do(self, theEnv, *args, **kargs): """ handler of the function """ # comparison is done against the <Symbol:TRUE> theValue = types.Symbol("TRUE") for theArg in args: # resolve the real value # before comparison if isinstance(theArg, (types.FunctionCall, types.Variable)): theArg = self.resolve(theEnv, theArg) # types + value comparison if theValue == theArg: return theValue # return <Symbol:TRUE> return types.Symbol("FALSE") Or.DEFINITION = FunctionDefinition( "?SYSTEM?", "or", Or(), types.Symbol, Or.do, [Constraint_MinArgsLength(2), Constraint_ArgType(types.Symbol)], forward=False)
theBegin = theMultifield[0:theIndex - 1] theEnd = theMultifield[theIndex - 1:None] theInner = [] for theArg in args: theArg = self.semplify( theEnv, theArg, (list), ("1", "number, lexeme, fact-address or multifield")) if isinstance(theArg, list): theInner += theArg else: theInner.append(theArg) return theBegin + theInner + theEnd Insert.DEFINITION = FunctionDefinition( "?SYSTEM?", "insert$", Insert(), list, Insert.do, [ Constraint_MinArgsLength(3), Constraint_ArgType(list, 0), Constraint_ArgType(types.Integer, 1), Constraint_ArgType((types.Lexeme, types.Number, WME, list), 2), Constraint_ArgType((types.Lexeme, types.Number, WME, list), (3, None), failIfMissing=False) ], forward=False)
(theBegin, theEnd) if theBegin != theEnd else str(theBegin)), len(theMultifield))) else: theInner = [] for theArg in args: theArg = self.semplify( theEnv, theArg, (list), ("1", "number, lexeme, fact-address or multifield")) if isinstance(theArg, list): theInner += theArg else: theInner.append(theArg) return theBegin + theInner + theEnd Replace.DEFINITION = FunctionDefinition( "?SYSTEM?", "replace$", Replace(), list, Replace.do, [ Constraint_MinArgsLength(4), Constraint_ArgType(list, 0), Constraint_ArgType(types.Integer, 1), Constraint_ArgType(types.Integer, 2), Constraint_ArgType((types.Lexeme, types.Number, WME, list), 3), Constraint_ArgType((types.Lexeme, types.Number, WME, list), (4, None), failIfMissing=False) ], forward=False)
def __init__(self, functionName, modulesManager, params=None, actions=None, comment=None): functionName = HasScope.cleanName(functionName.evaluate( ) if isinstance(functionName, BaseParsedType) else functionName) ParsedType.__init__(self, functionName) HasScope.__init__(self, modulesManager) self.functionName = functionName self.comment = comment.evaluate().strip('"') if isinstance( comment, BaseParsedType) else comment self.params = [] if params is None else params self.actions = [] if actions is None else actions self.functionDefinition = None # lets create the function definition if self.scope.functions.has(functionName): # has function return True # is exists a definition # and it is not a forward declaration # system functions aren't always forwards # valutate systemFunction only for # custom error if self.scope.functions.hasSystemFunction(functionName): raise TypeInstanceCreationError( "Deffunctions are not allowed to replace external functions: %s" % functionName) else: raise TypeInstanceCreationError( "Cannot define deffunction %s because of an import/export conflict" % functionName) # generate constraints from params constraints = [] # args length minParams = len( [x for x in self.params if isinstance(x, SingleFieldVariable)]) hasMax = not isinstance(self.params[-1], MultiFieldVariable) if hasMax: constraints.append(Constraint_ExactArgsLength(minParams)) else: constraints.append(Constraint_MinArgsLength(minParams)) from myclips.functions.UserFunction import UserFunction functionHandler = UserFunction(self.params, self.actions) fDef = FunctionDefinition( self.scope.moduleName, functionName, linkedType=functionHandler, returnTypes=(self.actions[-1].funcDefinition.returnTypes if len(self.actions) > 0 and isinstance(self.actions[-1], FunctionCall) else self.actions[-1].__class__ if isinstance( self.actions[-1], BaseParsedType) else (Lexeme, Number, list, WME)), handler=functionHandler.do, constraints=constraints, forward=True) functionHandler.DEFINITION = fDef self.scope.functions.addDefinition(fDef)