10$B?J?t$+$i(B16$B?J?t$X$NJQ49(B
KOSEKI Yoshinori
四則演算は、例えば100 + 2を行いたい時は
(+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
ができますが、このような簡単な操作で10進数を16進数に変換する
方法はないですか?
16進数から10進数への変換もできませんか?
#見ただけで暗算できるのが近くにいて便利だったのですが、あい
#にく転職してしまったもので。
--
\def\KOSE{{{\rm K}\kern-.1em\raise-.4ex\hbox{$\heartsuit $}\kern-.05em%
{\rm S}\kern-.05em\lower.4ex\hbox{\rm E}}}
\KOSE @wizard.tamra.co.jp
Shigenobu Kimura
In article <xjcybcs...@dwarf.wizard.tamra.co.jp>,
ko...@wizard.tamra.co.jp (KOSEKI Yoshinori) writes:
> 四則演算は、例えば100 + 2を行いたい時は
> (+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
> ができますが、このような簡単な操作で10進数を16進数に変換する
> 方法はないですか?
> 16進数から10進数への変換もできませんか?
(format "%x" 65535) -> "ffff"
逆は面倒かも知れませんね.
unix の printf(1) を使って
% printf "%d" 0xffff
が一番簡単かな?
$MULE/lisp で grep hexadecimal *.el したら
hexl.el の中に hexl-hex-string-to-integer という関数が
ありました. きっとこれで出来ます.
--
きむら
ISOYAMA Hideyuki
いそやま＠ＮＴＴデータです。
>>>>> In <xjcybcs...@dwarf.wizard.tamra.co.jp>
>>>>> ko...@wizard.tamra.co.jp (KOSEKI Yoshinori) wrote:
> (+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
> ができますが、このような簡単な操作で10進数を16進数に変換する
> 方法はないですか?
> 16進数から10進数への変換もできませんか?
おそらく、「mule の中でやりたい」のだと思いますのでちょっと
外れますけど、このような時は私は dc を使います。
[10進->16進]
% dc
16o <-16進で出力
255p
FF
^D
[16進->10進]
% dc
16i <-16進で入力
F0p
240
FFFFp
65535
^D
16i8o なら、16進->8進です。
--
いそやま＠ＮＴＴデータ
Ballroom Dancer
引越しました→ http://www.amnet.co.jp/home2/isoyama/
ueh...@gate.biz.ntts.co.jp
NTTソフトウェアの上原と申します。
In article <xjcybcs...@dwarf.wizard.tamra.co.jp> ko...@wizard.tamra.co.jp (KOSEKI Yoshinori) writes:
>>四則演算は、例えば100 + 2を行いたい時は
>>(+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
>>ができますが、このような簡単な操作で10進数を16進数に変換する
>>方法はないですか?
>>16進数から10進数への変換もできませんか?
10進数→16進数はすでにformatを使うというフォローがついておりますので、
(defun h2d(n x)
(if (null (cdr x))
(+ n (car x))
(h2d (*(+ n (car x)) 16) (cdr x))))
(defun hex2dec(s)
(h2d 0 (mapcar '(lambda(x)
(cond
((and (<= ?0 x) (<= x ?9)) (- x ?0))
((and (<= ?a x) (<= x ?f)) (+ (- x ?a) 10))))
s)))
としておいて
(hex2dec "fff")
4095
などと。
>>#見ただけで暗算できるのが近くにいて便利だったのですが、あい
>>#にく転職してしまったもので。
私はそういう計算はだいたいコマンドラインから
perl -e 'printf("%d",0xff)'
とかしますけどね。
--
§ NTTS○FT ニュービジネス事業本部第1事業部 上原 潤二 §
Hideaki Nobata
Mule の話じゃないんですが…、ちょっとだけ。
>> On 14 Feb 1997 20:07:12 JST, ueh...@gate.biz.ntts.co.jp said:
> 私はそういう計算はだいたいコマンドラインから
> perl -e 'printf("%d",0xff)'
> とかしますけどね。
それなら単純に、
perl -e 'print 0xff'
でいいと思います。
あるいは、printf(1) があれば、
printf '%d' 0xff
とか。
--
金沢大学大学院 工学研究科 電気・情報工学専攻 木村研究室 M2
野畠 英明 mailto:no...@blitz.ec.t.kanazawa-u.ac.jp
http://blitz.ec.t.kanazawa-u.ac.jp/%7Enova/
PGP fingerprint: D3 D4 A6 B2 A7 9B 2C C7 38 F3 73 A2 B8 57 CF EA
KATAYAMA Yoshio
In article <SKIMU.97F...@ninigi.phys.s.u-tokyo.ac.jp>,
sk...@komachi.phys.s.u-tokyo.ac.jp (Shigenobu Kimura) writes:
>In article <xjcybcs...@dwarf.wizard.tamra.co.jp>,
> ko...@wizard.tamra.co.jp (KOSEKI Yoshinori) writes:
>> 四則演算は、例えば100 + 2を行いたい時は
>> (+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
>> ができますが、このような簡単な操作で10進数を16進数に変換する
>> 方法はないですか?
>> 16進数から10進数への変換もできませんか?
>(format "%x" 65535) -> "ffff"
>逆は面倒かも知れませんね.
?\xffff ← ここにカーソルを持ってきて C-u C-x C-e
＃この方法は emacs 18.* ではダメみたい
--
片山＠ＰＦＵ
Inaba Hiroto
In article <UEHARA.97F...@gate.sed.ntts.co.jp> ueh...@gate.biz.ntts.co.jp writes:
> In article <xjcybcs...@dwarf.wizard.tamra.co.jp> ko...@wizard.tamra.co.jp (KOSEKI Yoshinori) writes:
> >>四則演算は、例えば100 + 2を行いたい時は
> >>(+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
> >>ができますが、このような簡単な操作で10進数を16進数に変換する
> >>方法はないですか?
> >>16進数から10進数への変換もできませんか?
> 10進数→16進数はすでにformatを使うというフォローがついておりますので、
> (defun h2d(n x)
:
> (defun hex2dec(s)
:
> としておいて
> (hex2dec "fff")
> 4095
> などと。
?\xfff の後で C-u C-x C-e で 4095 じゃだめですか？
> 私はそういう計算はだいたいコマンドラインから
> perl -e 'printf("%d",0xff)'
> とかしますけどね。
perl -le 'print 0xff'
でできますね。(10進→16進は perl -e 'printf"%x\n",4095'ですけど)
--
稲葉 浩人 (in...@st.rim.or.jp)
Shigenobu Kimura
In article <KATE.97Fe...@yamato.trad.pfu.co.jp>,
ka...@pfu.co.jp (KATAYAMA Yoshio) writes:
> ?\xffff ← ここにカーソルを持ってきて C-u C-x C-e
あああ本当ですね. でも Emacs Lisp Refference Manual には
載ってませんでした.
ところで, mule と emacs で文字のビット数って同じなんでしょうか?
--
きむら
Yoshinori Kishimoto
岸本＠中央電子です.
>>>>> In <xjcybcs...@dwarf.wizard.tamra.co.jp>,
ko...@wizard.tamra.co.jp wrote:
>四則演算は、例えば100 + 2を行いたい時は
>(+ 100 2)と入力後 C-u C-x C-eで演算結果をそこに展開すること
>ができますが、このような簡単な操作で10進数を16進数に変換する
>方法はないですか?
>16進数から10進数への変換もできませんか?
以前, 「muleのbuffer内で基数変換と簡単な計算でけん?」といっ
て作ってもらったパッケージ(tcalc.el)が手元にあるので, 付けと
きます.
load-libraryしたあと, M-x tcalc-modeで使えるようになります.
[機能]
基数変換
C-c o 8進へ変換
C-c j 10進へ変換
C-c h 16進へ変換
計算
C-c e 現在行の計算(置き換え)
C-u C-c e 現在行の計算(数式の後に追加)
現在行の計算は行内の数式は一つと仮定している.
C-c r リージョンの計算
リージョンの計算の仕様は前回と同じ.
その他
C-c C-s 出力時の数値表現の選択(c/lisp/intel/motorola)
C-c C-b 出力時の基数選択
C-c C-u 出力の case を toggle
C-u C-c C-u 出力を upcase
C-u - C-c C-u 出力を downcase
C-c C-p プリフィックス文字列の書き換え
---------- cut ---------- cut ---------- cut ---------- cut ----------
;;; -*- emacs-lisp -*-
;;;
;;; $Id: tcalc.el,v 1.3 1995/05/19 01:57:05 kom Exp $
;;;
;;; trivial calculator for inline expressions
;;;
(require 'cl)
(defvar tcalc-format-style 'c
"format style 'c, 'lisp, 'intel or 'motrola")
(defvar tcalc-format-radix 'dec
"indicator to use which format")
(defvar tcalc-output-upcase nil
"convert output string to upcase if this variable set non-nil")
(defvar tcalc-format-style-alist
'((c "0%o" "%d" "0x%x")
(lisp "#o%o" "%d" "#x%x")
(intel "%oo" "%d" "0%xh")
(motorola "@%o" "%d" "$%x"))
"categolized format sttyle")
(defvar tcalc-insert-prefix " = "
"output prefix for an equation")
(defconst tcalc-radix-alist
'(("octal" . oct)
("decimal" . dec)
("hexadecimal" . hex))
"Alist for completing radix input")
(defconst tcalc-style-alist
'(("c" . c)
("lisp" . lisp)
("intel" . intel)
("motorola" . motorola))
"alist for completing style input")
;;;
;;; minor mode for providing trivial calculation.
;;;
(defvar tcalc-mode nil)
(defun tcalc-mode (&optional arg)
"Toggle tcalc-mode.
With arg, turn numeric-conversion mode on if and only if arg is positive.
In nemeric-conversion mode, it convert a hexadecimal number, near the
point, to decimal number by C-c C-d, and also it converts a decimal
number to hexadecimal number by C-c C-x."
(interactive "P")
(let (map)
(and (setq tcalc-mode
(if (null arg)
(not tcalc-mode)
(> (prefix-numeric-value arg) 0)))
(or (assq 'tcalc-mode minor-mode-alist)
(setq minor-mode-alist
(cons '(tcalc-mode " tcalc")
minor-mode-alist)))
(or (assq 'tcalc-mode minor-mode-map-alist)
(progn
(setq map (make-sparse-keymap))
(define-key map [?\C-c ?o] 'tcalc-convert-to-oct)
(define-key map [?\C-c ?j] 'tcalc-convert-to-dec)
(define-key map [?\C-c ?h] 'tcalc-convert-to-hex)
(define-key map [?\C-c ?e] 'tcalc-calc-last-expr)
(define-key map [?\C-c ?r] 'tcalc-calc-region)
(define-key map [?\C-c ?\C-u] 'tcalc-toggle-output-case)
(define-key map [?\C-c ?\C-p] 'tcalc-set-prefix)
(define-key map [?\C-c ?\C-s] 'tcalc-set-style)
(define-key map [?\C-c ?\C-b] 'tcalc-set-radix)
(setq minor-mode-map-alist
(cons (cons 'tcalc-mode map)
minor-mode-map-alist))))
)))
;;
;; utilities
;;
(defun tcalc-set-style ()
(interactive)
(let ((style (completing-read "Select style: "
tcalc-style-alist nil t nil nil)))
(setq tcalc-format-style (cdr (assoc style tcalc-style-alist)))
))
(defun tcalc-set-radix ()
(interactive)
(let ((radix (completing-read "Select radix: "
tcalc-radix-alist nil t nil nil)))
(setq tcalc-format-radix (cdr (assoc radix tcalc-radix-alist)))
))
(defun tcalc-set-prefix ()
(interactive)
(setq tcalc-insert-prefix (read-from-minibuffer "Input prefix: ")))
(defun tcalc-toggle-output-case (&optional arg)
(interactive "P")
(message "%s" arg)
(cond ((null arg)
(setq tcalc-output-upcase (not tcalc-output-upcase)))
((eq arg '-)
(setq tcalc-output-upcase nil))
(t
(setq tcalc-output-upcase t))))
;;
;; front end of expression evaluator
;;
(defun tcalc-calc-region ()
"Calucurate expressions in region.
Expressions are notated as:
[ <expression> ]
replace ``[ <expression> ]'' by resolt,
[ <expression> ]=
remove ``['' and ``]'', then replace ``='' by concatinated
string, made from ``tcalc-insert-prefix'' and resolt."
(interactive)
(narrow-to-region (region-beginning) (region-end))
(goto-char (point-min))
(catch 'error-status
(while (search-forward "[" nil t nil)
(backward-char 1)
(if (not (looking-at "\\[\\([^]]\\|\\s-\\)+]"))
(progn
(throw 'error-status nil)))
(let ((beg (match-beginning 0))
(end (match-end 0))
resolt
(fmt (tcalc-get-format-string)))
(if (not (numberp (setq resolt (tcalc-parse-expr (1+ beg)
(1- end)))))
(progn
(message "%s %s" resolt (char-to-string (following-char)))
(throw 'error-status nil)))
(goto-char end)
(if (eq ?= (following-char))
(progn
(goto-char (1- end))
(delete-char 2)
(insert (if tcalc-output-upase
(upcase (format (concat tcalc-insert-prefix fmt)
resolt))
(format (concat tcalc-insert-prefix fmt)
resolt)))
(goto-char beg)
(delete-char 1))
(goto-char beg)
(delete-region beg end)
(insert (if tcalc-output-upcase
(upcase (format fmt resolt))
(format fmt resolt))))
)))
(widen))
(defvar tcalc-expr-beg-regex
"-\\|(\\|\
\\(0x\\|\\$\\|#16[Rr]\\|#[Xx]\\)[0-9A-Fa-f]+\\|\
[0-9][0-9A-Fa-f]*[Hh]\\|\
-?[1-9][0-9]*\\|\
\\(0\\|@\\|#8[Rr]\\|#[Oo]\\)[0-7]+\\|\
[0-7]+[OoQq]")
(defvar tcalc-expr-end-regex
")\\|\
\\(0x\\|\\$\\|#16[Rr]\\|#[Xx]\\)[A-Fa-f0-9]+\\|\
[0-9][0-9A-Fa-f]*[Hh]\\|\
-?[1-9][0-9]*\\|\
\\(0\\|@\\|#8[Rr]\\|#[Oo]\\)[0-7]+\\|\
[0-7]+[OoQq]")
(defun tcalc-calc-last-expr (&optional arg)
"Calculate expression in current line. This funcition substitutes
the expression by resolt if arg is nil. Otherwise, inserts
tcalc-insert-prefix and resold at the end of expression."
(interactive "P")
(let ((beg-line (progn (beginning-of-line)
(point)))
beg end)
(end-of-line)
(if (null (re-search-backward tcalc-expr-end-regex beg-line t nil))
(message "current line does not contain any expression")
(setq end (match-end 0))
;; maybe, regex compiler or matchar have bug. It cannot match
;; whole string of 0x[0-9][a-FA-F] by tcalc-expr-end-regexpr.
(goto-char end)
(if (string-match (char-to-string (following-char)) "abcdefABCDEF")
(setq end (1+ end)))
(beginning-of-line)
(re-search-forward tcalc-expr-beg-regex nil t nil)
(setq beg (match-beginning 0))
(let ((resolt (tcalc-parse-expr beg end)))
(if (not (numberp resolt))
(message "%s %s" resolt (char-to-string (following-char)))
(cond (arg
(goto-char end)
(insert (if tcalc-output-upcase
(concat tcalc-insert-prefix
(upcase (format (tcalc-get-format-string)
resolt)))
(concat tcalc-insert-prefix
(format (tcalc-get-format-string)
resolt)))))
(t
(goto-char beg)
(delete-region beg end)
(insert (if tcalc-output-upcase
(upcase (format (tcalc-get-format-string) resolt))
(format (tcalc-get-format-string) resolt))))))))))
;;
;; base conversion function
;;
(defun tcalc-convert-to-hex ()
(interactive)
(tcalc-convert (tcalc-get-format-string 'hex)))
(defun tcalc-convert-to-dec ()
(interactive)
(tcalc-convert (tcalc-get-format-string 'dec)))
(defun tcalc-convert-to-oct ()
(interactive)
(tcalc-convert (tcalc-get-format-string 'oct)))
(defun tcalc-convert-string (form func cvt-beg cvt-end del-beg del-end)
"do convert and replace"
(insert (if tcalc-output-upcase
(upcase (format form
(prog1
(funcall func
(buffer-substring cvt-beg cvt-end))
(delete-region del-beg del-end))))
(format form
(prog1
(funcall func
(buffer-substring cvt-beg cvt-end))
(delete-region del-beg del-end))))))
(defun tcalc-convert (form)
"convert a number to other format"
(if (null (looking-at "\\<\\|[-$#@]"))
(backward-word 1))
(and (< (point-min) (point))
(string-match (buffer-substring (1- (point)) (point)) "$#@-")
(backward-char 1))
(cond ((and (not (looking-at "[0-9]+[HhOoQq]"))
(looking-at "-?[1-9][0-9]*"))
(tcalc-convert-string form 'tcalc-get-dec
(match-beginning 0) (match-end 0)
(match-beginning 0) (match-end 0)))
((or (looking-at "0x\\([0-9A-Fa-f]+\\)")
(looking-at "\\$\\([0-9A-Fa-f]+\\)")
(looking-at "\\([0-9][0-9A-Fa-h]*\\)[hH]")
(looking-at "#[Xx]\\([0-9A-Fa-f]+\\)")
(looking-at "#16[Rr]\\([0-9A-Fa-f]+\\)"))
(tcalc-convert-string form 'tcalc-get-hex
(match-beginning 1) (match-end 1)
(match-beginning 0) (match-end 0)))
((or (looking-at "\\(0[0-7]*\\)")
(looking-at "\\([0-7]+\\)[OoQq]")
(looking-at "@\\([0-7]+\\)")
(looking-at "#[Oo]\\([0-7]+\\)")
(looking-at "#8[Rr]\\([0-7]+\\)"))
(tcalc-convert-string form 'tcalc-get-oct
(match-beginning 1) (match-end 1)
(match-beginning 0) (match-end 0)))
(t (message "no acceptable word found."))
))
;;
;; syntax-parser
;;
(defvar tcalc-expr-stack nil)
(defvar tcalc-operator-stack nil)
(defconst tcalc-operator-precidence
'((mark-parren . 0) (+ . 1) (- . 1) (* . 2) (/ . 2) (% . 2)))
(defun tcalc-reduce-stack-top (&optional next)
(let (opr x y)
(and tcalc-operator-stack
(not (eq (car tcalc-operator-stack) 'mark-parren))
(setq opr (pop tcalc-operator-stack))
(setq y (pop tcalc-expr-stack))
(setq x (pop tcalc-expr-stack))
(push (apply opr (list x y)) tcalc-expr-stack))
(and next
tcalc-operator-stack
(<= (cdr (assq next tcalc-operator-precidence))
(cdr (assq (car tcalc-operator-stack tcalc-operator-precidence))))
(tcalc-reduce-stack-top next))
))
(defun tcalc-reduce-to-parren-mark ()
(while (tcalc-reduce-stack-top))
(and tcalc-operator-stack
(eq (car tcalc-operator-stack) 'mark-parren)
(pop tcalc-operator-stack)
(car tcalc-expr-stack)))
(defun tcalc-reduce-all ()
(while tcalc-operator-stack
(tcalc-reduce-to-parren-mark)))
(defun tcalc-parse-expr (start end)
"Parse and calcirate an expression. This parser accepts
BNF described bellow:
<input> := <nothing>
| <expr>
<expr> := NUM
| <expr> <opr> <expr>
| - <expr>
| ( <expr> )
<opr> := - | + | * | / | %"
(setq tcalc-expr-stack nil tcalc-operator-stack nil)
(let ((state 'wait-for-operand)
(last-prec 0)
(resolt nil)
(nested 0)
token
type
value)
(goto-char start)
(prog1
(catch 'error-status
(while (setq token (tcalc-parse-token end))
(setq type (car token))
(setq value (cdr token))
(if (eq type 'error)
(throw 'error-status value))
(cond ((eq state 'wait-for-operand)
(cond ((eq type 'number)
(push value tcalc-expr-stack)
(setq state 'wait-for-operator))
((eq type 'operator)
(if (not (eq value '-))
(throw 'error-status 'syntax-error)
(push 0 tcalc-expr-stack)
(if (and tcalc-operator-stack
(<= (cdr (assq '-
tcalc-operator-precidence))
(cdr (assq (car tcalc-operator-stack))
tcalc-operator-precidence)))
(tcalc-reduce-stack-top '-))
(push '- tcalc-operator-stack)
(setq state 'wait-for-operand)))
((eq type 'open-parren)
(setq state 'wait-for-operand)
(push 'mark-parren tcalc-operator-stack)
(setq nested (1+ nested)))
(t (throw 'error-status 'syntax-error))))
((eq state 'wait-for-operator)
(cond ((eq type 'operator)
(if (and tcalc-operator-stack
(<= (cdr (assq value
tcalc-operator-precidence))
(cdr (assq (car tcalc-operator-stack)
tcalc-operator-precidence))))
(tcalc-reduce-stack-top value))
(push value tcalc-operator-stack)
(setq state 'wait-for-operand))
((eq type 'close-parren)
(if (> 0 (setq nested (1- nested)))
(throw 'error-status 'unbalanced-parren)
(tcalc-reduce-to-parren-mark)))
(t (throw 'error-status 'syntax-error))))
))
(cond ((/= nested 0) 'parren-unbalance)
((eq state 'wait-for-operand) 'syntax-error)
(t (tcalc-reduce-all)
(pop tcalc-expr-stack)))
)
)))
;;
;; lexer
;;
(defconst tcalc-operator-alist
'((?+ . +) (?- . -) (?* . *) (?/ . /) (?% . %)))
(defun tcalc-parse-token (end)
"Lexical analyser"
(and (looking-at "\\s-")
(goto-char (match-end 0)))
(if (>= (point) end)
nil
(let ((beg) (end))
(prog1
(cond ((and (not (looking-at "[0-9]+[hHoOqQ]"))
(looking-at "[1-9][0-9]*"))
(setq beg (match-beginning 0) end (match-end 0))
(cons 'number (tcalc-get-dec (buffer-substring beg end))))
((or (looking-at "0x\\([0-9a-fA-F]+\\)")
(looking-at "\\$\\([0-9a-fA-F]+\\)")
(looking-at "\\([0-9][0-9A-Fa-f]*\\)[hH]")
(looking-at "#[Xx]\\([0-9A-Fa-f]+\\)")
(looking-at "#16[Rr]\\([0-9A0Fa-f]+\\)"))
(setq beg (match-beginning 1) end (match-end 1))
(cons 'number (tcalc-get-hex (buffer-substring beg end))))
((or (looking-at "\\(0[0-7]*\\)")
(looking-at "\\([0-7]+\\)[OoQh]")
(looking-at "@\\([0-7]+\\)")
(looking-at "#[Oo]\\([0-7]+\\)")
(looking-at "#8[Rr]\\([0-7]+\\)"))
(setq beg (match-beginning 1) end (match-end 1))
(cons 'number (tcalc-get-oct (buffer-substring beg end))))
((looking-at "[-+*/%]")
(setq beg (match-beginning 0) end (match-end 0))
(cons 'operator (cdr (assq (following-char)
tcalc-operator-alist))))
((looking-at "(")
(setq beg (match-beginning 0) end (match-end 0))
(cons 'open-parren 'open-parren))
((looking-at ")")
(setq beg (match-beginning 0) end (match-end 0))
(cons 'close-parren 'close-parren))
(t (setq end (point)) (cons 'error 'illegal-char))
)
(goto-char end))
)))
(defun tcalc-get-format-string (&optional radix)
(let ((style (cdr (assoc tcalc-format-style tcalc-format-style-alist)))
(base (if radix
radix
tcalc-format-radix)))
(cond ((eq base 'oct) (car style))
((eq base 'dec) (cadr style))
((eq base 'hex) (caddr style))
(t nil))))
(defalias 'tcalc-get-dec 'string-to-number)
(defun tcalc-get-oct (str)
(let ((len (length str))
(index 0)
(num 0))
(while (< index len)
(setq num (logior (lsh num 3) (- (aref str index) ?0)))
(setq index (1+ index)))
num))
(defun tcalc-get-hex (str)
(let* ((index 0)
(num 0)
(hex (upcase str))
(len (length hex)))
(while (< index len)
(let ((c (aref hex index))
tmp)
(setq num (logior (lsh num 4)
(if (> c ?9) (- c (- ?A 10))
(- c ?0)))))
(setq index (1+ index)))
num))
---------- cut ---------- cut ---------- cut ---------- cut ----------
KATAYAMA Yoshio
In article <SKIMU.97F...@ninigi.phys.s.u-tokyo.ac.jp>,
sk...@komachi.phys.s.u-tokyo.ac.jp (Shigenobu Kimura) writes:
>ところで, mule と emacs で文字のビット数って同じなんでしょうか?
文字 = 8bit、整数 = 24bit は、emacs と mule で共通だと思います。
＃生(?)の emacs は使ったことがありませんが
--
片山＠ＰＦＵ
ueh...@gate.biz.ntts.co.jp
NTTソフトウェアの上原と申します。
In article <KATE.97Fe...@yamato.trad.pfu.co.jp> ka...@pfu.co.jp (KATAYAMA Yoshio) writes:
>>>ところで, mule と emacs で文字のビット数って同じなんでしょうか?
>>
>>文字 = 8bit、整数 = 24bit は、emacs と mule で共通だと思います。
そうでしょうか? 「文字」の定義によるのかもしれませんが、muleでは
?あ
という文字定数は、
53794
という値を取りますよ。あと、muleとemacsで整数のビット数は基本的には同
じです。が、それは可変であり、configureするときの--valbitsオプションで
設定可能です。実際、64ビットマシンだと56ビットぐらいにできるようです。
KATAYAMA Yoshio
In article <UEHARA.97F...@gate.sed.ntts.co.jp>,
ueh...@gate.biz.ntts.co.jp writes:
>In article <KATE.97Fe...@yamato.trad.pfu.co.jp> ka...@pfu.co.jp (KATAYAMA Yoshio) writes:
>>>文字 = 8bit、整数 = 24bit は、emacs と mule で共通だと思います。
>そうでしょうか? 「文字」の定義によるのかもしれませんが、muleでは
> ?あ
>という文字定数は、
> 53794
>という値を取りますよ。
バッファーや文字列の中の文字のつもりでした。
C 言語の感覚で、文字定数は整数と思ってたのですが、info を見てみ
たら“文字型”としっかり書いてありました。
＃文字型 ＝ 整数
>あと、muleとemacsで整数のビット数は基本的には同
>じです。が、それは可変であり、configureするときの--valbitsオプションで
>設定可能です。
これは知りませんでした。(_ _)
--
片山＠ＰＦＵ