about summary refs log tree commit diff stats
path: root/dwm.c
diff options
context:
space:
mode:
authorAnselm R Garbe <garbeam@gmail.com>2008-08-18 09:49:44 +0100
committerAnselm R Garbe <garbeam@gmail.com>2008-08-18 09:49:44 +0100
commit2dc7f42fd7fc8f1fc8d837265221654e8565eb6b (patch)
treee67ec1b63848ffb117b4e29e09130000c7fefdf5 /dwm.c
parent9f3a5cb7540df6628c9c8a8bd7a8667a73f08fb1 (diff)
downloaddwm-2dc7f42fd7fc8f1fc8d837265221654e8565eb6b.tar.gz
applied Martin Hurton's view() simplification, not checking arg
Diffstat (limited to 'dwm.c')
-rw-r--r--dwm.c4
1 files changed, 2 insertions, 2 deletions
diff --git a/dwm.c b/dwm.c
index 7d99390..c31343c 100644
--- a/dwm.c
+++ b/dwm.c
@@ -1640,10 +1640,10 @@ updatewmhints(Client *c) {
 
 void
 view(const Arg *arg) {
-	if(arg && (arg->ui & TAGMASK) == tagset[seltags])
+	if((arg->ui & TAGMASK) == tagset[seltags])
 		return;
 	seltags ^= 1; /* toggle sel tagset */
-	if(arg && (arg->ui & TAGMASK))
+	if(arg->ui & TAGMASK)
 		tagset[seltags] = arg->ui & TAGMASK;
 	clearurgent();
 	arrange();
#
#
#           The Nimrod Compiler
#        (c) Copyright 2008 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# Implements a table from trees to trees. Does structural equavilent checking.

import 
  nhashes, ast, astalgo, types

proc NodeTableGet*(t: TNodeTable, key: PNode): int
proc NodeTablePut*(t: var TNodeTable, key: PNode, val: int)
proc NodeTableTestOrSet*(t: var TNodeTable, key: PNode, val: int): int
# implementation

proc hashTree(n: PNode): THash = 
  result = 0
  if n == nil: return 
  result = ord(n.kind)
  case n.kind
  of nkEmpty, nkNilLit, nkType: 
    nil
  of nkIdent: 
    result = concHash(result, n.ident.h)
  of nkSym: 
    result = concHash(result, n.sym.name.h)
  of nkCharLit..nkInt64Lit: 
    if (n.intVal >= low(int)) and (n.intVal <= high(int)): 
      result = concHash(result, int(n.intVal))
  of nkFloatLit..nkFloat64Lit: 
    if (n.floatVal >= - 1000000.0) and (n.floatVal <= 1000000.0): 
      result = concHash(result, toInt(n.floatVal))
  of nkStrLit..nkTripleStrLit: 
    result = concHash(result, GetHashStr(n.strVal))
  else: 
    for i in countup(0, sonsLen(n) - 1): 
      result = concHash(result, hashTree(n.sons[i]))
  
proc TreesEquivalent(a, b: PNode): bool = 
  result = false
  if a == b: 
    result = true
  elif (a != nil) and (b != nil) and (a.kind == b.kind): 
    case a.kind
    of nkEmpty, nkNilLit, nkType: result = true
    of nkSym: result = a.sym.id == b.sym.id
    of nkIdent: result = a.ident.id == b.ident.id
    of nkCharLit..nkInt64Lit: result = a.intVal == b.intVal
    of nkFloatLit..nkFloat64Lit: result = a.floatVal == b.floatVal
    of nkStrLit..nkTripleStrLit: result = a.strVal == b.strVal
    else: 
      if sonsLen(a) == sonsLen(b): 
        for i in countup(0, sonsLen(a) - 1): 
          if not TreesEquivalent(a.sons[i], b.sons[i]): return 
        result = true
    if result: result = sameTypeOrNil(a.typ, b.typ)
  
proc NodeTableRawGet(t: TNodeTable, k: THash, key: PNode): int = 
  var h: THash
  h = k and high(t.data)
  while t.data[h].key != nil: 
    if (t.data[h].h == k) and TreesEquivalent(t.data[h].key, key): 
      return h
    h = nextTry(h, high(t.data))
  result = - 1

proc NodeTableGet(t: TNodeTable, key: PNode): int = 
  var index: int
  index = NodeTableRawGet(t, hashTree(key), key)
  if index >= 0: result = t.data[index].val
  else: result = low(int)
  
proc NodeTableRawInsert(data: var TNodePairSeq, k: THash, key: PNode, val: int) = 
  var h: THash
  h = k and high(data)
  while data[h].key != nil: h = nextTry(h, high(data))
  assert(data[h].key == nil)
  data[h].h = k
  data[h].key = key
  data[h].val = val

proc NodeTablePut(t: var TNodeTable, key: PNode, val: int) = 
  var 
    index: int
    n: TNodePairSeq
    k: THash
  k = hashTree(key)
  index = NodeTableRawGet(t, k, key)
  if index >= 0: 
    assert(t.data[index].key != nil)
    t.data[index].val = val
  else: 
    if mustRehash(len(t.data), t.counter): 
      newSeq(n, len(t.data) * growthFactor)
      for i in countup(0, high(t.data)): 
        if t.data[i].key != nil: 
          NodeTableRawInsert(n, t.data[i].h, t.data[i].key, t.data[i].val)
      swap(t.data, n)
    NodeTableRawInsert(t.data, k, key, val)
    inc(t.counter)

proc NodeTableTestOrSet(t: var TNodeTable, key: PNode, val: int): int = 
  var 
    index: int
    n: TNodePairSeq
    k: THash
  k = hashTree(key)
  index = NodeTableRawGet(t, k, key)
  if index >= 0: 
    assert(t.data[index].key != nil)
    result = t.data[index].val
  else: 
    if mustRehash(len(t.data), t.counter): 
      newSeq(n, len(t.data) * growthFactor)
      for i in countup(0, high(t.data)): 
        if t.data[i].key != nil: 
          NodeTableRawInsert(n, t.data[i].h, t.data[i].key, t.data[i].val)
      swap(t.data, n)
    NodeTableRawInsert(t.data, k, key, val)
    result = val
    inc(t.counter)