镜花水月

MacOS与Windows的字体对齐

2026-10-12T09:22:32Z

近日来，由于工作设备由Windows迁移至MacOS，发现同一份文档在Windows中字体、排版均正常，但是一旦放到MacOS中，就会出现字体丢失，版式异常等问题，即便将对应的字体文件和默认模版更新到MacOS中，依然出现字体缺失或显示异常等问题。

经过一段时间的琢磨，发现主要问题是Windows和MacOS对字体的name表读取是有明显差异的，两个系统各自偏爱不同的nameID和platformID。Windows系统在读取字体时，主要取nameID的1（家族名）和2（子家族名）作为字体名称显示，优先读取platformID = 3（windows unicode）的记录；MacOS系统在读取字体时，主要取nameID 4（Full font name）作为字体名称显示，取platformID = 1（Macintosh)的记录，当然也兼容platformID = 3的记录；PostScript主要取nameID 6的记录。

因此具体在使用上，同一个字体的文档在Windows和MacOS的Office软件中显示的字体会出现明显差异，造成混乱。为了文档在不同系统的一致性显示，基于目前Windows的用户更多，最简单的办法是修正个人设备中字体在MacOS中的namespace信息，保持其解析与Windows中的一致性。

为一次性解决问题，实现（预编译包下载：https://aibsd.lanzouq.com/irmjS4bpsotc 密码:mfna）如下：

Golang实现：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584


// -*- coding: utf-8 -*-
package main

import (
	"encoding/binary"
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"unicode/utf16"
)

type nameRec struct {
	platformID, encID, langID, nameID uint16
	raw                               []byte
}
type table struct {
	tag  string
	data []byte
}
type fontInfo struct {
	base   uint32
	tables []table
}

func readTables(data []byte, base uint32) []table {
	if int(base)+12 > len(data) {
		return nil
	}
	nt := int(binary.BigEndian.Uint16(data[base+4:]))
	out := make([]table, 0, nt)
	for i := 0; i < nt; i++ {
		d := int(base) + 12 + i*16
		if d+16 > len(data) {
			break
		}
		tag := string(data[d : d+4])
		off := binary.BigEndian.Uint32(data[d+8:])
		l := binary.BigEndian.Uint32(data[d+12:])
		if int(off)+int(l) > len(data) { // 越界保护, 避免slice panic
			continue
		}
		out = append(out, table{tag, data[off : off+l]})
	}
	return out
}

// loadFonts返回字体列表(含各自base偏移)与是否TTC
func loadFonts(data []byte) ([]fontInfo, bool) {
	if len(data) >= 4 && string(data[:4]) == "ttcf" {
		num := binary.BigEndian.Uint32(data[8:12])
		fis := make([]fontInfo, 0, num)
		for i := uint32(0); i < num; i++ {
			base := binary.BigEndian.Uint32(data[12+i*4:])
			if int(base) > len(data) { // 越界保护
				continue
			}
			fis = append(fis, fontInfo{base, readTables(data, base)})
		}
		return fis, true
	}
	return []fontInfo{{0, readTables(data, 0)}}, false
}

func findNameTable(fi *fontInfo) ([]nameRec, bool) {
	for _, t := range fi.tables {
		if t.tag == "name" {
			return parseName(t.data), true
		}
	}
	return nil, false
}

func parseName(tbl []byte) []nameRec {
	if len(tbl) < 6 {
		return nil
	}
	count := binary.BigEndian.Uint16(tbl[2:4])
	strOff := binary.BigEndian.Uint16(tbl[4:6])
	recs := make([]nameRec, 0, count)
	for i := 0; i < int(count); i++ {
		b := 6 + i*12
		if b+12 > len(tbl) {
			break
		}
		l := binary.BigEndian.Uint16(tbl[b+8:])
		o := binary.BigEndian.Uint16(tbl[b+10:])
		so := int(strOff) + int(o)
		if so+int(l) > len(tbl) {
			continue
		}
		recs = append(recs, nameRec{
			binary.BigEndian.Uint16(tbl[b:]), binary.BigEndian.Uint16(tbl[b+2:]),
			binary.BigEndian.Uint16(tbl[b+4:]), binary.BigEndian.Uint16(tbl[b+6:]),
			tbl[so : so+int(l)],
		})
	}
	return recs
}

func decode(r nameRec) string {
	switch r.platformID {
	case 0, 3:
		u := make([]uint16, 0, len(r.raw)/2)
		for i := 0; i+1 < len(r.raw); i += 2 {
			u = append(u, binary.BigEndian.Uint16(r.raw[i:]))
		}
		return string(utf16.Decode(u))
	case 1:
		if len(r.raw) >= 2 && r.raw[0] == 0x00 && r.raw[1] != 0x00 {
			u := make([]uint16, 0, len(r.raw)/2)
			for i := 0; i+1 < len(r.raw); i += 2 {
				u = append(u, binary.BigEndian.Uint16(r.raw[i:]))
			}
			return string(utf16.Decode(u))
		}
		var sb strings.Builder
		for _, c := range r.raw {
			if c >= 0x20 && c < 0x80 {
				sb.WriteByte(c)
			}
		}
		return sb.String()
	}
	return fmt.Sprintf("", r.platformID)
}

func encode(s string, platformID, encID uint16) []byte {
	switch platformID {
	case 0, 3:
		u := utf16.Encode([]rune(s))
		b := make([]byte, len(u)*2)
		for i, r := range u {
			binary.BigEndian.PutUint16(b[i*2:], r)
		}
		return b
	case 1:
		if encID == 0 {
			out := make([]byte, 0, len(s))
			for i := 0; i < len(s); i++ {
				if s[i] < 0x80 {
					out = append(out, s[i])
				}
			}
			return out
		}
		u := utf16.Encode([]rune(s))
		b := make([]byte, len(u)*2)
		for i, r := range u {
			binary.BigEndian.PutUint16(b[i*2:], r)
		}
		return b
	}
	return []byte(s)
}

func cmdDump(path string, fontIndex int) {
	data, err := os.ReadFile(path)
	if err != nil {
		fmt.Fprintln(os.Stderr, "读取失败:", err)
		os.Exit(1)
	}
	fis, isttc := loadFonts(data)
	if fontIndex >= 0 {
		if fontIndex >= len(fis) {
			fmt.Fprintln(os.Stderr, "索引超出范围:", fontIndex, "/", len(fis))
			os.Exit(1)
		}
		dumpOne(path, &fis[fontIndex], fontIndex, isttc)
		return
	}
	for i := range fis {
		dumpOne(path, &fis[i], i, isttc)
	}
}

func dumpOne(path string, fi *fontInfo, idx int, isttc bool) {
	recs, ok := findNameTable(fi)
	pre := fmt.Sprintf("  [字体#%d] ", idx)
	if !ok {
		fmt.Printf("== %s :: 字体#%d无name表\n", filepath.Base(path), idx)
		return
	}
	fmt.Printf("== %s :: 字体#%d %s name表 ==\n", filepath.Base(path), idx, map[bool]string{true: "(TTC)", false: "(单字体)"}[isttc])
	sort.Slice(recs, func(i, j int) bool { return recs[i].nameID < recs[j].nameID })
	for _, r := range recs {
		fmt.Printf("%snameID=%-2d plat=%d enc=%d lang=0x%04x: %q\n",
			pre, r.nameID, r.platformID, r.encID, r.langID, decode(r))
	}
}

var macEn = [2]uint16{0, 0x0000}
var macZh = [2]uint16{25, 0x0021}

func find(recs []nameRec, nameID, platformID, enc, lang uint16) string {
	for _, r := range recs {
		if r.nameID == nameID && r.platformID == platformID && r.encID == enc && r.langID == lang {
			return decode(r)
		}
	}
	return ""
}

func isRegular(s string) bool {
	s = strings.ToLower(s)
	return s == "regular" || s == "normal" || s == ""
}

// alignTables重写给定字体的name表, 返回新表(slice或nil表示需跳过)与原因描述
func alignTables(recs []nameRec, langs []string, withTypo bool) ([]byte, string) {
	base := map[string][2]string{}
	for _, lang := range langs {
		var fam, sub string
		if lang == "zh" {
			fam = find(recs, 1, 3, 1, 0x0804)
			sub = find(recs, 2, 3, 1, 0x0804)
		} else {
			fam = find(recs, 1, 3, 1, 0x0409)
			sub = find(recs, 2, 3, 1, 0x0409)
		}
		if fam == "" {
			fam = find(recs, 1, 3, 0, 0)
		}
		if sub == "" {
			sub = "Regular"
		}
		if fam == "" {
			return nil, fmt.Sprintf("缺少可用的Windows family记录(lang=%s)", lang)
		}
		base[lang] = [2]string{fam, sub}
	}
	var keep []nameRec
	for _, r := range recs {
		if r.platformID == 3 {
			keep = append(keep, r)
			continue
		}
		if r.nameID == 16 || r.nameID == 17 {
			continue
		}
		if (r.platformID == 0 || r.platformID == 1) && (r.nameID == 1 || r.nameID == 2 || r.nameID == 4) {
			continue
		}
		keep = append(keep, r)
	}
	for _, lang := range langs {
		fam, sub := base[lang][0], base[lang][1]
		full := fam
		if !isRegular(sub) {
			full = fam + " " + sub
		}
		for _, plat := range []uint16{1, 0} {
			if plat == 1 && lang != "en" {
				continue
			}
			var enc, lid uint16
			if plat == 0 {
				enc, lid = 3, 0x0409
				if lang == "zh" {
					enc, lid = 3, 0x0804
				}
			} else {
				if lang == "zh" {
					enc, lid = macZh[0], macZh[1]
				} else {
					enc, lid = macEn[0], macEn[1]
				}
			}
			keep = append(keep, nameRec{plat, enc, lid, 1, encode(fam, plat, enc)})
			keep = append(keep, nameRec{plat, enc, lid, 2, encode(sub, plat, enc)})
			keep = append(keep, nameRec{plat, enc, lid, 4, encode(full, plat, enc)})
			if withTypo {
				keep = append(keep, nameRec{plat, enc, lid, 16, encode(fam, plat, enc)})
				keep = append(keep, nameRec{plat, enc, lid, 17, encode(sub, plat, enc)})
			}
		}
	}
	return buildNameTable(keep), "ok"
}

func buildNameTable(recs []nameRec) []byte {
	count := len(recs)
	stringOff := 6 + 12*count
	var sb []byte
	type e struct {
		r   nameRec
		off uint16
	}
	ents := make([]e, 0, count)
	for _, r := range recs {
		ents = append(ents, e{r, uint16(len(sb))})
		sb = append(sb, r.raw...)
	}
	out := make([]byte, stringOff+len(sb))
	binary.BigEndian.PutUint16(out[2:], uint16(count))
	binary.BigEndian.PutUint16(out[4:], uint16(stringOff))
	for i, x := range ents {
		b := 6 + i*12
		binary.BigEndian.PutUint16(out[b:], x.r.platformID)
		binary.BigEndian.PutUint16(out[b+2:], x.r.encID)
		binary.BigEndian.PutUint16(out[b+4:], x.r.langID)
		binary.BigEndian.PutUint16(out[b+6:], x.r.nameID)
		binary.BigEndian.PutUint16(out[b+8:], uint16(len(x.r.raw)))
		// 记录偏移相对字符串区起始; 字符串实际位置 = header.stringOffset + 此值 (与fontTools语义一致)
		binary.BigEndian.PutUint16(out[b+10:], x.off)
	}
	copy(out[stringOff:], sb)
	return out
}

func u32sum(b []byte) uint32 {
	var s uint32
	i := 0
	for ; i+4 <= len(b); i += 4 {
		s += binary.BigEndian.Uint32(b[i:])
	}
	if i < len(b) {
		var t [4]byte
		copy(t[:], b[i:])
		s += binary.BigEndian.Uint32(t[:])
	}
	return s
}

func align4(n int) int { return (n + 3) &^ 3 }

// writeFont序列化单个字体(offset table + tables), 返回字节; head表adjustment按"该字体字节"重算
func writeFont(offsetTable []byte, tables []table) []byte {
	nt := len(tables)
	dirSize := align4(len(offsetTable) + nt*16)
	total := dirSize
	for _, t := range tables {
		total += align4(len(t.data))
	}
	out := make([]byte, total)
	copy(out, offsetTable)
	// 表数据必须从目录区(dirSize)之后开始, 否则会覆盖目录导致字体损坏
	cursor := dirSize
	offsets := make([]uint32, nt)
	sums := make([]uint32, nt)
	for i, t := range tables {
		offsets[i] = uint32(cursor)
		sums[i] = u32sum(t.data)
		copy(out[cursor:], t.data)
		cursor += align4(len(t.data))
	}
	for i, t := range tables {
		d := len(offsetTable) + i*16
		copy(out[d:d+4], t.tag)
		binary.BigEndian.PutUint32(out[d+4:], sums[i])
		binary.BigEndian.PutUint32(out[d+8:], offsets[i])
		binary.BigEndian.PutUint32(out[d+12:], uint32(len(t.data)))
	}
	// head checkSumAdjustment: 该字体所有字节求和(head+8置0)
	if headIdx := findTableIdx(tables, "head"); headIdx >= 0 {
		st := int(offsets[headIdx]) + 8
		work := make([]byte, len(out))
		copy(work, out)
		work[st], work[st+1], work[st+2], work[st+3] = 0, 0, 0, 0
		adj := 0xB1B0AFBA - u32sum(work)
		binary.BigEndian.PutUint32(out[st:st+4], adj)
	}
	return out
}

func findTableIdx(tables []table, tag string) int {
	for i, t := range tables {
		if t.tag == tag {
			return i
		}
	}
	return -1
}

func cmdAlign(path, out string, langs []string, fontIndex int, withTypo bool) {
	data, err := os.ReadFile(path)
	if err != nil {
		fmt.Fprintln(os.Stderr, "读取失败:", err)
		os.Exit(1)
	}
	fis, isttc := loadFonts(data)
	// 处理字体: 默认(-1)处理全部; 否则处理指定索引
	if fontIndex >= 0 && fontIndex >= len(fis) {
		fmt.Fprintln(os.Stderr, "索引超出范围:", fontIndex, "/", len(fis))
		os.Exit(1)
	}
	newNames := make([][]byte, len(fis))
	changed := make([]bool, len(fis))
	idxs := make([]int, 0)
	if fontIndex < 0 {
		for i := range fis {
			idxs = append(idxs, i)
		}
	} else {
		idxs = append(idxs, fontIndex)
	}
	processed := 0
	for _, i := range idxs {
		recs, ok := findNameTable(&fis[i])
		if !ok {
			fmt.Fprintf(os.Stderr, "  ⚠ 字体#%d: 无name表, 已跳过\n", i)
			continue
		}
		nb, reason := alignTables(recs, langs, withTypo)
		if nb == nil {
			fmt.Fprintf(os.Stderr, "  ⚠ 字体#%d: %s, 已跳过(其余正常处理)\n", i, reason)
			continue
		}
		newNames[i], changed[i] = nb, true
		processed++
	}
	if processed == 0 {
		fmt.Fprintln(os.Stderr, "!!! 没有任何字体可对齐, 不产生输出文件")
		os.Exit(3)
	}

	// 重建文件
	var outData []byte
	if isttc {
		outData = rebuildTTC(data, fis, changed, newNames)
	} else {
		outData = rebuildSingle(data, &fis[0], changed[0], newNames[0])
	}
	if err := os.WriteFile(out, outData, 0644); err != nil {
		fmt.Fprintln(os.Stderr, "写入失败:", err)
		os.Exit(1)
	}
	fmt.Printf("已生成: %s\n", out)
}

func rebuildSingle(src []byte, fi *fontInfo, changed bool, newName []byte) []byte {
	offTbl := append([]byte{}, src[fi.base:fi.base+12]...)
	tables := make([]table, 0, len(fi.tables))
	for _, t := range fi.tables {
		if changed && t.tag == "name" {
			t = table{"name", newName}
		}
		tables = append(tables, t)
	}
	binary.BigEndian.PutUint16(offTbl[4:6], uint16(len(tables)))
	return writeFont(offTbl, tables)
}

func rebuildTTC(src []byte, fis []fontInfo, changed []bool, newNames [][]byte) []byte {
	num := binary.BigEndian.Uint32(src[8:12])
	// 生成各字体字节
	fontBytes := make([][]byte, len(fis))
	dirStart := 12 + int(num)*4
	cursor := dirStart
	offsets := make([]uint32, len(fis))
	for i := range fis {
		offTbl := append([]byte{}, src[fis[i].base:fis[i].base+12]...)
		tables := make([]table, 0, len(fis[i].tables))
		for _, t := range fis[i].tables {
			if changed[i] && t.tag == "name" {
				t = table{"name", newNames[i]}
			}
			tables = append(tables, t)
		}
		binary.BigEndian.PutUint16(offTbl[4:6], uint16(len(tables)))
		b := writeFont(offTbl, tables)
		offsets[i] = uint32(cursor)
		// 表offset需改为相对整个TTC文件的绝对偏移(fontTools语义), 而非相对字体block
		ntFont := int(binary.BigEndian.Uint16(b[4:6]))
		for t := 0; t < ntFont; t++ {
			d := 12 + t*16
			cur := binary.BigEndian.Uint32(b[d+8:])
			binary.BigEndian.PutUint32(b[d+8:], cur+offsets[i])
		}
		fontBytes[i] = b
		cursor += len(b)
	}
	out := make([]byte, cursor)
	copy(out, "ttcf")
	ver := binary.BigEndian.Uint32(src[4:8])
	binary.BigEndian.PutUint32(out[4:8], ver)
	binary.BigEndian.PutUint32(out[8:12], num)
	for i := range fis {
		binary.BigEndian.PutUint32(out[12+i*4:], offsets[i])
	}
	c := dirStart
	for i := range fis {
		copy(out[c:], fontBytes[i])
		c += len(fontBytes[i])
	}
	return out
}

// mfna — macOS Fonts Name Align tools
const progFull = "macOS Fonts Name Align tools"

func banner() {
	fmt.Println("mfna — " + progFull)
	fmt.Println("  把macOS读取的字体name信息对齐到Windows的值(Windows记录保持不改)")
	fmt.Println("  支持TTF / OTF / TTC; TTC默认处理全部字体, 可用 --font-index指定")
	fmt.Println()
	fmt.Println("用法:")
	fmt.Println("  mfna dump  [--font-index N]")
	fmt.Println("  mfna align  --out  [--lang en,zh] [--with-typo] [--font-index N]")
	fmt.Println("  mfna -v | --version显示版本与名称释义")
}

func main() {
	if len(os.Args) < 2 || os.Args[1] == "-h" || os.Args[1] == "--help" {
		banner()
		os.Exit(0)
	}
	if os.Args[1] == "-v" || os.Args[1] == "--version" {
		fmt.Printf("mfna %s (build for macOS/Linux)", progFull)
		return
	}
	switch os.Args[1] {
	case "dump":
		if len(os.Args) < 3 {
			usage()
		}
		idx := -1
		for i := 2; i < len(os.Args)-1; i++ {
			if os.Args[i] == "--font-index" && i+1 < len(os.Args) {
				fmt.Sscanf(os.Args[i+1], "%d", &idx)
			}
		}
		cmdDump(os.Args[2], idx)
	case "align":
		var out, lang string = "", "en,zh"
		fontIndex := -1
		withTypo := false
		var pos []string
		args := os.Args[2:]
		for i := 0; i < len(args); i++ {
			switch args[i] {
			case "--out":
				if i+1 < len(args) {
					out = args[i+1]
					i++
				}
			case "--lang":
				if i+1 < len(args) {
					lang = args[i+1]
					i++
				}
			case "-font-index", "--font-index":
				if i+1 < len(args) {
					fmt.Sscanf(args[i+1], "%d", &fontIndex)
					i++
				}
			case "--with-typo":
				withTypo = true
			default:
				pos = append(pos, args[i])
			}
		}
		if out == "" || len(pos) < 1 {
			usage()
		}
		langs := languages(lang)
		if len(langs) == 0 {
			fmt.Fprintln(os.Stderr, "--lang需包含en或zh")
			os.Exit(2)
		}
		cmdAlign(pos[0], out, langs, fontIndex, withTypo)
	default:
		usage()
	}
}

func languages(s string) []string {
	var out []string
	for _, x := range strings.Split(s, ",") {
		x = strings.TrimSpace(x)
		if x == "en" {
			out = append(out, "en")
		} else if x == "zh" {
			out = append(out, "zh")
		}
	}
	return out
}

func usage() {
	fmt.Fprintln(os.Stderr, "用法:\n  mfna dump  [--font-index N]\n  mfna align  --out out [-font-index N] [--lang en,zh] [--with-typo]\n运行mfna(无参数) 查看详细帮助")
	os.Exit(2)
}

Python实现：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173


#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import argparse, os, json, struct
from fontTools.ttLib import TTFont, TTCollection, TTLibError

MAC_SPECS = {"en": (1, 0, 0x0000), "zh": (1, 25, 0x0021)}
WIN_SPECS = {"en": (3, 1, 0x0409), "zh": (3, 1, 0x0804)}


def is_ttc(path):
    with open(path, "rb") as f:
        return f.read(4) == b"ttcf"


def load(path, font_index=None, force=False):
    """返回 (fonts_list, is_collection)"""
    if is_ttc(path):
        coll = TTCollection(path)
        return coll, True
    font = TTFont(path)
    if font_index is not None and font_index != 0:
        raise SystemExit("单字体文件只有索引0")
    return [font], False


def _get(name, nameID, specs):
    p, e, l = specs
    for r in name.names:
        if r.nameID == nameID and r.platformID == p and r.platEncID == e and r.langID == l:
            try:
                return r.toUnicode()
            except Exception:
                return None
    return None


def _first(name, nameID, platformID):
    for r in name.names:
        if r.nameID == nameID and r.platformID == platformID:
            try:
                return r.toUnicode()
            except Exception:
                return None
    return None


def dump_table(path, as_json=False, font_index=None):
    fonts, iscol = load(path, font_index)
    if font_index is None:
        idxs = range(len(fonts)) if iscol else [0]
    else:
        idxs = [font_index]
    for i in idxs:
        if i >= len(fonts):
            raise SystemExit(f"索引 {i} 超出范围(共 {len(fonts)} 个字体)")
        font = fonts[i]
        if "name" not in font:
            print(f"[字体#{i}] 无name表"); continue
        name = font["name"]
        rows = []
        for r in name.names:
            try:
                v = r.toUnicode()
            except Exception:
                v = "<无法解码>"
            rows.append((r.nameID, r.platformID, r.platEncID, r.langID, v))
        rows.sort(key=lambda x: (x[0], x[1], x[2], x[3]))
        if as_json:
            data = [{"nameID": x[0], "platformID": x[1], "encID": x[2],
                     "langID": hex(x[3]), "value": x[4]} for x in rows]
            print(f"[字体#{i}] " + json.dumps(data, ensure_ascii=False))
        else:
            print(f"== {path} :: 字体#{i} ({'TTC' if iscol else '单字体'}) name表 ==")
            tag = f"  [字体#{i}] " if iscol and font_index is None else "  "
            for x in rows:
                print(f"{tag}nameID={x[0]:2d} plat={x[1]} enc={x[2]} lang=0x{x[3]:04x}: {x[4]!r}")


def operate_font(font, langs, with_typo, force=False):
    """对单个TTFont应用对齐逻辑, 返回True表示执行了修改"""
    if "name" not in font:
        return False
    name = font["name"]
    base = {}
    for lang in langs:
        fam = _get(name, 1, WIN_SPECS[lang])
        sub = _get(name, 2, WIN_SPECS[lang])
        if fam is None:
            fam = _first(name, 1, 3)
        if sub is None:
            sub = _first(name, 2, 3) or "Regular"
        base[lang] = {"family": fam, "sub": sub}
        if fam is None:
            print(f"  [跳过] 未找到Windows平台family(lang={lang})")
            return False
    # 移除mac平台待重写1/2/4/16/17及各平台16/17; 保留platform 3
    name.names = [n for n in name.names
                  if not (n.platformID == 3 and False)     # platform 3永不删
                  and not (n.platformID == 1 and n.nameID in {1, 2, 4, 16, 17})
                  and n.nameID not in {16, 17}]
    for lang in langs:
        fam = base[lang]["family"] or base["en"]["family"]
        sub = base[lang]["sub"] or "Regular"
        full = fam if sub.lower() in ("regular", "normal", "") else f"{fam} {sub}"
        p, e, l = MAC_SPECS[lang]
        name.setName(fam, 1, p, e, l)
        name.setName(sub, 2, p, e, l)
        name.setName(full, 4, p, e, l)
        if with_typo:
            name.setName(fam, 16, p, e, l)
            name.setName(sub, 17, p, e, l)
    return True


def align_path(path, outpath, langs, with_typo, font_index, force):
    iscol = is_ttc(path)
    if iscol:
        coll = TTCollection(path)
        if font_index is None:
            idxs = range(len(coll.fonts))
        else:
            idxs = [font_index]
        done = 0
        for i in idxs:
            if i >= len(coll.fonts):
                raise SystemExit(f"索引 {i} 超出范围(共 {len(coll.fonts)} 个字体)")
            if operate_font(coll.fonts[i], langs, with_typo, force):
                done += 1
        coll.save(outpath)
        print(f"✅ 已写出TTC: {outpath} (处理 {done} 个字体 / 共 {len(coll.fonts)})")
    else:
        font = TTFont(path)
        if font_index is not None and font_index != 0:
            raise SystemExit("单字体文件无索引之分")
        if not operate_font(font, langs, with_typo, force):
            raise SystemExit("未对齐(缺Windows平台family)")
        font.save(outpath)
        print(f"✅ 已写出: {outpath}")


def main():
    ap = argparse.ArgumentParser(description="字体name表dump/对齐工具 (支持TTF/OTF/TTC)")
    sub = ap.add_subparsers(dest="cmd", required=True)

    d = sub.add_parser("dump", help="打印name表")
    d.add_argument("font"); d.add_argument("--json", action="store_true")
    d.add_argument("--font-index", type=int, default=None, help="TTC字体索引(0-based)")

    p = sub.add_parser("align", help="以Windows为基准对齐macOS")
    p.add_argument("font"); p.add_argument("--out", required=True)
    p.add_argument("--lang", default="en,zh")
    p.add_argument("--with-typo", action="store_true")
    p.add_argument("--font-index", type=int, default=None, help="TTC字体索引, 默认全部")
    p.add_argument("--force", action="store_true")

    args = ap.parse_args()
    if args.cmd == "dump":
        dump_table(args.font, args.json, args.font_index)
        return
    if args.cmd == "align":
        langs = []
        for x in args.lang.lower().replace("both", "en,zh").split(","):
            x = x.strip()
            if x == "en": langs.append("en")
            elif x == "zh": langs.append("zh")
        if not langs:
            raise SystemExit("--lang需包含en或zh")
        align_path(args.font, args.out, langs, args.with_typo, args.font_index, args.force)


if __name__ == "__main__":
    main()

MacOS中制作光盘备忘

2026-09-09T14:20:00Z

缘起

某些同学提供了大量的素材，需要固化提交某部门，不接受可读写介质，需要使用光盘提供，因此才有了下面的探索。

使用xorriso

在macos中，安装xorriso很容易，直接：

brew install xorriso

即可，但是愿望是美好的，现实是打脸的。

通过：

xorriso -as mkisofs -volid "MyVol" -J -udf \
  -o /tmp/output.iso /path/to/your-files

或

xorriso -outdev /tmp/output.iso -volid "MyVol" \
  -joliet on -udf on -map /path/to/your-files / -commit

之后，提示命令错误，缺失-udf等选项，仔细查阅后，brew安装的xorriso是通过libiso等库支持的，进一步查询确认，该版本完全不支持udf，遂更换方法。

使用cdrtools

在macos中，安装cdrtools也很容易，直接：

brew install cdrtools

即可。但愿望是美好的，现实更把脸打肿了。通过：

mkisofs -J -r -UDF -iso-level 3 -input-charset utf-8 \
  -output-charset utf-8 -o out.iso /path/to/your-files

或

mkisofs -J -r -UDF -U -iso-level 3 -input-charset utf-8 \
  -output-charset utf-8 -o out.iso /path/to/your-files

为何需要指定charset，和使用-U选项，是因为同学提供的素材中包含大量的中文命名文件和文件夹，部分命名巨长，导致虽然能完成iso的制作，但复读iso时文件名出现截断乱码。通过：

isoinfo -R -l -i out.iso
isoinfo -J -l -i out.iso
isoinfo -f -l -i out.iso

查看各个层面的编码信息，发现rockride层中文是正常的但udf层和joliet层的中文都变为_。由于系统locale明确是utf-8，因此该问题基本确认是由于brew安装的cdrtools中的mkisofs未包含完整的iconv支持，使utf-8编码在转换为ucs时出错，直接将非ASCII编码替换为_，导致出现该问题。

使用原生hdiutil完成工作

hdiutil makehybrid -default-volume-name=“your_disk_tag" \
  -iso -joliet -udf -o out.iso /path/to/your-files

经isoinfo查看，虽然在rockridge、udf、joliet层中文都显示为单个的"_"，但将iso文件在mac、linux、windows中挂载，中文都显示正常，因此问题暂时得到解决。

Hugo+Git+Hooks+Remark42工作流部署经验

2026-08-29T15:00:00Z

系统部署

由于个人部署，Hugo、Git、Remark42均为GO程序，因此操作系统依赖小，各个版本的BSD和LINUX均能满足要求；本项目部署在Aliyun的VPS，为方便，采用Debian。
部署顺序：Caddy、Gitea、Remark42、Hugo、Git hooks。
个人站点，建议直接二进制部署。

踩坑经验

（一）Caddy

建议采用分站点的方式安排配置文件，主配置文件不变，各站点配置文件置于conf.d中，便于组织和排故。
建议采用统一的日志生成机制。
本项目采用Aliyun DNS，因此需要使用xcaddy重新编译，加入aliyun dns插件。
Aliyun DNS的id和secret，通过caddy的env文件导入，具体查阅插件说明。

本人采用的配置文件（脱密版）：

主文件Caddyfile

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


{
        email xxx@xxx.xxx
        storage file_system /var/lib/caddy/keys
}
# 定义可复用日志模板
(logs) {
        # 访问日志
        log {
                output file /var/log/caddy/{args[0]}_access.log {
                        roll_size 10MB
                        roll_keep 5
                        roll_keep_for 720h
                }
                level INFO
        }
        # 错误日志
        log {
                output file /var/log/caddy/{args[0]}_error.log {
                        roll_size 5MB
                        roll_keep 5
                }
                level ERROR
        }
}
# 导入所有站点配置
import /etc/caddy/conf.d/*.caddy

站点文件（示例）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


https://www.aibsd.cn {
        tls {
                resolvers 1.0.0.1
                dns alidns {
                        access_key_id "{env.ALICLOUD_ACCESS_KEY_ID}"
                        access_key_secret "{env.ALICLOUD_ACCESS_KEY_SECRET}"
                }
        }
        root * /opt/www/
        # Hugo对模版的子目录支持之rewrite规则
        handle /_3p/* {
                rewrite * /blog{path}
                file_server
        }
        # 自动跳转blog目录
        redir / /blog/ permanent
        # 路径自动补全/
        @noSlash path_regexp no_slash ^(.*/[^/.]+)$
        redir @noSlash {http.request.uri.path}/ 301
        # 其他路径的文件服务器配置
        handle {
                file_server {
                        index index.htm index.html
                }
        }
        import logs www.aibsd.cn
}

（二）Gitea

个人自托管业务，SQLite3已足够支持，Postgresql对于个人代码托管显得过于重了。
如果需要应用git hooks，需要在配置选项增项相应条目，否则hooks不生效。
hooks脚本需要在项目的设置的“git钩子”中配置，在个人仓库的custom/hooks目录配置脚本是无效的。
如果国内部署，需要增项相应的备案信息，需要在gitea根目录的custom/templates/custom/中添加相应的修改模版。

注意主配置文件中[server]段的域名配置和ssh配置。

Gitea主配置文件需要添加的hooks配置

[security]
DISABLE_GIT_HOOKS = false

Gitea添加备案信息，模版名称为extra_links_footer.tmpl

<span>span>
<a href="https://beian.miit.gov.cn/#/Integrated/recordQuery" target="_blank" rel="noopener noreferrer">某ICP备**********号a>
<span>span>
<a href="https://beian.mps.gov.cn/#/query/webSearch" target="_blank" rel="noopener noreferrer">某公网安备**********号a>

（三）Remark42

Remark42建议直接二级域名，不建议使用子目录，否则会遇到域交叉信任问题。
国内使用，除非你有合法的国际网络代理通道，否则不建议使用官方推荐的认证方式，建议使用邮件登录或匿名登录。

🚨 警告
3. Rmark42在使用邮件登录时，会调用gravatar.com的图标，造成大约5s的延时，会直接导致登录出现“Something went wrong”的错误；该错误在debug信息中无显示，tcpdump跟踪也会因为多域名的缘故造成混淆，最后通过跟踪故障发生时SIGQUIT的goroutine dump才找到石锤信息；解决方法有两种：其一是直接通过hosts将该域名定向到127.0.0.1，其二是通过国内镜像解决，需要将caddy的内部CA加入系统信任，同时caddy配置时添加tls internal来自签。

Remark42的配置文件，是REMARK前缀，并且不是所有选项都需要remark前缀，需详细查阅官方文档。

本项目Remark42主配置文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


REMARK_URL=https://remark.aibsd.cn
SITE=remark
SECRET=***  //通过openssl rand -hex 32 获取随机字符串
STORE_TYPE=bolt
STORE_BOLT_PATH=***
STORE_TIMOUT=20s
BACKUP_PATH=***
BACKUP_DURATION=24h
BACKUP_MAX_FILES=10
ADMIN_SHARED_ID=***
ADMIN_SHARED_EMAIL=***
ADMIN_SHARED_PASSWORD=***
AUTH_ANON=true
REMARK_ADDRESS=127.0.0.1
REMARK_PORT=4000
AUTH_EMAIL_ENABLE=true
AUTH_EMAIL_FROM=xxx@xxx.xxx
AUTH_EMAIL_SUBJ="在***的留言确认"
AUTH_EMAIL_CONTENT_TYPE="text/html"
SMTP_HOST=***
SMTP_PORT=465
SMTP_TLS=true
SMTP_USERNAME=***
SMTP_PASSWORD=***
SMTP_TIMEOUT=10s

本项目的Remark42的caddy反向代理配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


https://remark.aibsd.cn {
        tls {
                resolvers 1.0.0.1
                dns alidns {
                        access_key_id "{env.ALICLOUD_ACCESS_KEY_ID}"
                        access_key_secret "{env.ALICLOUD_ACCESS_KEY_SECRET}"
                }
        }
        encode zstd gzip
        reverse_proxy 127.0.0.1:4000 {
                header_up X-Real-IP {remote_host}
                header_up X-Forwarded-For {remote_host}
                header_up X-Forwarded-Proto {scheme}
        }
        import logs remark.aibsd.cn
}

博客功能完整性测试

2026-08-28T06:20:00Z

测试功能,再次hooks测试。

公式

行内公式： \(E = mc^2\)

块级公式：

$$
 \int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi} 
$$

义训

注音注释：

漢字（かんじ）

汉字（hàn zì）

提示框/标注：

📓 注意
这是一个提示标注

💡 友情提示
这是一个实用技巧

🚨 警告
这是一个重要警告

❗ 重要
这是关键信息

⚠️ 小心
请谨慎操作

How to build custom mfsbsd images

2018-03-16T08:10:00Z

Generation of mfsbsd image

You can generate your own mfsbsd image (see below) or just get one of the Testing/Beta ones from MFSBSD8. In the latter case, you will need to also download the original kernel.txz from a FreeBSD mirror site because by default mfsbsd does not include the geom_eli module and its dependencies (zlib, crypto). The generic image will just use DHCP to get all its network related data and start sshd. Just connect with the mfsroot password by root.

The kernel.tgz can be taken from ftp://ftp.fr.freebsd.org/pub/FreeBSD/releases/amd64/amd64/9.2-RELEASE. Note that the kernel.tgz version needs to be the same one as the one inside mfsbsd, else you will not be able to load the modules.

buildworld & buildkernel

make buildworld
make buildkernel KERNCONF=GENERIC

Please add any option you want like -j8 and define options as you see fit like NO_CLEAN=yes

📓 注意
The mfsbsd Makefile can do that for you if you specify CUSTOM=1 BUILDWORLD=1 BUILDKERNEL=1.

Configuration

You need to modify and customize the various configuration files located in conf/:

1
2
3
4
5


authorized_keys
interfaces.conf
loader.conf
rc.conf
resolv.conf

The main things to change are IP addresses of the server, DNS servers, defaultroute and all that. Most of these informations are on the page describing your server in the console. Recent versions of mfsbsd (around 2.0) allow to specify DHCP making thinsg much easier (and the images more generic).

loader.conf is important because that where you specify the tunables for the kernel. As we are installing a ZFS system, you will need at least to specify vm.kmem_size. I’d advise you to use 2xRAM here.

There also on file we need to modify: Makefile. By default, only some kernel modules are loaded in, a few more are put as loadable modules and there are some missing (in the context of the current article): geom_eli, aesni and its dependencies (crypto, zlib). ZFS and opensolaris are included though.

mfsbsd creation

If you use the source to generate a release/snapshot, use the following to create the mfsbsd image:

make BASE=/data/work/freebsd/9 SRC_DIR=/data/work/freebsd/9  CUSTOM=1

If you use the files from a given distribution, SRC_DIR is not needed and BASE should point to the directory with base.txz and kernel.txz. Copy the newly created mfsboot.img somewhere you can reach over the Internet. Any FTP or HTTP server will do.

「转」质疑天龙八部和鹿鼎记不是金庸自己写

2007-06-21T21:10:00Z

如果《天龙八部》《鹿鼎记》等一干作品真的系金大师的手笔，如果金大师愿意将写作的角度转向社会生活领域的话，那他会有八成以上的把握成为第一个得到诺贝尔文学奖的中国人。赛珍珠那部以中国社会为题材获得文学奖的《大地》无论在整个作品的布局、作品的立意和思想高度以及对深层文化的理解上都稍逊《天龙八部》等一筹。离我们比较近的两个日本人川端康成和大江健三郎，以他们的功力和余秋雨之流PK那是绰绰有余，但是如果要应付《天龙八部》《鹿鼎记》的作者，还是有点吃力。

但是我越来越怀疑这些作品的真正作者到底是不是金大师。理由如下：

金大师的第一部作品是1955年的《书剑恩仇录》，是公认的很不错的作品。到了1961开始写《鸳鸯刀》、《白马啸西风》，这是金大师所有作品中超级烂的两部，完全属于一个三流写手的水准。这里出现了第一个疑点：一个专业人士在不间断训练的情况下，技术水平居然没有提高反而出现大幅度的滑坡，太不可思议了！同时请注意，1961年，金大师在写另外一部十分精彩的作品《倚天屠龙记》。同一时间出现的作品水平差距竟然如此之远，这已经不是不可思议而是匪夷所思了。
1963至1964年金大师在写作最精彩的作品《天龙八部》期间到欧洲游历，但是期间《天龙八部》在《明报》上的连载并未间断，这可能是金大师的一个疏忽，临走前忘记交代枪手暂停一下。但是就有人就这个问题提出质疑，金大师的解释是：好朋友倪匡代写了一部分。倪匡，想必有看武侠的朋友都知道。既然金大师都承认一部分是别人代笔的，那么我们完全有理由相信整部作品都是枪手操作的，甚至还不是一部作品或者一个枪手。当时金大师是《明报》的老板，叫几个写手署一个他指定的笔名应该不是太困难。
金大师在小说写作上封笔之后是不是都没有动过笔呢？不是的。他还写过一些社论和演讲稿。大家有兴趣可以去观摩一下。我这里以一个小辈的态度客观谈一下大师1994年在北大关于中国历史观的演讲。整个演讲的风格是自得中略显浮夸，客套中稍带吹捧，类似于后来的杨振宁风格，总之缺乏本应该表现出来的大师风范。就演讲内容而言，谈了一些民族融合的表面现象，没有深入剖析，很象一个中学历史老师的教案。这绝对不是能写出《天龙八部》作者的手笔。
很明显，金大师最近几年对早期作品表示出相当的不满，所以不时冒出来修理加工一下。文学史上对自己经典作品不断修改的作家也不在少数，但是能够作到每一处的改动都能够达到画蛇添足效果的只有金大师一个人！这不能不说是一种极其罕见并且怪异的现象。从改动的思路来看，改动者完全不能领会原作品中体现出来深层的人生哲理，而是从一些世俗、粗糙、表面化的角度去处理某些情节。比如对《鹿鼎记》的修改，我只能说这个大师想给断臂的维纳斯接上义肢。这样非但浅薄而且可笑的行为居然出自一个绝顶高手，我们不得不怀疑。合理的解释就是，原来的作者根本就是另有其人。
谁是抢手？金大师写第一部作品《书剑恩仇录》于1955年，当时的身份是《新晚报》的编辑。《新晚报》原来一直在连载梁羽生的武侠，2月初梁一时没有时间继续，总编罗孚叫金大师（当然，当时还离大师很远。）写一部先顶一下，于是《书》开始连载。该作品的前面几个章节主要应该是由今完成的，为什么仅仅是主要而不是独立完成？因为《新晚报》的主编还不至于那么大胆将这样的大任务完全交代给一个从前从来没有写过小说（这是金大师自己说的）的编辑。《书》的前面几个章节也平淡无奇，丝毫没有引起太多的关注，但是细心的朋友可以发现该书从第7章《剑气沉沉作龙吟》开始，写作的风格和手法逐步作了大幅度的调整，才使这部小说免于落入俗套。当年这部作品也正是从载了一半左右开始吸引大批读者的。那么，后半部《书》到底是哪位出手的呢？请诸位自己去把梁羽生的《七剑下天山》《白发魔女传》等作品和《书》比较一下。我想，第一位出场的枪手应该是梁羽生。
1956年写的《碧血剑》应该是第一部金大师独立完成的作品，这部作品连载于《香港商报》，此时梁羽生于公于私都不会给他代笔，但是在整体设计上给予了一定的帮助。《书剑恩仇录》的成功使金大师认识到一点：武侠不能是粗糙的打打杀杀。所以在《碧》一书将场景设计在明末，引入了崇祯和他的公主，虽然有点牵强但是总算是超越旧套的武侠。传说中金大师精通佛学、道学和儒学的深厚功力在这部小说中没有丝毫痕迹，所引用的部分诗词也未能柔和顺畅地溶入作品。该文意图刻画的袁承志在大侠风范上与郭靖、萧峰相去甚远，在快意恩仇上无法与令狐冲、杨过相提并论，在书中的风头甚至被一个配角金蛇郎君盖过。该书在人物形象描写上是有硬伤的，质量在十四部作品中应该属于倒数有名的，但是金大师不止一次地宣称这是他最满意的作品，或许有点国人惯有的敝帚自珍心理吧。《碧》书代表了金大师早期的功力。
1957年伟大的作品《射雕英雄传》开始动工，但是这部作品并不是从一开始就精彩纷呈，金大师的可能是想迎合当时大量老派读者的阅读习惯同时加大武侠小说的文学韵味，所以在前几章中密集地使用了诸如：正是：阴世新添枉死鬼，阳间不见少年人！；可怜她：花容月貌无双女，惆怅芳魂赴九泉。这样半江湖半文言的语句。这一用句特点在后来的《鸳鸯刀》中表现最为明显，个人认为这很能反映金大师的语言功底，毕竟是学法律出生，写作又是以评论性的杂文见长。这时候有一个传奇任务从遥远的内蒙古一路历经千心万苦跑到了香港，他接下了金大师的棒，成就了《射雕英雄传》。《射》中有一个若隐偌现的人物—–俅千仗，这个人物与全文发展思路基本无关，但却给予了相当的笔墨，是不是在暗示着某种东西呢？从前给皇室制作工艺品的匠人都喜欢在隐蔽的地方留下属于自己的痕迹，比如刻上名字，尽管这样有杀头的危险。同时请大家注意黄蓉的出场方式，绝对不象金大师手笔。最重要的枪手倪匡出场，他将在以后的系列作品中担负艰巨的任务。
倪匡当时的身份是偷渡到港的低级产业工人，具有外星人般的文学天赋，作为报社编辑的金大师偶然发现了这样的人才。如果倪为金大师代笔，对大家都有好处，何乐而不为呢？

📓 注意

本人意图并非对某个人进行攻击，只是想能以科学求实的态度引出点滴值得探讨的问题，如果让一些FANS感到不满，敬请谅解！希望大家都应该有点陈寅恪先生提出的“独立之精神，自由之思想”，不要让惯有的思维禁锢自己的灵魂。