anchor.diff:      nothing ->
         tokenize_expression(T, LN, break, [], Acc);
       {str, S} ->
  -      case get("V" ++ S) of
  -        undefined ->
  -          erlang:error(S ++ " undefined on line " ++ integer_to_list(LN));
  -        SavedVal ->
  -          tokenize_expression(T, LN, break, [], [{val, SavedVal} | Acc])
  -      end;
  +      S2 = inject_variables(S),
  +      tokenize_expression(T, LN, break, [], [{val, S2} | Acc]);
       Val ->
         tokenize_expression(T, LN, break, [], [{val, Val} | Acc])
     end).
  
positive.code: process_rpn(_LN, [], [ResVal]) ->
    ResVal;
  process_rpn(LN, [], _) ->
    erlang:error("Cannot understand zss arithmetic expression- too many
      arguments line " ++ integer_to_list(LN));
  process_rpn(LN, [{N,Op} | T], [V2 | [V1 | Res]]) when is_integer(N) ->
    process_rpn(LN, T, [calculate(LN, Op, V1, V2) | Res]);
  process_rpn(LN, [V | T], Res) ->
  
negative.code:   {col,{?OP(O,R,N),?OP(O,G,N),?OP(O,B,N),A}};
  
  calculate(LN, Op, {Type, _}, {col, _}) ->
    erlang:error("Cannot '" + [Op] + "' a '" ++ Type ++
      "' and a color together- on line " ++ integer_to_list(LN));
  calculate(LN, Op, {col, _}, {Type, _}) ->
    erlang:error("Cannot '" + [Op] + "' a '" ++ Type ++
      "' and a color together- on line " ++ integer_to_list(LN));
  
  % Number to number
  calculate(_LN, O, {num, N1}, {num, N2}) ->
    {num, ?OP(O,N1,N2)};
  
  % Number to size
  calculate(_LN, O, {num, N1}, {Type, N2}) when is_integer(N2) or is_float(N2) ->
    {Type, ?OP(O,N1,N2)};
  calculate(_LN, O, {Type, N1}, {num, N2}) when is_integer(N1) or is_float(N1) ->
    {Type, ?OP(O,N1,N2)};
  
  % Size to size - simple case where they match first
  calculate(_LN, O, {Type, N1}, {Type, N2}) when is_integer(N1) or is_float(N1) ->
    {Type, ?OP(O,N1,N2)}.
  
  %calculate(_LN, O, {T1, N1}, {T2, N2}) when
  %    (is_integer(N1) or is_float(N1)) and
  %    (is_integer(N2) or is_float(N2)) ->
  
  
  
  
  
  translate_value({col, {R, G, B, 1}}) ->
  