diff --git a/src/tim/engine/compilers/html.nim b/src/tim/engine/compilers/html.nim
index 48f2917..4d8180d 100755
--- a/src/tim/engine/compilers/html.nim
+++ b/src/tim/engine/compilers/html.nim
@@ -222,6 +222,11 @@ proc toString(value: Value, escape = false): string =
of nimValue:
value.nVal.toString(escape)
+template write(x: Node, fixtail, escape: bool) =
+ if likely(x != nil):
+ add c.output, x.toString(escape)
+ c.stickytail = fixtail
+
proc print(val: Node) =
let meta = " ($1:$2) " % [$val.meta[0], $val.meta[2]]
stdout.styledWriteLine(
@@ -344,15 +349,18 @@ proc infixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
result = lhs.fVal == toFloat(rhs.iVal)
else: discard
of ntIdent:
- var lhs = c.fromScope(lhs.identName, scopetables)
- if lhs == nil or rhs == nil: return # false
- case rhs.nt
- of ntIdent:
- var rhs = c.fromScope(rhs.identName, scopetables)
- if rhs != nil:
- result = c.infixEvaluator(lhs.varValue, rhs.varValue, infixOp, scopetables)
- else:
- result = c.infixEvaluator(lhs.varValue, rhs, infixOp, scopetables)
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.infixEvaluator(lhs, rhs, infixOp, scopetables)
+ # var lhs = c.fromScope(lhs.identName, scopetables)
+ # if lhs == nil or rhs == nil: return # false
+ # case rhs.nt
+ # of ntIdent:
+ # var rhs = c.fromScope(rhs.identName, scopetables)
+ # if rhs != nil:
+ # result = c.infixEvaluator(lhs.varValue, rhs.varValue, infixOp, scopetables)
+ # else:
+ # result = c.infixEvaluator(lhs.varValue, rhs, infixOp, scopetables)
of ntDotExpr:
let x = c.dotEvaluator(lhs, scopetables)
result = c.infixEvaluator(x, rhs, infixOp, scopetables)
@@ -373,6 +381,10 @@ proc infixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
of ntLitInt:
result = lhs.fVal > toFloat(rhs.iVal)
else: discard
+ of ntIdent:
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.infixEvaluator(lhs, rhs, infixOp, scopetables)
else: discard # handle float
of GTE:
case lhs.nt:
@@ -390,6 +402,10 @@ proc infixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
of ntLitInt:
result = lhs.fVal >= toFloat(rhs.iVal)
else: discard
+ of ntIdent:
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.infixEvaluator(lhs, rhs, infixOp, scopetables)
else: discard # handle float
of LT:
case lhs.nt:
@@ -407,6 +423,10 @@ proc infixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
of ntLitInt:
result = lhs.fVal <= toFloat(rhs.iVal)
else: discard
+ of ntIdent:
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.infixEvaluator(lhs, rhs, infixOp, scopetables)
else: discard # handle float
of LTE:
case lhs.nt:
@@ -424,6 +444,10 @@ proc infixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
of ntLitInt:
result = lhs.fVal <= toFloat(rhs.iVal)
else: discard
+ of ntIdent:
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.infixEvaluator(lhs, rhs, infixOp, scopetables)
else: discard # handle float
of AND:
case lhs.nt
@@ -475,7 +499,7 @@ proc getValue(c: var HtmlCompiler, node: Node,
result = ast.newNode(ntLitString)
let vNodes: seq[Node] = c.getValues(node, scopetables)
for vNode in vNodes:
- add result.sVal, vNode.sVal
+ add result.sVal, vNode.toString()
else:
result = ast.newNode(ntLitBool)
result.bVal = c.infixEvaluator(node.infixLeft, node.infixRight, node.infixOp, scopetables)
@@ -492,6 +516,16 @@ proc getValue(c: var HtmlCompiler, node: Node,
result = c.fnCall(node, scopetables)
else: discard
+template calcInfixEval {.dirty.} =
+ let lhs = c.mathInfixEvaluator(lhs.infixMathLeft, lhs.infixMathRight, lhs.infixMathOp, scopetables)
+ if likely(lhs != nil):
+ return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
+
+template calcIdent {.dirty.} =
+ let lhs = c.getValue(lhs, scopetables)
+ if likely(lhs != nil):
+ return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
+
proc mathInfixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
op: MathOp, scopetables: var seq[ScopeTable]): Node =
## Evaluates a math expression and returns a new Node
@@ -523,10 +557,8 @@ proc mathInfixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
if likely(rhs != nil):
return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
else: discard
- of ntIdent:
- let lhs = c.getValue(lhs, scopetables)
- if likely(lhs != nil):
- return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
+ of ntIdent: calcIdent()
+ of ntMathInfixExpr: calcInfixEval()
else: discard
of mMinus:
case lhs.nt
@@ -555,10 +587,8 @@ proc mathInfixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
if likely(rhs != nil):
return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
else: discard
- of ntIdent:
- let lhs = c.getValue(lhs, scopetables)
- if likely(lhs != nil):
- return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
+ of ntIdent: calcIdent()
+ of ntMathInfixExpr: calcInfixEval()
else: discard
of mMulti:
case lhs.nt
@@ -590,10 +620,8 @@ proc mathInfixEvaluator(c: var HtmlCompiler, lhs, rhs: Node,
let rhs = c.dotEvaluator(rhs, scopetables)
return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
else: discard
- of ntIdent:
- let lhs = c.getValue(lhs, scopetables)
- if likely(lhs != nil):
- return c.mathInfixEvaluator(lhs, rhs, op, scopetables)
+ of ntIdent: calcIdent()
+ of ntMathInfixExpr: calcInfixEval()
else: discard
else: discard
@@ -643,29 +671,12 @@ proc evalCondition(c: var HtmlCompiler, node: Node, scopetables: var seq[ScopeTa
result = c.walkNodes(node.condElseBranch, scopetables)
proc evalConcat(c: var HtmlCompiler, node: Node, scopetables: var seq[ScopeTable]) =
- case node.infixLeft.nt
- of ntDotExpr:
- c.writeDotExpr(node.infixLeft, scopetables)
- of ntAssignableSet:
- add c.output, node.infixLeft.toString()
- of ntInfixExpr:
- c.evalConcat(node.infixLeft, scopetables)
- else: discard
-
- case node.infixRight.nt
- of ntDotExpr:
- c.writeDotExpr(node.infixRight, scopetables)
- of ntAssignableSet:
- add c.output, node.infixRight.toString()
- of ntInfixExpr:
- c.evalConcat(node.infixRight, scopetables)
- of ntMathInfixExpr:
- let math = node.infixRight
- let someValue = c.mathInfixEvaluator(math.infixMathLeft,
- math.infixMathRight, math.infixMathOp, scopetables)
- if likely(someValue != nil):
- add c.output, someValue.toString()
- else: discard
+ var x, y: Node
+ x = c.getValue(node.infixLeft, scopetables)
+ y = c.getValue(node.infixRight, scopetables)
+ if likely(x != nil and y != nil):
+ write x, true, false
+ write y, true, false
template loopEvaluator(items: Node) =
case items.nt:
@@ -808,8 +819,7 @@ proc fnCall(c: var HtmlCompiler, node: Node,
newScope(scopetables)
let fnNode = some.scopeTable[node.callIdent]
if fnNode.fnParams.len > 0:
- # add available param definition
- # to current stack
+ # add params to the stack
for k, p in fnNode.fnParams:
var x = ast.newVariable(k, p.pImplVal, p.meta)
c.stack(k, x, scopetables)
@@ -820,7 +830,7 @@ proc fnCall(c: var HtmlCompiler, node: Node,
var i = 0
for k, p in fnNode.fnParams:
case node.callArgs[i].nt
- of ntIdent:
+ of ntIdent, ntMathInfixExpr, ntInfixExpr:
var valNode = c.getValue(node.callArgs[i], scopetables)
if not c.typeCheck(valNode, p.pType):
return # error > type mismatch
@@ -951,11 +961,6 @@ proc evaluatePartials(c: var HtmlCompiler, includes: seq[string], scopetables: v
if likely(c.ast.partials.hasKey(x)):
c.walkNodes(c.ast.partials[x][0].nodes, scopetables)
-template write(x: Node, fixtail, escape: bool) =
- if likely(x != nil):
- add c.output, x.toString(escape)
- c.stickytail = fixtail
-
proc walkNodes(c: var HtmlCompiler, nodes: seq[Node],
scopetables: var seq[ScopeTable], parentNodeType: NodeType = ntUnknown): Node {.discardable.} =
# Evaluate a seq[Node] nodes
@@ -1010,7 +1015,7 @@ proc walkNodes(c: var HtmlCompiler, nodes: seq[Node],
if likely(returnNode != nil):
write returnNode, true, false
else:
- return c.fnCall(nodes[i], scopetables)
+ discard c.fnCall(nodes[i], scopetables)
of ntInclude:
c.evaluatePartials(nodes[i].includes, scopetables)
of ntJavaScriptSnippet: