@@ -26,6 +26,23 @@ class Value(object): def __deepcopy__(self, memo): return self +class LengthValue(Value): + def __init__(self, lhs, metatable=None): + self.left = lhs + if metatable is None: + self.metatable = {} + else: + self.metatable = metatable + + def getMetatable(self): + return self.metatable + + def getOneValue(self, currEnv): + return self.resolve(currEnv) + + def resolve(self, currEnv): + return LiteralValue(len(self.left.reallyResolve(currEnv))) + class LiteralValue(Value): def __init__(self, value, metatable=None): self.value = value @@ -91,7 +108,8 @@ class FunctionCallValue(Value): f = self.body.reallyResolve(currEnv) if type(self.nparams).__name__ not in ('list','tuple'): self.nparams = [self.nparams] - return f(*self.nparams) + result = f(*self.nparams) + return result class APIFunctionValue(Value): def __init__(self, params, body, metatable=None): @@ -107,8 +125,8 @@ class APIFunctionValue(Value): def resolve(self, currEnv): def f(*nparams): - nparams = [i.reallyResolve(currEnv) for i in nparams] newEnv = currEnv.clone() + nparams = [i.reallyResolve(newEnv) for i in nparams] for i in range(len(nparams)): newEnv[self.params[i]] = nparams[i] try: @@ -130,11 +148,23 @@ class TableValue(Value): else: self.metatable = metatable + @classmethod + def dictize(cls, fields, currEnv): + index = 1 + newD = {} + for f in fields: + if type(f) == type((1,)): + newD[f[0].reallyResolve(currEnv)] = f[1].reallyResolve(currEnv) + else: + newD[index] = f.reallyResolve(currEnv) + index += 1 + return newD + def resolve(self, currEnv): - return self.fieldlist + return TableValue.dictize(self.fieldlist, currEnv) def getOneValue(self, currEnv): - return self.fieldlist.get(1,None) + return self.fieldlist.resolve().get(1,None) def getMetatable(self): return self.metatable @@ -165,7 +195,7 @@ class VariableValue(Value): def resolve(self, currEnv): if type(self.name).__name__ == 'tuple': - return currEnv[self.name[0].reallyResolve(currEnv)][self.name[1].reallyResolve(currEnv)] + return self.name[0].reallyResolve(currEnv).get(self.name[1].reallyResolve(currEnv), None) return currEnv[self.name.reallyResolve(currEnv)] def getOneValue(self, currEnv): @@ -174,217 +204,6 @@ class VariableValue(Value): def getMetatable(self): return self.metatable -class Environment(object): - def __init__(self, currEnv=None): - if currEnv is not None: - if type(currEnv).__name__ == 'dict': - self.oldCurrEnv = None - self.currEnv = currEnv - else: - self.oldCurrEnv = currEnv - self.currEnv = {} - else: - self.oldCurrEnv = None - self.currEnv = {} - def embraceAndExtend(self, var, value): - self.currEnv[var] = value - - def extend(self, var, value): - e = Environment(self) - e.embraceAndExtend(var, value) - return e - - def clone(self): - return Environment(self) - - def __str__(self): - return str(self.currEnv) + "::" + str(self.oldCurrEnv) - - def __getitem__(self, key): - if self.oldCurrEnv is None: - return self.currEnv.get(key, None) - else: - return self.currEnv.get(key,self.oldCurrEnv[key]) - - def __setitem__(self, key, value): - if key in self.oldCurrEnv: - self.oldCurrEnv[key] = value - else: - self.currEnv[key] = value - - def __contains__(self, key): - if key in self.currEnv: - return True - else: - if self.oldCurrEnv is not None: - return key in self.oldCurrEnv - else: - return False - - def __len__(self): - return len(self.currEnv) + len(self.oldCurrEnv) - - def __delitem__(self, key): - self.embraceAndExtend(key, None) - -class AssignmentHelperTable(object): - def __init__(self, left, index, embrace=False): - self.left = left - self.index = index - self.embrace = embrace - - def doAssignment(self, currEnv, right): - currEnv[self.left][self.index] = right - -class AssignmentHelperNoTable(object): - def __init__(self, left, embrace=False): - self.left = left - self.embrace = embrace - - def doAssignment(self, currEnv, right): - if self.embrace: - currEnv.embraceAndExtend(self.left, right) - else: - currEnv[self.left] = right - -class AssignmentNode(Node): - def __init__(self, lhs, rhs, rec=False): - self.lhs = lhs - self.rhs = rhs - self.rec = rec - - def evaluate(self, currEnv): - variables = [] - for left in self.lhs: - if type(left).__name__ == 'tuple': - variables.append(AssignmentHelperTable(left[0].resolve(currEnv),left[1].resolve(currEnv))) - else: - variables.append(AssignmentHelperNoTable(left.resolve(currEnv))) - if self.rec: - [currEnv.__setitem__(i, None) for i in variables if i not in currEnv] - values = [i.resolve(currEnv) for i in self.rhs] - for i in range(len(variables)): - if i > len(values): - ass = None - else: - ass = values[i] - variables[i].doAssignment(currEnv, ass) - -class LocalAssignmentNode(Node): - def __init__(self, lhs, rhs, rec=False): - self.lhs = lhs - self.rhs = rhs - self.rec = rec - - def evaluate(self, currEnv): - variables = [] - for left in self.lhs: - if type(left).__name__ == 'tuple': - variables.append(AssignmentHelperTable(left[0].resolve(currEnv),left[1].resolve(currEnv)),embrace=True) - else: - variables.append(AssignmentHelperNoTable(left.resolve(currEnv),embrace=True)) - if self.rec: - #FIXME: HUGE KLUDGE ALERT!!! - [currEnv.embraceAndExtend(i.left, None) for i in variables if i.left not in currEnv.currEnv] - values = [i.resolve(currEnv) for i in self.rhs] - for i in range(len(variables)): - if i > len(values): - ass = None - else: - ass = values[i] - variables[i].doAssignment(currEnv, ass) - -class WhileNode(Node): - def __init__(self, cond, body): - self.cond = cond - self.body = body - - def evaluate(self, currEnv): - while self.cond.resolve(currEnv): - self.body.evaluate(currEnv) - -class RepeatNode(Node): - def __init(self, cond, body): - self.cond = cond - self.body = body - - def evaluate(self, currEnv): - self.body.evaluate(currEnv) - while self.cond.resolve(currEnv): - self.body.evaluate(currEnv) - -class TableConstructorNode(Node): - def __init__(self, fields): - self.fields = fields - - def evaluate(self, currEnv): - v = TableValue({}) - for i in range(len(fields)): - ri = fields[i] - if type(ri).__name__ == 'tuple': - v[ri[0].evaluate(currEnv)] = ri[1].evaluate(currEnv) - else: - v[i] = ri.evaluate(currEnv) - return v - -class IfNode(Node): - def __init__(self,cond,body,elses=None): - if elses is None: - self.elses = [] - else: - self.elses = elses - self.cond = cond - self.body = body - - def evaluate(self, currEnv): - if self.cond.reallyResolve(currEnv): - self.body.evaluate(currEnv) - else: - if len(self.elses) > 0: - for i in self.elses: - if i.cond.reallyResolve(currEnv): - i.body.evaluate(currEnv) - break - -class ElseNode(Node): - def __init__(self, cond,body): - self.cond = cond - self.body = body - -class NumericForNode(Node): - def __init__(self, var, limit, step, index, body): - self.var = var - self.limit = limit - self.step = step - self.index = index - self.body = body - - def evaluate(self, currEnv): - var, limit, step = int(self.var.reallyResolve(currEnv)), int(self.limit.reallyResolve(currEnv)), int(self.step.reallyResolve(currEnv)) - self.index = self.index.reallyResolve(currEnv) - newEnv = currEnv.extend(self.index, None) - try: - while (step > 0 and var <= limit) or (step <= 0 and var >= limit): - newEnv[self.index] = LiteralValue(var) - self.body.evaluate(newEnv) - var += step - except BreakSignalException: - pass - -class ReturnNode(Node): - def __init__(self, retValue): - self.retValue = retValue - - def evaluate(self, currEnv): - raise ReturnSignalException(self.retValue) - -class BreakNode(Node): - def __init__(self): - pass - - def evaluate(self, currEnv): - raise BreakSignalException() - class AdditionValue(Value): def __init__(self, lhs, rhs, metatable=None): self.lhs = lhs @@ -689,22 +508,216 @@ class NotValue(Value): def resolve(self, currEnv): return LiteralValue(not self.left.reallyResolve(currEnv)) -class LengthValue(Value): - def __init__(self, lhs, metatable=None): - self.left = lhs - if metatable is None: - self.metatable = {} + +class Environment(object): + def __init__(self, currEnv=None, oldEnv=None): + if currEnv is not None: + if type(currEnv).__name__ == 'dict': + self.oldCurrEnv = oldEnv + self.currEnv = currEnv + else: + self.oldCurrEnv = currEnv + self.currEnv = {} else: - self.metatable = metatable + self.oldCurrEnv = oldEnv + self.currEnv = {} + def embraceAndExtend(self, var, value): + self.currEnv[var] = value - def getMetatable(self): - return self.metatable + def extend(self, var, value): + e = Environment(currEnv={}, oldEnv=self) + e.embraceAndExtend(var, value) + return e - def getOneValue(self, currEnv): - return self.resolve(currEnv) + def clone(self): + e = Environment(currEnv={}, oldEnv=self) + return e - def resolve(self, currEnv): - return LiteralValue(len(self.left.reallyResolve(currEnv))) + def __str__(self): + return str(self.currEnv) + "::" + str(self.oldCurrEnv) + + def __getitem__(self, key): + if self.oldCurrEnv is None: + return self.currEnv.get(key, None) + else: + return self.currEnv.get(key,self.oldCurrEnv[key]) + + def __setitem__(self, key, value): + self.currEnv[key] = value + + def __contains__(self, key): + if key in self.currEnv: + return True + else: + if self.oldCurrEnv is not None: + return key in self.oldCurrEnv + else: + return False + + def __len__(self): + return len(self.currEnv) + len(self.oldCurrEnv) + + def __delitem__(self, key): + self.embraceAndExtend(key, None) + +class AssignmentHelperTable(object): + def __init__(self, left, index, embrace=False): + self.left = left + self.index = index + self.embrace = embrace + + def doAssignment(self, currEnv, right): + currEnv[self.left][self.index] = right + +class AssignmentHelperNoTable(object): + def __init__(self, left, embrace=False): + self.left = left + self.embrace = embrace + + def doAssignment(self, currEnv, right): + if self.embrace: + currEnv.embraceAndExtend(self.left, right) + else: + currEnv[self.left] = right + +class AssignmentNode(Node): + def __init__(self, lhs, rhs, rec=False): + self.lhs = lhs + self.rhs = rhs + self.rec = rec + + def evaluate(self, currEnv): + variables = [] + for left in self.lhs: + if type(left).__name__ == 'tuple': + variables.append(AssignmentHelperTable(left[0].resolve(currEnv),left[1].resolve(currEnv))) + else: + variables.append(AssignmentHelperNoTable(left.resolve(currEnv))) + if self.rec: + [currEnv.__setitem__(i, None) for i in variables if i not in currEnv] + values = [i.resolve(currEnv) for i in self.rhs] + for i in range(len(variables)): + if i > len(values): + ass = None + else: + ass = values[i] + variables[i].doAssignment(currEnv, ass) + +class LocalAssignmentNode(Node): + def __init__(self, lhs, rhs, rec=False): + self.lhs = lhs + self.rhs = rhs + self.rec = rec + + def evaluate(self, currEnv): + variables = [] + for left in self.lhs: + if type(left).__name__ == 'tuple': + variables.append(AssignmentHelperTable(left[0].resolve(currEnv),left[1].resolve(currEnv)),embrace=True) + else: + variables.append(AssignmentHelperNoTable(left.resolve(currEnv),embrace=True)) + if self.rec: + #FIXME: HUGE KLUDGE ALERT!!! + [currEnv.embraceAndExtend(i.left, None) for i in variables if i.left not in currEnv.currEnv] + values = [i.resolve(currEnv) for i in self.rhs] + for i in range(len(variables)): + if i > len(values): + ass = None + else: + ass = values[i] + variables[i].doAssignment(currEnv, ass) + +class WhileNode(Node): + def __init__(self, cond, body): + self.cond = cond + self.body = body + + def evaluate(self, currEnv): + while self.cond.resolve(currEnv): + self.body.evaluate(currEnv) + +class RepeatNode(Node): + def __init(self, cond, body): + self.cond = cond + self.body = body + + def evaluate(self, currEnv): + self.body.evaluate(currEnv) + while self.cond.resolve(currEnv): + self.body.evaluate(currEnv) + +class TableConstructorNode(Node): + def __init__(self, fields): + self.fields = fields + + def evaluate(self, currEnv): + v = TableValue({}) + for i in range(len(fields)): + ri = fields[i] + if type(ri).__name__ == 'tuple': + v[ri[0].evaluate(currEnv)] = ri[1].evaluate(currEnv) + else: + v[i] = ri.evaluate(currEnv) + return v + +class IfNode(Node): + def __init__(self,cond,body,elses=None): + if elses is None: + self.elses = [] + else: + self.elses = elses + self.cond = cond + self.body = body + + def evaluate(self, currEnv): + if self.cond.reallyResolve(currEnv): + self.body.evaluate(currEnv) + else: + if len(self.elses) > 0: + for i in self.elses: + if i.cond.reallyResolve(currEnv): + i.body.evaluate(currEnv) + break + +class ElseNode(Node): + def __init__(self, cond,body): + self.cond = cond + self.body = body + +class NumericForNode(Node): + def __init__(self, var, limit, step, index, body): + self.var = var + self.limit = limit + self.step = step + self.index = index + self.body = body + + def evaluate(self, currEnv): + var, limit, step = int(self.var.reallyResolve(currEnv)), int(self.limit.reallyResolve(currEnv)), int(self.step.reallyResolve(currEnv)) + self.index = self.index.reallyResolve(currEnv) + newEnv = currEnv.extend(self.index, None) + try: + while (step > 0 and var <= limit) or (step <= 0 and var >= limit): + newEnv[self.index] = LiteralValue(var) + self.body.evaluate(newEnv) + var += step + except BreakSignalException: + pass + +class ReturnNode(Node): + def __init__(self, retValue): + self.retValue = retValue + + def evaluate(self, currEnv): + raise ReturnSignalException(self.retValue) + +class BreakNode(Node): + def __init__(self): + pass + + def evaluate(self, currEnv): + raise BreakSignalException() + class FunctionCallStatementNode(Node): def __init__(self, function): engine/routine_nodes.py @@ -1,2 +1,4 @@ s = { "x", "y"; x = 1, [30] = 23; 45 }; -debug_print(s[0]); \ No newline at end of file +debug_print(s["x"]); +debug_print(#s); +debug_print{ "x", "y"; x = 1, [30] = 23; 44 }; engine/tests/tables.lua 268892f797d8ad86b0b9e76a7bdbea610cc8bcdb Silas Snider swsnider@gmail.com http://github.com/swsnider/mmo/commit/f6182e54edffd3cced7b75dda8c9fe3f134b22af f6182e54edffd3cced7b75dda8c9fe3f134b22af 2008-06-12T12:03:04-07:00 2008-06-12T12:03:04-07:00 fixed the table constructor logic and a gaping hole in the Environment cloning/handling 99ff1cf49e53dfc93197ea77305bcb7ff81bb490 Silas Snider swsnider@gmail.com