Author: yamakenz
Date: Sat May 10 04:54:01 2008
New Revision: 5480

Added:
  trunk/scm/composer.scm
     - copied, changed from r5479, /branches/composer/scm/composer.scm
  trunk/scm/event.scm
     - copied, changed from r5479, /branches/composer/scm/event.scm
  trunk/scm/ng-action.scm
     - copied, changed from r5479, /branches/composer/scm/ng-action.scm
  trunk/scm/ng-key.scm
     - copied, changed from r5479, /branches/composer/scm/ng-key.scm
  trunk/test/test-ng-key.scm
     - copied, changed from r5479, /branches/composer/test/test-ng-key.scm

Log:
* This commit port some of core files of composer framework from
 the composer branch, and adapt to SigScheme. These codes also need overhaul

* scm/event.scm
 - Update and fix copyright
 - Temporarily disable utext.scm
 - (%HYPHEN-SYM): new variable
 - (define-event):
   * Fix broken field spec preparation
   * Adapt to SigScheme
 - (key-event-inspect): Adapt to SigScheme
* scm/ng-key.scm
 - Update and fix copyright
 - Temporarily disable key-custom.scm
 - (mod_ignore_Shift, mod_ignore_Control, mod_ignore_Alt,
   mod_ignore_Meta, mod_ignore_Super, mod_ignore_Hyper): Shift
   value assignments to be capable by storage-compact
 - (modifier-shift-mask, modifier-control-mask,
   modifier-alt-mask, modifier-meta-mask, modifier-super-mask,
   modifier-hyper-mask, modifier-aggregate): Replace bitwise-or
   with bitwise-ior
* scm/ng-action.scm
 - Update copyright
* scm/composer.scm
 - Update copyright
 - Temporarily disable utext.scm
* test/test-ng-key.scm
 - Update and fix copyright
 - Replace bitwise-or with bitwise-ior
 - Temporarily disable physical-key.scm


Copied: trunk/scm/composer.scm (from r5479, /branches/composer/scm/composer.scm)
==============================================================================
--- /branches/composer/scm/composer.scm (original)
+++ trunk/scm/composer.scm      Sat May 10 04:54:01 2008
@@ -1,6 +1,6 @@
;;; composer.scm: The composer framework for uim
;;;
-;;; Copyright (c) 2005 uim Project http://uim.freedesktop.org/
+;;; Copyright (c) 2005-2008 uim Project http://code.google.com/p/uim/
;;;
;;; All rights reserved.
;;;
@@ -35,7 +35,7 @@
(require "i18n.scm")
(require "event.scm")
(require "ustr.scm")
-(require "utext.scm")
+;;(require "utext.scm")
(require "ng-action.scm")



Copied: trunk/scm/event.scm (from r5479, /branches/composer/scm/event.scm)
==============================================================================
--- /branches/composer/scm/event.scm    (original)
+++ trunk/scm/event.scm Sat May 10 04:54:01 2008
@@ -1,6 +1,6 @@
;;; event.scm: Event definitions
;;;
-;;; Copyright (c) 2004-2005 uim Project http://uim.freedesktop.org/
+;;; Copyright (c) 2004-2008 uim Project http://code.google.com/p/uim/
;;;
;;; All rights reserved.
;;;
@@ -16,10 +16,10 @@
;;;    may be used to endorse or promote products derived from this software
;;;    without specific prior written permission.
;;;
-;;; THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
;;; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
;;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
;;; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -35,9 +35,11 @@
;; on loose relationships.  -- YamaKen 2005-02-18

(require "util.scm")
-(require "utext.scm")
+;;(require "utext.scm")
(require "ng-key.scm")

+(define %HYPHEN-SYM (string->symbol "-"))
+
;;
;; event definitions
;;
@@ -78,18 +80,20 @@
(define define-event
  (lambda args
    (let* ((name (car args))
-           (base-spec (alist-replace (cons 'type name)
+           (base-spec (alist-replace (list 'type name)
                                     (cadr args)))
-           (ext-spec (cddr args))
+           (ext-spec (if (null? (cddr args))
+                        '()
+                        (car (cddr args))))
           (base-defaults (map cadr base-spec))
           (ext-defaults (map cadr ext-spec))
           (creator (lambda args
                      (append base-defaults
                              args
                              (list-tail ext-defaults (length args))))))
-      (define-record (symbolconc name '-event) (append base-spec ext-spec))
-      (eval (list 'define (symbolconc name '-event-new) creator)
-           toplevel-env)
+ (define-record (symbolconc name %HYPHEN-SYM 'event) (append base-spec ext-spec))
+      (eval (list 'define (symbolconc name %HYPHEN-SYM 'event-new) creator)
+           (interaction-environment))
      (set! valid-event-types (cons name valid-event-types)))))

(define event-external-state
@@ -254,10 +258,10 @@
         "-")
     " "
     (symbol->string (or (key-event-lkey ev)
-                        '-))
+                        %HYPHEN-SYM))
     " "
     (symbol->string (or (key-event-pkey ev)
-                        '-))
+                        %HYPHEN-SYM))
     " ("
     (string-join
      " "

Copied: trunk/scm/ng-action.scm (from r5479, 
/branches/composer/scm/ng-action.scm)
==============================================================================
--- /branches/composer/scm/ng-action.scm        (original)
+++ trunk/scm/ng-action.scm     Sat May 10 04:54:01 2008
@@ -1,6 +1,6 @@
;;; ng-action.scm: Action handling framework for uim (next generation)
;;;
-;;; Copyright (c) 2005 uim Project http://uim.freedesktop.org/
+;;; Copyright (c) 2005-2008 uim Project http://code.google.com/p/uim/
;;;
;;; All rights reserved.
;;;

Copied: trunk/scm/ng-key.scm (from r5479, /branches/composer/scm/ng-key.scm)
==============================================================================
--- /branches/composer/scm/ng-key.scm   (original)
+++ trunk/scm/ng-key.scm        Sat May 10 04:54:01 2008
@@ -1,6 +1,6 @@
-;;; ng-key.scm: Key definitions and utilities
+;;; ng-key.scm: Key definitions and utilities (next generation)
;;;
-;;; Copyright (c) 2005 uim Project http://uim.freedesktop.org/
+;;; Copyright (c) 2005-2008 uim Project http://code.google.com/p/uim/
;;;
;;; All rights reserved.
;;;
@@ -16,10 +16,10 @@
;;;    may be used to endorse or promote products derived from this software
;;;    without specific prior written permission.
;;;
-;;; THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
;;; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
;;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
;;; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -30,7 +30,7 @@
;;;;

(require "util.scm")
-(require-custom "key-custom.scm")
+;;(require-custom "key-custom.scm")  ;; FIXME: temporarily disabled

;;
;; modifiers
@@ -92,29 +92,29 @@
(define mod_Caps_Lock      262144)
;;(define  524288)
;;(define  1048576)
-;;(define  2097152)
-;;(define  4194304)
-;;(define  8388608)
-;;(define  16777216)
-(define mod_ignore_Shift   33554432)
-(define mod_ignore_Control 67108864)
-(define mod_ignore_Alt     134217728)
-(define mod_ignore_Meta    268435456)
-(define mod_ignore_Super   536870912)
-(define mod_ignore_Hyper   1073741824)
+(define mod_ignore_Shift   2097152)
+(define mod_ignore_Control 4194304)
+(define mod_ignore_Alt     8388608)
+(define mod_ignore_Meta    16777216)
+(define mod_ignore_Super   33554432)
+(define mod_ignore_Hyper   67108864)
+;;(define  134217728)  ;; incapable by storage-compact
+;;(define  268435456)  ;; incapable by storage-compact
+;;(define  536870912)  ;; incapable by storage-compact
+;;(define  1073741824) ;; incapable by storage-compact

(define modifier-shift-mask
-  (bitwise-or mod_Shift_L   mod_Shift_R   mod_Shift))
+  (bitwise-ior mod_Shift_L   mod_Shift_R   mod_Shift))
(define modifier-control-mask
-  (bitwise-or mod_Control_L mod_Control_R mod_Control))
+  (bitwise-ior mod_Control_L mod_Control_R mod_Control))
(define modifier-alt-mask
-  (bitwise-or mod_Alt_L     mod_Alt_R     mod_Alt))
+  (bitwise-ior mod_Alt_L     mod_Alt_R     mod_Alt))
(define modifier-meta-mask
-  (bitwise-or mod_Meta_L    mod_Meta_R    mod_Meta))
+  (bitwise-ior mod_Meta_L    mod_Meta_R    mod_Meta))
(define modifier-super-mask
-  (bitwise-or mod_Super_L   mod_Super_R   mod_Super))
+  (bitwise-ior mod_Super_L   mod_Super_R   mod_Super))
(define modifier-hyper-mask
-  (bitwise-or mod_Hyper_L   mod_Hyper_R   mod_Hyper))
+  (bitwise-ior mod_Hyper_L   mod_Hyper_R   mod_Hyper))


;; API
@@ -139,7 +139,7 @@
                                                (not (= self-mods 0)))
                                           mod
                                           self-mods))))))
-      (bitwise-or (aggregate-mod-group self flags mod_Shift mod_ignore_Shift
+      (bitwise-ior (aggregate-mod-group self flags mod_Shift mod_ignore_Shift
                                       modifier-shift-mask)
                  (aggregate-mod-group self flags mod_Control mod_ignore_Control
                                       modifier-control-mask)

Copied: trunk/test/test-ng-key.scm (from r5479, 
/branches/composer/test/test-ng-key.scm)
==============================================================================
--- /branches/composer/test/test-ng-key.scm     (original)
+++ trunk/test/test-ng-key.scm  Sat May 10 04:54:01 2008
@@ -1,6 +1,6 @@
#!/usr/bin/env gosh

-;;; Copyright (c) 2005 uim Project http://uim.freedesktop.org/
+;;; Copyright (c) 2005-2008 uim Project http://code.google.com/p/uim/
;;;
;;; All rights reserved.
;;;
@@ -16,10 +16,10 @@
;;;    may be used to endorse or promote products derived from this software
;;;    without specific prior written permission.
;;;
-;;; THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
;;; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
;;; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
;;; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -104,27 +104,27 @@
   (assert-true  (uim-bool '(modifier-has? mod_ignore_Shift mod_ignore_Shift)))
   (assert-false (uim-bool '(modifier-has? mod_ignore_Shift mod_Caps_Lock)))

-   (assert-true  (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-true  (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_None)))
-   (assert-true  (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-true  (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift)))
-   (assert-true  (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-true  (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_L)))
-   (assert-true  (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-true  (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_R)))
-   (assert-false (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-false (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_ignore_Shift)))
-   (assert-false (uim-bool '(modifier-has? (bitwise-or mod_Shift
+   (assert-false (uim-bool '(modifier-has? (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Caps_Lock)))
@@ -180,54 +180,54 @@
   (assert-equal (uim 'mod_ignore_Shift)
                 (uim '(modifier-aggregate mod_Shift mod_ignore_Shift)))

-   (assert-equal (uim '(bitwise-or mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift_L
+   (assert-equal (uim '(bitwise-ior mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift_L
                                                       mod_Shift_R)
                                           mod_None)))
-   (assert-equal (uim '(bitwise-or mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift_L
+   (assert-equal (uim '(bitwise-ior mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_L)))
-   (assert-equal (uim '(bitwise-or mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift_L
+   (assert-equal (uim '(bitwise-ior mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_R)))
   (assert-equal (uim 'mod_Shift)
-                (uim '(modifier-aggregate (bitwise-or mod_Shift_L
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift)))
   (assert-equal (uim 'mod_ignore_Shift)
-                (uim '(modifier-aggregate (bitwise-or mod_Shift_L
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift_L
                                                       mod_Shift_R)
                                           mod_ignore_Shift)))

-   (assert-equal (uim '(bitwise-or mod_Shift mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+   (assert-equal (uim '(bitwise-ior mod_Shift mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_None)))
-   (assert-equal (uim '(bitwise-or mod_Shift mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+   (assert-equal (uim '(bitwise-ior mod_Shift mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_L)))
-   (assert-equal (uim '(bitwise-or mod_Shift mod_Shift_L mod_Shift_R))
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+   (assert-equal (uim '(bitwise-ior mod_Shift mod_Shift_L mod_Shift_R))
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift_R)))
   (assert-equal (uim 'mod_Shift)
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_Shift)))
   (assert-equal (uim 'mod_ignore_Shift)
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R)
                                           mod_ignore_Shift)))
   (assert-equal (uim 'mod_ignore_Shift)
-                (uim '(modifier-aggregate (bitwise-or mod_Shift
+                (uim '(modifier-aggregate (bitwise-ior mod_Shift
                                                       mod_Shift_L
                                                       mod_Shift_R
                                                       mod_ignore_Shift)
@@ -241,13 +241,13 @@
   (assert-true  (uim-bool '(modifier-match? mod_None mod_ignore_Shift)))
   (assert-false (uim-bool '(modifier-match? mod_None mod_Caps_Lock)))
   (assert-false (uim-bool '(modifier-match? mod_None
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_ignore_Shift))))
   (assert-false (uim-bool '(modifier-match? mod_None
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_ignore_Shift))))
   (assert-false (uim-bool '(modifier-match? mod_None
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_R
                                                         mod_Shift_L
                                                         mod_ignore_Shift))))
@@ -259,10 +259,10 @@
   (assert-false (uim-bool '(modifier-match? mod_Shift mod_ignore_Shift)))
   (assert-false (uim-bool '(modifier-match? mod_Shift mod_Caps_Lock)))
   (assert-true  (uim-bool '(modifier-match? mod_Shift
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R))))
   (assert-true  (uim-bool '(modifier-match? mod_Shift
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R))))

@@ -273,7 +273,7 @@
   (assert-false (uim-bool '(modifier-match? mod_Shift_L mod_ignore_Shift)))
   (assert-false (uim-bool '(modifier-match? mod_Shift_L mod_Caps_Lock)))
   (assert-false (uim-bool '(modifier-match? mod_Shift_L
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R))))

   (assert-false (uim-bool '(modifier-match? mod_Shift_R mod_None)))
@@ -290,251 +290,251 @@
   (assert-true  (uim-bool '(modifier-match? mod_ignore_Shift 
mod_ignore_Shift)))
   (assert-false (uim-bool '(modifier-match? mod_ignore_Shift mod_Caps_Lock)))
   (assert-true  (uim-bool '(modifier-match? mod_ignore_Shift
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R))))
   (assert-false (uim-bool '(modifier-match? mod_ignore_Shift
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_L))))

   ;; multiple modifiers
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_None)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift_L)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_Control_L)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control_L))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Control_L))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control
                                                         mod_Control_L))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift_R)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_ignore_Shift)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_Shift_L
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_Shift_L
                                                         mod_Control_L)
                                             mod_Caps_Lock)))

   ;; multiple modifiers with ignore_Shift
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_None)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift_L)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_Control_L)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control_L))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Control_L))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control
                                                         mod_Control_L))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control))))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_Shift_R)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_ignore_Shift)))
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Shift_L
                                                         mod_Control_L)
                                             mod_Caps_Lock)))

   ;; ignoring Shift
-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_None)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_Control_L)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_Control_R)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_Control)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Control_L
+                                            (bitwise-ior mod_Control_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Control
+                                            (bitwise-ior mod_Control
                                                         mod_Control_L
                                                         mod_Control_R))))

-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_Shift)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Control_L))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Control))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Control_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Control
                                                         mod_Control_L
                                                         mod_Control_R))))

-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
                                             mod_Shift_L)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control_L))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Control
                                                         mod_Control_L
                                                         mod_Control_R))))

-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_L))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift_L
+                                            (bitwise-ior mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control
                                                         mod_Control_L
                                                         mod_Control_R))))

-   (assert-false (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-false (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_L))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control_L
                                                         mod_Control_R))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_Control)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control
@@ -542,28 +542,28 @@
                                                         mod_Control_R))))

   ;; ignoring multiple modifiers
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_ignore_Control
                                                         mod_Alt)
                                             mod_Alt)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_ignore_Control
                                                         mod_Alt)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control
                                                         mod_Control_L
                                                         mod_Control_R
                                                         mod_Alt))))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_ignore_Control
                                                         mod_ignore_Alt)
                                             mod_None)))
-   (assert-true  (uim-bool '(modifier-match? (bitwise-or mod_ignore_Shift
+   (assert-true  (uim-bool '(modifier-match? (bitwise-ior mod_ignore_Shift
                                                         mod_ignore_Control
                                                         mod_ignore_Alt)
-                                            (bitwise-or mod_Shift
+                                            (bitwise-ior mod_Shift
                                                         mod_Shift_L
                                                         mod_Shift_R
                                                         mod_Control
@@ -599,14 +599,16 @@
   (assert-false (uim-bool '(physical-key? 'pkey_qwerty_0)))
   (assert-false (uim-bool '(physical-key? 'pkey_qwerty_a)))
   (assert-false (uim-bool '(physical-key? 'pkey_jp106_yen)))
-   (uim '(require "physical-key.scm"))
-   (assert-false (uim-bool '(physical-key? 'pkey_Nonexistent)))
-   (assert-false (uim-bool '(physical-key? 'lkey_a)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_VoidSymbol)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_BackSpace)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_Shift_L)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_F1)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_space)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_0)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_qwerty_a)))
-   (assert-true  (uim-bool '(physical-key? 'pkey_jp106_yen)))))
+   ;; Temporarily disabled  -- YamaKen 2008-05-10
+   ;;(uim '(require "physical-key.scm"))
+   ;;(assert-false (uim-bool '(physical-key? 'pkey_Nonexistent)))
+   ;;(assert-false (uim-bool '(physical-key? 'lkey_a)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_VoidSymbol)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_BackSpace)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_Shift_L)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_F1)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_space)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_0)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_qwerty_a)))
+   ;;(assert-true  (uim-bool '(physical-key? 'pkey_jp106_yen)))
+   ))

Reply via email to