summaryrefslogtreecommitdiff
path: root/luaotfload-database.lua
blob: 50f3e08953e5db16b6a01fb40e7def63682d7fe1 (plain)
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
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
if not modules then modules = { } end modules ['luaotfload-database'] = {
    version   = 2.2,
    comment   = "companion to luaotfload.lua",
    author    = "Khaled Hosny and Elie Roux",
    copyright = "Luaotfload Development Team",
    license   = "GNU GPL v2"
}

--- TODO: if the specification is an absolute filename with a font not in the 
--- database, add the font to the database and load it. There is a small
--- difficulty with the filenames of the TEXMF tree that are referenced as
--- relative paths...

--- Luatex builtins
local load                    = load
local next                    = next
local pcall                   = pcall
local require                 = require
local tonumber                = tonumber

local fontloaderinfo          = fontloader.info
local iolines                 = io.lines
local ioopen                  = io.open
local kpseexpand_path         = kpse.expand_path
local kpseexpand_var          = kpse.expand_var
local kpselookup              = kpse.lookup
local kpsereadable_file       = kpse.readable_file
local mathabs                 = math.abs
local mathmin                 = math.min
local stringfind              = string.find
local stringformat            = string.format
local stringgmatch            = string.gmatch
local stringgsub              = string.gsub
local stringlower             = string.lower
local stringsub               = string.sub
local stringupper             = string.upper
local tableconcat             = table.concat
local tablecopy               = table.copy
local tablesort               = table.sort
local tabletofile             = table.tofile
local texiowrite_nl           = texio.write_nl
local utf8gsub                = unicode.utf8.gsub
local utf8lower               = unicode.utf8.lower

--- these come from Lualibs/Context
local dirglob                 = dir.glob
local dirmkdirs               = dir.mkdirs
local filebasename            = file.basename
local filedirname             = file.dirname
local filecollapsepath        = file.collapsepath or file.collapse_path
local fileextname             = file.extname
local fileiswritable          = file.iswritable
local filejoin                = file.join
local filereplacesuffix       = file.replacesuffix
local filesplitpath           = file.splitpath or file.split_path
local stringis_empty          = string.is_empty
local stringsplit             = string.split
local stringstrip             = string.strip
local tableappend             = table.append
local tabletohash             = table.tohash

--- the font loader namespace is “fonts”, same as in Context
fonts                = fonts       or { }
fonts.names          = fonts.names or { }

local names          = fonts.names

names.version        = 2.2
names.data           = nil
names.path           = {
    basename = "luaotfload-names.lua",
    dir      = "",
    path     = "",
}

-- We use the cache.* of ConTeXt (see luat-basics-gen), we can
-- use it safely (all checks and directory creations are already done). It
-- uses TEXMFCACHE or TEXMFVAR as starting points.
local writable_path = caches.getwritablepath("names","")
if not writable_path then
  error("Impossible to find a suitable writeable cache...")
end
names.path.dir = writable_path
names.path.path = filejoin(writable_path, names.path.basename)


---- <FIXME>
---
--- these lines load some binary module called “lualatex-platform”
--- that doesn’t appear to build with Lua 5.2. I’m going ahead and
--- disable it for the time being until someone clarifies what it
--- is supposed to do and whether we should care to fix it.
---
--local success = pcall(require, "luatexbase.modutils")
--if success then
--   success = pcall(luatexbase.require_module,
--                   "lualatex-platform", "2011/03/30")
--    print(success)
--end

--local get_installed_fonts
--if success then
--   get_installed_fonts = lualatex.platform.get_installed_fonts
--else
--   function get_installed_fonts()
--   end
--end
---- </FIXME>

local get_installed_fonts = nil

--[[doc--
Auxiliary functions
--doc]]--


local report = logs.names_report

local sanitize_string = function (str)
    if str ~= nil then
        return utf8gsub(utf8lower(str), "[^%a%d]", "")
    end
    return nil
end

--[[doc--
This is a sketch of the db:

    type dbobj = {
        mappings : fontentry list;
        status   : filestatus;
        version  : float;
    }
    and fontentry = {
        familyname  : string;
        filename    : (string * bool);
        fontname    : string;
        fullname    : string;
        names       : {
            family     : string;
            fullname   : string;
            psname     : string;
            subfamily  : string;
        }
        size        : int list;
        slant       : int;
        weight      : int;
        width       : int;
    }
    and filestatus = (fullname, { index : int list; timestamp : int }) dict

beware that this is a reconstruction and may be incomplete.

--doc]]--

local fontnames_init = function ( )
    return {
        mappings  = { },
        status    = { },
        filenames = { }, --- (basename, fullname) hash; maybe overkill
        version   = names.version,
    }
end

local make_name = function (path)
    return filereplacesuffix(path, "lua"), filereplacesuffix(path, "luc")
end

--- When loading a lua file we try its binary complement first, which
--- is assumed to be located at an identical path, carrying the suffix
--- .luc.

local code_cache = { }

--- string -> (string * table)
local load_lua_file = function (path)
    local code = code_cache[path]
    if code then return path, code() end

    local foundname = filereplacesuffix(path, "luc")

    local fh = ioopen(foundname, "rb") -- try bin first
    if fh then
        local chunk = fh:read"*all"
        fh:close()
        code = load(chunk, "b")
    end

    if not code then --- fall back to text file
        foundname = filereplacesuffix(path, "lua")
        fh = ioopen(foundname, "rb")
        if fh then
            local chunk = fh:read"*all"
            fh:close()
            code = load(chunk, "t")
        end
    end

    if not code then return nil, nil end

    code_cache[path] = code --- insert into memo
    return foundname, code()
end

--- define locals in scope
local find_closest
local font_fullinfo
local load_names
local read_fonts_conf
local reload_db
local resolve
local save_names
local scan_external_dir
local update_names

load_names = function ( )
    local starttime = os.gettimeofday()
    local foundname, data = load_lua_file(names.path.path)

    if data then
        report("info", 1, "db",
            "Font names database loaded", "%s", foundname)
        report("info", 1, "db", "Loading took %0.f ms",
                                1000*(os.gettimeofday()-starttime))
    else
        report("info", 0, "db",
            [[Font names database not found, generating new one.
             This can take several minutes; please be patient.]])
        data = update_names(fontnames_init())
        save_names(data)
    end
    return data
end

local fuzzy_limit = 1 --- display closest only

local style_synonyms = { set = { } }
do
    style_synonyms.list = {
        regular    = { "normal",        "roman",
                       "plain",         "book",
                       "medium", },
        bold       = { "demi",           "demibold",
                       "semibold",       "boldregular",},
        italic     = { "regularitalic",  "normalitalic",
                       "oblique",        "slanted", },
        bolditalic = { "boldoblique",    "boldslanted",
                       "demiitalic",     "demioblique",
                       "demislanted",    "demibolditalic",
                       "semibolditalic", },
    }

    for category, synonyms in next, style_synonyms.list do
        style_synonyms.set[category] = tabletohash(synonyms, true)
    end
end

--- state of the database
local fonts_loaded   = false
local fonts_reloaded = false

--[[doc--

Luatex-fonts, the font-loader package luaotfload imports, comes with
basic file location facilities (see luatex-fonts-syn.lua).
However, the builtin functionality is too limited to be of more than
basic use, which is why we supply our own resolver that accesses the
font database created by the mkluatexfontdb script.

--doc]]--


---
--- the request specification has the fields:
---
---   · features: table
---     · normal: set of { ccmp clig itlc kern liga locl mark mkmk rlig }
---     · ???
---   · forced:   string
---   · lookup:   "name" | "file"
---   · method:   string
---   · name:     string
---   · resolved: string
---   · size:     int
---   · specification: string (== <lookup> ":" <name>)
---   · sub:      string
---
--- the return value of “resolve” is the file name of the requested
--- font
---
--- 'a -> 'a -> table -> (string * string | bool * bool)
---
---     note by phg: I added a third return value that indicates a
---     successful lookup as this cannot be inferred from the other
---     values.
---
--- 
resolve = function (_,_,specification) -- the 1st two parameters are used by ConTeXt
    local name  = sanitize_string(specification.name)
    local style = sanitize_string(specification.style) or "regular"

    local size
    if specification.optsize then
        size = tonumber(specification.optsize)
    elseif specification.size then
        size = specification.size / 65536
    end

    if not fonts_loaded then
        names.data   = load_names()
        fonts_loaded = true
    end

    local data = names.data
    if type(data) == "table" then
        local db_version, nms_version = data.version, names.version
        if data.version ~= names.version then
            report("log", 0, "db",
                [[version mismatch; expected %4.3f, got %4.3f]],
                nms_version, db_version
            )
            return reload_db(resolve, nil, nil, specification)
        end
        if data.mappings then
            local found = { }
            local synonym_set = style_synonyms.set
            for _,face in next, data.mappings do
                --- TODO we really should store those in dedicated
                --- .sanitized field
                local family    = sanitize_string(face.names and face.names.family)
                local subfamily = sanitize_string(face.names and face.names.subfamily)
                local fullname  = sanitize_string(face.names and face.names.fullname)
                local psname    = sanitize_string(face.names and face.names.psname)
                local fontname  = sanitize_string(face.fontname)
                local pfullname = sanitize_string(face.fullname)
                local optsize, dsnsize, maxsize, minsize
                if #face.size > 0 then
                    optsize = face.size
                    dsnsize = optsize[1] and optsize[1] / 10
                    -- can be nil
                    maxsize = optsize[2] and optsize[2] / 10 or dsnsize
                    minsize = optsize[3] and optsize[3] / 10 or dsnsize
                end
                if name == family then
                    if subfamily == style then
                        if optsize then
                            if dsnsize == size
                            or (size > minsize and size <= maxsize) then
                                found[1] = face
                                break
                            else
                                found[#found+1] = face
                            end
                        else
                            found[1] = face
                            break
                        end
                    elseif synonym_set[style] and
                           synonym_set[style][subfamily] then
                        if optsize then
                            if dsnsize == size
                            or (size > minsize and size <= maxsize) then
                                found[1] = face
                                break
                            else
                                found[#found+1] = face
                            end
                        else
                            found[1] = face
                            break
                        end
                    elseif subfamily == "regular" or
                           synonym_set.regular[subfamily] then
                        found.fallback = face
                    end
                else
                    if name == fullname
                    or name == pfullname
                    or name == fontname
                    or name == psname then
                        if optsize then
                            if dsnsize == size
                            or (size > minsize and size <= maxsize) then
                                found[1] = face
                                break
                            else
                                found[#found+1] = face
                            end
                        else
                            found[1] = face
                            break
                        end
                    end
                end
            end
            if #found == 1 then
                if kpselookup(found[1].filename[1]) then
                    report("log", 0, "resolve",
                        "font family='%s', subfamily='%s' found: %s",
                        name, style, found[1].filename[1]
                    )
                    return found[1].filename[1], found[1].filename[2], true
                end
            elseif #found > 1 then
                -- we found matching font(s) but not in the requested optical
                -- sizes, so we loop through the matches to find the one with
                -- least difference from the requested size.
                local closest
                local least = math.huge -- initial value is infinity
                for i,face in next, found do
                    local dsnsize    = face.size[1]/10
                    local difference = mathabs(dsnsize-size)
                    if difference < least then
                        closest = face
                        least   = difference
                    end
                end
                if kpselookup(closest.filename[1]) then
                    report("log", 0, "resolve",
                        "font family='%s', subfamily='%s' found: %s",
                        name, style, closest.filename[1]
                    )
                    return closest.filename[1], closest.filename[2], true
                end
            elseif found.fallback then
                return found.fallback.filename[1], found.fallback.filename[2], true
            end
            --- no font found so far
            if not fonts_reloaded then
                --- last straw: try reloading the database
                return reload_db(resolve, nil, nil, specification)
            else
                --- else, fallback to requested name
                --- specification.name is empty with absolute paths, looks
                --- like a bug in the specification parser <TODO< is it still
                --- relevant? looks not...
                return specification.name, false, false
            end
        end
    else --- no db or outdated; reload names and retry
        if not fonts_reloaded then
            return reload_db(resolve, nil, nil, specification)
        else --- unsucessfully reloaded; bail
            return specification.name, false, false
        end
    end
end --- resolve()

--- when reload is triggered we update the database
--- and then re-run the caller with the arg list

--- ('a -> 'a) -> 'a list -> 'a
reload_db = function (caller, ...)
    report("log", 1, "db", "reload initiated")
    names.data = update_names()
    save_names(names.data)
    fonts_reloaded = true
    return caller(...)
end

--- string -> string -> int
local iterative_levenshtein = function (s1, s2)

  local costs = { }
  local len1, len2 = #s1, #s2

  for i = 0, len1 do
    local last = i
    for j = 0, len2 do
      if i == 0 then
        costs[j] = j
      else
        if j > 0 then
          local current = costs[j-1]
          if stringsub(s1, i, i) ~= stringsub(s2, j, j) then
            current = mathmin(current, last, costs[j]) + 1
          end
          costs[j-1] = last
          last = current
        end
      end
    end
    if i > 0 then costs[len2] = last end
  end

  return costs[len2]--- lower right has the distance
end

--- string -> int -> bool
find_closest = function (name, limit)
    local name     = sanitize_string(name)
    limit          = limit or fuzzy_limit

    if not fonts_loaded then
        names.data = load_names()
        fonts_loaded     = true
    end

    local data = names.data

    if type(data) == "table" then
        local by_distance   = { } --- (int, string list) dict
        local distances     = { } --- int list
        local cached        = { } --- (string, int) dict
        local mappings      = data.mappings
        local n_fonts       = #mappings

        for n = 1, n_fonts do
            local current    = mappings[n]
            local cnames     = current.names
            --[[
                This is simplistic but surpisingly fast.
                Matching is performed against the “family” name
                of a db record. We then store its “fullname” at
                it edit distance.
                We should probably do some weighting over all the
                font name categories as well as whatever agrep
                does.
            --]]
            if cnames then
                local fullname, family = cnames.fullname, cnames.family
                family = sanitize_string(family)

                local dist = cached[family]--- maybe already calculated
                if not dist then
                    dist = iterative_levenshtein(name, family)
                    cached[family] = dist
                end
                local namelst = by_distance[dist]
                if not namelst then --- first entry
                    namelst = { fullname }
                    distances[#distances+1] = dist
                else --- append
                    namelst[#namelst+1] = fullname
                end
                by_distance[dist] = namelst
            end
        end

        --- print the matches according to their distance
        local n_distances = #distances
        if n_distances > 0 then --- got some data
            tablesort(distances)
            limit = mathmin(n_distances, limit)
            report(false, 1, "query",
                    "displaying %d distance levels", limit)

            for i = 1, limit do
                local dist     = distances[i]
                local namelst  = by_distance[dist]
                report(false, 0, "query",
                    "distance from “" .. name .. "”: " .. dist
                 .. "\n    " .. tableconcat(namelst, "\n    ")
                )
            end

            return true
        end
        return false
    else --- need reload
        return reload_db(find_closest, name)
    end
    return false
end --- find_closest()

--[[doc--
The data inside an Opentype font file can be quite heterogeneous.
Thus in order to get the relevant information, parts of the original
table as returned by the font file reader need to be relocated.
--doc]]--
font_fullinfo = function (filename, subfont, texmf)
    local tfmdata = { }
    local rawfont = fontloader.open(filename, subfont)
    if not rawfont then
        report("log", 1, "error", "failed to open %s", filename)
        return
    end
    local metadata = fontloader.to_table(rawfont)
    fontloader.close(rawfont)
    collectgarbage("collect")
    -- see http://www.microsoft.com/typography/OTSPEC/features_pt.htm#size
    if metadata.fontstyle_name then
        for _, name in next, metadata.fontstyle_name do
            if name.lang == 1033 then --- I hate magic numbers
                tfmdata.fontstyle_name = name.name
            end
        end
    end
    if metadata.names then
        for _, namedata in next, metadata.names do
            if namedata.lang == "English (US)" then
                tfmdata.names = {
                    --- see
                    --- https://developer.apple.com/fonts/TTRefMan/RM06/Chap6name.html
                    fullname = namedata.names.compatfull
                            or namedata.names.fullname,
                    family   = namedata.names.preffamilyname
                            or namedata.names.family,
                    subfamily= tfmdata.fontstyle_name
                            or namedata.names.prefmodifiers
                            or namedata.names.subfamily,
                    psname   = namedata.names.postscriptname
                }
            end
        end
    else
        -- no names table, propably a broken font
        report("log", 1, "db", "broken font rejected", "%s", basefile)
        return
    end
    tfmdata.fontname    = metadata.fontname
    tfmdata.fullname    = metadata.fullname
    tfmdata.familyname  = metadata.familyname
    tfmdata.filename    = {
        texmf and filebasename(filename) or filename,
        subfont
    }
    tfmdata.weight      = metadata.pfminfo.weight
    tfmdata.width       = metadata.pfminfo.width
    tfmdata.slant       = metadata.italicangle
    -- don't waste the space with zero values
    tfmdata.size = {
        metadata.design_size         ~= 0 and metadata.design_size         or nil,
        metadata.design_range_top    ~= 0 and metadata.design_range_top    or nil,
        metadata.design_range_bottom ~= 0 and metadata.design_range_bottom or nil,
    }
    return tfmdata
end

--- we return true if the fond is new or re-indexed
--- string -> dbobj -> dbobj -> bool -> bool
local load_font = function (fullname, fontnames, newfontnames, texmf)
    local newmappings   = newfontnames.mappings
    local newstatus     = newfontnames.status
    local mappings      = fontnames.mappings
    local status        = fontnames.status
    local filenames     = fontnames.filenames
    local basename      = filebasename(fullname)
    --- entryname is apparently the identifier a font is
    --- loaded by; it is different for files in the texmf
    --- (due to kpse? idk.)
    --- entryname = texmf : true -> basename | false -> fullname
    local entryname     = texmf and basename or fullname

    if not fullname then return false end

    if names.blacklist[fullname]
    or names.blacklist[basename]
    then
        report("log", 2, "db",
            "ignoring blacklisted font “%s”", fullname)
        return false
    end
    local timestamp, db_timestamp
    db_timestamp        = status[entryname]
                        and status[entryname].timestamp
    timestamp           = lfs.attributes(fullname, "modification")

    local index_status = newstatus[entryname]
                        or (not texmf and newstatus[basename])
    local teststat = newstatus[entryname]
    --- index_status: nil | false | table
    if index_status and index_status.timestamp == timestamp then
        -- already indexed this run
        return false
    end

    newstatus[entryname]           = newstatus[entryname] or { }
    newstatus[entryname].timestamp = timestamp
    newstatus[entryname].index     = newstatus[entryname].index or { }

    if db_timestamp == timestamp and not newstatus[entryname].index[1] then
        for _,v in next, status[entryname].index do
            local index = #newstatus[entryname].index
            newmappings[#newmappings+1]        = mappings[v]
            newstatus[entryname].index[index+1] = #newmappings
        end
        report("log", 2, "db", "font “%s” already indexed", entryname)
        return false
    end
    local info = fontloaderinfo(fullname)

    if info then
        if type(info) == "table" and #info > 1 then
            for i in next, info do
                local fullinfo = font_fullinfo(fullname, i-1, texmf)
                if not fullinfo then
                    return false
                end
                local index = newstatus[entryname].index[i]
                if newstatus[entryname].index[i] then
                    index = newstatus[entryname].index[i]
                else
                    index = #newmappings+1
                end
                newmappings[index]           = fullinfo
                newstatus[entryname].index[i] = index
            end
        else
            local fullinfo = font_fullinfo(fullname, false, texmf)
            if not fullinfo then
                return false
            end
            local index
            if newstatus[entryname].index[1] then
                index = newstatus[entryname].index[1]
            else
                index = #newmappings+1
            end
            newmappings[index]           = fullinfo
            newstatus[entryname].index[1] = index
        end

    else --- missing info
        report("log", 1, "db", "failed to load “%s”", entryname)
        return false
    end
    return true
end

local path_normalize
do
    --- os.type and os.name are constants so we
    --- choose a normalization function in advance
    --- instead of testing with every call
    local os_type, os_name = os.type, os.name
    local filecollapsepath = filecollapsepath
    local lfsreadlink      = lfs.readlink

    --- windows and dos
    if os_type == "windows" or os_type == "msdos" then
        --- ms platfom specific stuff
        path_normalize = function (path)
            path = stringgsub(path, '\\', '/')
            path = stringlower(path)
            path = stringgsub(path, '^/cygdrive/(%a)/', '%1:/')
            path = filecollapsepath(path)
            return path
        end

    elseif os_name == "cygwin" then -- union of ms + unix
        path_normalize = function (path)
            path = stringgsub(path, '\\', '/')
            path = stringlower(path)
            path = stringgsub(path, '^/cygdrive/(%a)/', '%1:/')
            local dest = lfsreadlink(path)
            if dest then
                if kpsereadable_file(dest) then
                    path = dest
                elseif kpsereadable_file(filejoin(filedirname(path), dest)) then
                    path = filejoin(file.dirname(path), dest)
                else
                    -- broken symlink?
                end
            end
            path = filecollapsepath(path)
            return path
        end

    else -- posix
        path_normalize = function (path)
            local dest = lfsreadlink(path)
            if dest then
                if kpsereadable_file(dest) then
                    path = dest
                elseif kpsereadable_file(filejoin(filedirname(path), dest)) then
                    path = filejoin(file.dirname(path), dest)
                else
                    -- broken symlink?
                end
            end
            path = filecollapsepath(path)
            return path
        end
    end
end

fonts.path_normalize = path_normalize

names.blacklist = { }

local function read_blacklist()
    local files = {
        kpselookup("luaotfload-blacklist.cnf", {all=true, format="tex"})
    }
    local blacklist = names.blacklist
    local whitelist = { }

    if files and type(files) == "table" then
        for _,v in next, files do
            for line in iolines(v) do
                line = stringstrip(line) -- to get rid of lines like " % foo"
                local first_chr = stringsub(line, 1, 1) --- faster than find
                if first_chr == "%" or stringis_empty(line) then
                    -- comment or empty line
                else
                    --- this is highly inefficient
                    line = stringsplit(line, "%")[1]
                    line = stringstrip(line)
                    if stringsub(line, 1, 1) == "-" then
                        whitelist[stringsub(line, 2, -1)] = true
                    else
                        report("log", 2, "db", "blacklisted file “%s”", line)
                        blacklist[line] = true
                    end
                end
            end
        end
    end
    for _,fontname in next, whitelist do
      blacklist[fontname] = nil
    end
end

local font_extensions = { "otf", "ttf", "ttc", "dfont" }
local font_extensions_set = {}
for key, value in next, font_extensions do
   font_extensions_set[value] = true
end

--- string -> dbobj -> dbobj -> bool -> (int * int)
local scan_dir = function (dirname, fontnames, newfontnames, texmf)
    --[[
    This function scans a directory and populates the list of fonts
    with all the fonts it finds.
    - dirname is the name of the directory to scan
    - names is the font database to fill -> no such term!!!
    - texmf is a boolean saying if we are scanning a texmf directory
    ]]
    local n_scanned, n_new = 0, 0   --- total of fonts collected
    report("log", 2, "db", "scanning", "%s", dirname)
    for _,i in next, font_extensions do
        for _,ext in next, { i, stringupper(i) } do
            local found = dirglob(stringformat("%s/**.%s$", dirname, ext))
            local n_found = #found
            --- note that glob fails silently on broken symlinks, which
            --- happens sometimes in TeX Live.
            report("log", 2, "db", "%s '%s' fonts found", n_found, ext)
            n_scanned = n_scanned + n_found
            for j=1, n_found do
                local fullname = found[j]
                fullname = path_normalize(fullname)
                report("log", 2, "db", "loading font “%s”", fullname)
                local new = load_font(fullname, fontnames, newfontnames, texmf)
                if new then n_new = n_new + 1 end
            end
        end
    end
    report("log", 2, "db", "%d fonts found in '%s'", n_scanned, dirname)
    return n_scanned, n_new
end

local function scan_texmf_fonts(fontnames, newfontnames)
    local n_scanned, n_new = 0, 0
    --[[
    This function scans all fonts in the texmf tree, through kpathsea
    variables OPENTYPEFONTS and TTFONTS of texmf.cnf
    ]]
    if stringis_empty(kpseexpand_path("$OSFONTDIR")) then
        report("info", 1, "db", "Scanning TEXMF fonts...")
    else
        report("info", 1, "db", "Scanning TEXMF and OS fonts...")
    end
    local fontdirs = stringgsub(kpseexpand_path("$OPENTYPEFONTS"), "^%.", "")
    fontdirs       = fontdirs .. stringgsub(kpseexpand_path("$TTFONTS"), "^%.", "")
    if not stringis_empty(fontdirs) then
        for _,d in next, filesplitpath(fontdirs) do
            local found, new = scan_dir(d, fontnames, newfontnames, true)
            n_scanned = n_scanned + found
            n_new     = n_new     + new
        end
    end
    return n_scanned, n_new
end

--[[
  For the OS fonts, there are several options:
   - if OSFONTDIR is set (which is the case under windows by default but
     not on the other OSs), it scans it at the same time as the texmf tree,
     in the scan_texmf_fonts.
   - if not:
     - under Windows and Mac OSX, we take a look at some hardcoded directories
     - under Unix, we read /etc/fonts/fonts.conf and read the directories in it

  This means that if you have fonts in fancy directories, you need to set them
  in OSFONTDIR.
]]

--- (string -> tab -> tab -> tab)
read_fonts_conf = function (path, results, passed_paths)
    --[[
    This function parses /etc/fonts/fonts.conf and returns all the dir
    it finds.  The code is minimal, please report any error it may
    generate.

    TODO    fonts.conf are some kind of XML so in theory the following
            is totally inappropriate. Maybe a future version of the
            lualibs will include the lxml-* files from Context so we
            can write something presentable instead.
    ]]
    local fh = ioopen(path)
    passed_paths[#passed_paths+1] = path
    passed_paths_set = tabletohash(passed_paths, true)
    if not fh then
        report("log", 2, "db", "cannot open file %s", path)
        return results
    end
    local incomments = false
    for line in fh:lines() do
        while line and line ~= "" do
            -- spaghetti code... hmmm...
            if incomments then
                local tmp = stringfind(line, '-->') --- wtf?
                if tmp then
                    incomments = false
                    line = stringsub(line, tmp+3)
                else
                    line = nil
                end
            else
                local tmp = stringfind(line, '<!--')
                local newline = line
                if tmp then
                    -- for the analysis, we take everything that is before the
                    -- comment sign
                    newline = stringsub(line, 1, tmp-1)
                    -- and we loop again with the comment
                    incomments = true
                    line = stringsub(line, tmp+4)
                else
                    -- if there is no comment start, the block after that will
                    -- end the analysis, we exit the while loop
                    line = nil
                end
                for dir in stringgmatch(newline, '<dir>([^<]+)</dir>') do
                    -- now we need to replace ~ by kpse.expand_path('~')
                    if stringsub(dir, 1, 1) == '~' then
                        dir = filejoin(kpseexpand_path('~'), stringsub(dir, 2))
                    end
                    -- we exclude paths with texmf in them, as they should be
                    -- found anyway
                    if not stringfind(dir, 'texmf') then
                        results[#results+1] = dir
                    end
                end
                for include in stringgmatch(newline, '<include[^<]*>([^<]+)</include>') do
                    -- include here can be four things: a directory or a file,
                    -- in absolute or relative path.
                    if stringsub(include, 1, 1) == '~' then
                        include = filejoin(kpseexpand_path('~'),stringsub(include, 2))
                        -- First if the path is relative, we make it absolute:
                    elseif not lfs.isfile(include) and not lfs.isdir(include) then
                        include = filejoin(file.dirname(path), include)
                    end
                    if      lfs.isfile(include)
                    and     kpsereadable_file(include)
                    and not passed_paths_set[include]
                    then
                        -- maybe we should prevent loops here?
                        -- we exclude path with texmf in them, as they should
                        -- be found otherwise
                        read_fonts_conf(include, results, passed_paths)
                    elseif lfs.isdir(include) then
                        for _,f in next, dirglob(filejoin(include, "*.conf")) do
                            if not passed_paths_set[f] then
                                read_fonts_conf(f, results, passed_paths)
                            end
                        end
                    end
                end
            end
        end
    end
    fh:close()
    return results
end

-- for testing purpose
names.read_fonts_conf = read_fonts_conf

--- TODO stuff those paths into some writable table
local function get_os_dirs()
    if os.name == 'macosx' then
        return {
            filejoin(kpseexpand_path('~'), "Library/Fonts"),
            "/Library/Fonts",
            "/System/Library/Fonts",
            "/Network/Library/Fonts",
        }
    elseif os.type == "windows" or os.type == "msdos" or os.name == "cygwin" then
        local windir = os.getenv("WINDIR")
        return { filejoin(windir, 'Fonts') }
    else 
        local passed_paths = {}
        local os_dirs = {}
        for _,p in next, {"/usr/local/etc/fonts/fonts.conf", "/etc/fonts/fonts.conf"} do
            if lfs.isfile(p) then
                read_fonts_conf(p, os_dirs, passed_paths)
            end
        end
        return os_dirs
    end
    return {}
end

local function scan_os_fonts(fontnames, newfontnames)
    local n_scanned, n_new = 0, 0
    --[[
    This function scans the OS fonts through
      - fontcache for Unix (reads the fonts.conf file and scans the directories)
      - a static set of directories for Windows and MacOSX
    ]]
    report("info", 1, "db", "Scanning OS fonts...")
    report("info", 2, "db", "Searching in static system directories...")
    for _,d in next, get_os_dirs() do
        local found, new = scan_dir(d, fontnames, newfontnames, false)
        n_scanned = n_scanned + found
        n_new     = n_new     + new
    end
    return n_scanned, n_new
end

--- dbobj -> bool -> dbobj
update_names = function (fontnames, force)
    local starttime = os.gettimeofday()
    local n_scanned, n_new = 0, 0
    --[[
    The main function, scans everything
    - “newfontnames” is the final table to return
    - force is whether we rebuild it from scratch or not
    ]]
    report("info", 1, "db", "Updating the font names database"
                         .. (force and " forcefully" or ""))

    if force then
        fontnames = fontnames_init()
    else
        if not fontnames then
            fontnames = load_names()
        end
        if fontnames.version ~= names.version then
            fontnames = fontnames_init()
            report("log", 1, "db", "No font names database or old "
                                .. "one found; generating new one")
        end
    end
    local newfontnames = fontnames_init()
    read_blacklist()
    --installed_fonts_scanned = false
    --scan_installed_fonts(fontnames, newfontnames) --- see fixme above
    local scanned, new = scan_texmf_fonts(fontnames, newfontnames)
    n_scanned = n_scanned + scanned
    n_new     = n_new     + new
    --if  not installed_fonts_scanned
    --and stringis_empty(kpseexpand_path("$OSFONTDIR"))
    if stringis_empty(kpseexpand_path("$OSFONTDIR"))
    then
        local scanned, new = scan_os_fonts(fontnames, newfontnames)
        n_scanned = n_scanned + scanned
        n_new     = n_new     + new
    end
    --- stats:
    ---            before rewrite   | after rewrite
    ---   partial:         804 ms   |   701 ms
    ---   forced:        45384 ms   | 44714 ms
    report("info", 1, "db",
           "Scanned %d font files; %d new entries.", n_scanned, n_new)
    report("info", 1, "db",
           "Rebuilt in %0.f ms", 1000*(os.gettimeofday()-starttime))
    return newfontnames
end

--- dbobj -> unit
save_names = function (fontnames)
    local path  = names.path.dir
    if not lfs.isdir(path) then
        dirmkdirs(path)
    end
    path = filejoin(path, names.path.basename)
    if fileiswritable(path) then
        local luaname, lucname = make_name(path)
        tabletofile(luaname, fontnames, true)
        caches.compile(fontnames,luaname,lucname)
        report("info", 0, "db", "Font names database saved")
        return path
    else
        report("info", 0, "db", "Failed to save names database")
        return nil
    end
end

scan_external_dir = function (dir)
    local old_names, new_names
    if fonts_loaded then
        old_names = names.data
    else
        old_names = load_names()
        fonts_loaded    = true
    end
    new_names = tablecopy(old_names)
    local n_scanned, n_new = scan_dir(dir, old_names, new_names)
    names.data = new_names
    return n_scanned, n_new
end

--- export functionality to the namespace “fonts.names”
names.scan   = scan_external_dir
names.load   = load_names
names.update = update_names
names.save   = save_names

names.resolve      = resolve --- replace the resolver from luatex-fonts
names.resolvespec  = resolve
names.find_closest = find_closest

--- dummy required by luatex-fonts (cf. luatex-fonts-syn.lua)

fonts.names.getfilename = function (askedname,suffix) return "" end

-- vim:tw=71:sw=4:ts=4:expandtab