--HG--

branch : pmacs2

code_examples/demo.scm

@@ -1,71 +1,72 @@
 ; a helper function which prints each argument seperated by a space
 (define output
-    (lambda (. things)
+        (lambda (. things)
-        (cond
+                (cond
-            ((null? things) (display #\newline))
+                  ((null? things) (display #\newline))
-            (else
+                  (else
-                (display (car things))
+                    (display (car things))
-                (display #\space)
+                    (display #\space)
-                (apply output (cdr things))))))
+                    (apply output (cdr things))))))
 
 ; a helper function which shows arguments before calling them
 (define explicit-apply
-    (lambda (f . args)
+        (lambda (f . args)
-        (let ((result (apply f args)))
+                (let ((result (apply f args)))
-            (output f args result)
+                     (output f args result)
-            result)))
+                     result)))
 
 ; determine whether or not a given attack roll will hit
 (define is-hit?
-    (lambda (roll attack ac)
+        (lambda (roll attack ac)
-        (or (= roll 20) (and (< 1 roll) (>= (+ roll attack) ac)))))
+                (or (= roll 20) (and (< 1 roll) (>= (+ roll attack) ac)))))
 
 ; determine whether or not a given attack roll will crit
 (define is-crit?
-    (lambda (roll attack ac threat)
+        (lambda (roll attack ac threat)
-        (or (= roll 20) (and (is-hit? roll attack ac) (>= roll threat)))))
+                (or (= roll 20) (and (is-hit? roll attack ac) (>= roll threat)))))
 
 ; determine the expected damage of a particular attack roll
 (define roll-dmg
-    (lambda (roll attack ac dmg threat mult)
+        (lambda (roll attack ac dmg threat mult)
-        (cond
+                (cond
-            ((is-crit? roll attack ac threat) (* dmg mult))
+                  ((is-crit? roll attack ac threat) (* dmg mult))
-            ((is-hit? roll attack ac) dmg)
+                  ((is-hit? roll attack ac) dmg)
-            (else 0))))
+                  (else 0))))
 
 ; determine the expected damage across all attack rolls
 (define expected-dmg
-    (lambda (. args)
+        (lambda (. args)
-        (define adder
+                (define adder
-            (lambda (total roll)
+                        (lambda (total roll)
-                (if (> roll 20)
+                                (if (> roll 20)
-                    total
+                                    total
-                    (adder (+ total (apply roll-dmg roll args)) (+ roll 1)))))
+                                    (adder (+ total (apply roll-dmg roll args))
-        (/ (adder 0 1) 20)))
+                                           (+ roll 1)))))
+                (/ (adder 0 1) 20)))
 
 ; find the best power attack score (and expected damage) versus an AC
 (define find-best-power
-    (lambda (power-max attack ac dmg threat mult)
+        (lambda (power-max attack ac dmg threat mult)
-        (define checker
+                (define checker
-            (lambda (power best-power best-dmg)
+                        (lambda (power best-power best-dmg)
-                (if (> power power-max)
+                                (if (> power power-max)
-                    (list best-power best-dmg)
+                                    (list best-power best-dmg)
-                    (let* ((a (- attack power))
+                                    (let* ((a (- attack power))
-                            (d (+ dmg power))
+                                           (d (+ dmg power))
-                            (ed (expected-dmg a ac d threat mult)))
+                                           (ed (expected-dmg a ac d threat mult)))
-                        (if (> ed best-dmg)
+                                          (if (> ed best-dmg)
-                            (checker (+ power 1) power ed)
+                                              (checker (+ power 1) power ed)
-                            (checker (+ power 1) best-power best-dmg))))))
+                                              (checker (+ power 1) best-power best-dmg))))))
-        (checker 0 0 0)))
+                (checker 0 0 0)))
 
 ; iterate across a range of armor classes
 (define iter
-    (let ((max-power 6)
+        (let ((max-power 6)
-            (attack 6)
+              (attack 6)
-            (dmg 5.5)
+              (dmg 5.5)
-            (threat 20)
+              (threat 20)
-            (mult 3))
+              (mult 3))
-        (lambda (ac max-ac)
+             (lambda (ac max-ac)
-            (explicit-apply find-best-power max-power attack ac dmg threat mult)
+                     (explicit-apply find-best-power max-power attack ac dmg threat mult)
-            (if (> ac max-ac) #f (iter (+ ac 1) max-ac)))))
+                     (if (> ac max-ac) #f (iter (+ ac 1) max-ac)))))
 (iter 10 30)

mode/lisp.py

@@ -24,20 +24,21 @@ class LispTabber(tab2.StackTabber):
         if rtoken is not None and rtoken.string != '(':
             rtoken = self.get_next_right_token(y, i + 1)
         if rtoken is None:
-            level = self.get_curr_level() + 4
+            level = self.get_curr_level() + self.mode.tabwidth
         else:
             level = rtoken.x
         self._append(token.string, level)
         return currlvl
 
 class Lisp(mode2.Fundamental):
+    tabwidth    = 2
     tabbercls   = LispTabber
     grammar     = LispGrammar
     opentokens  = ('delimiter',)
     opentags    = {'(': ')'}
     closetokens = ('delimiter',)
     closetags   = {')': '('}
-    colors = {
+    colors      = {
         'comment': ('red', 'default'),
         'string.start':   ('green', 'default'),
         'string.null':    ('green', 'default'),

mode/scheme.py

@@ -26,13 +26,14 @@ class SchemeGrammar(Grammar):
     ]
 
 class Scheme(mode2.Fundamental):
+    tabwidth    = 2
     tabbercls   = mode.lisp.LispTabber
     grammar     = SchemeGrammar
     opentokens  = ('delimiter',)
     opentags    = {'(': ')'}
     closetokens = ('delimiter',)
     closetags   = {')': '('}
-    colors = {
+    colors      = {
         'comment': ('red', 'default'),
 
         'keyword': ('cyan', 'default'),

tab2.py

@@ -154,7 +154,8 @@ class StackTabber(Tabber):
         token  = self.get_token(y, i)
         rtoken = self.get_next_right_token(y, i)
         if rtoken is None:
-            level = self.get_curr_level() + 4
+            #level = self.get_curr_level() + 4
+            level = self.get_curr_level() + self.mode.tabwidth
         else:
             level = rtoken.x
         self._append(token.string, level)