mirror of
git://xwords.git.sourceforge.net/gitroot/xwords/xwords
synced 2024-12-27 09:58:45 +01:00
Initial revision
This commit is contained in:
ehouse
parent
88f0865a4e
commit
ec410e7b21
26 changed files with 4045 additions and 0 deletions
40
xwords4/xwords4/dawg/English/Makefile
Normal file
40
xwords4/xwords4/dawg/English/Makefile
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
# -*-mode: Makefile -*-
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
TARGET_TYPE ?= FRANK
|
||||
|
||||
# This represents the default -- for now
|
||||
COMMAND = -f Makefile.BasEnglish TARGET_TYPE=FRANK
|
||||
|
||||
alleng:
|
||||
for mfile in Makefile.BasEnglish Makefile.OSW Makefile.TWL98 Makefile.CollegeEng; do \
|
||||
$(MAKE) -f $$mfile TARGET_TYPE=$(TARGET_TYPE); \
|
||||
done
|
||||
|
||||
%:
|
||||
$(MAKE) $(COMMAND) $@
|
||||
|
||||
all:
|
||||
$(MAKE) $(COMMAND)
|
||||
|
||||
clean:
|
||||
$(MAKE) $(COMMAND) clean
|
||||
|
||||
help:
|
||||
@echo "try make -f Makefile.[BasEnglish|CollegeEng] \\"
|
||||
@echo " TARGET_TYPE=[PALM|FRANK]"
|
||||
|
||||
35
xwords4/xwords4/dawg/English/Makefile.BasEnglish
Normal file
35
xwords4/xwords4/dawg/English/Makefile.BasEnglish
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# -*-mode: Makefile -*-
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
LANG=BasEnglish
|
||||
LANGCODE=en_US
|
||||
#NEWDAWG=1
|
||||
|
||||
TARGET_TYPE ?= FRANK
|
||||
|
||||
include ../Makefile.2to8
|
||||
|
||||
include ../Makefile.langcommon
|
||||
|
||||
$(LANG)Main.dict.gz: BasEnglish.dict.gz
|
||||
ln -s $< $@
|
||||
|
||||
# Everything but creating of the Main.dict file is inherited from the
|
||||
# "parent" Makefile.langcommon in the parent directory.
|
||||
|
||||
clean: clean_common
|
||||
rm -f $(LANG)Main.dict.gz *.bin $(LANG)*.pdb $(LANG)*.seb
|
||||
34
xwords4/xwords4/dawg/English/Makefile.CollegeEng
Normal file
34
xwords4/xwords4/dawg/English/Makefile.CollegeEng
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
# -*- mode: makefile; -*-
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
LANG=CollegeEng
|
||||
LANGCODE=en_US
|
||||
#NEWDAWG=1
|
||||
TARGET_TYPE=FRANK
|
||||
|
||||
include ../Makefile.2to8
|
||||
|
||||
include ../Makefile.langcommon
|
||||
|
||||
$(LANG)Main.dict.gz: CollegeEng.dict.gz
|
||||
ln -s $< $@
|
||||
|
||||
# Everything but creating of the Main.dict file is inherited from the
|
||||
# "parent" Makefile.langcommon in the parent directory.
|
||||
|
||||
clean: clean_common
|
||||
rm -f $(LANG)Main.dict.gz *.bin $(LANG)*.pdb $(LANG)*.seb
|
||||
33
xwords4/xwords4/dawg/English/Makefile.OSPD
Normal file
33
xwords4/xwords4/dawg/English/Makefile.OSPD
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
# -*- mode: makefile; compile-command: "make -f Makefile.OSPD TARGET_TYPE=PALM"; -*-
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
LANG=OSPD
|
||||
LANGCODE=en_US
|
||||
NEWDAWG=1
|
||||
|
||||
include ../Makefile.2to8
|
||||
|
||||
include ../Makefile.langcommon
|
||||
|
||||
$(LANG)Main.dict.gz: OSPD.dict.gz
|
||||
ln -s $< $@
|
||||
|
||||
# Everything but creating of the Main.dict file is inherited from the
|
||||
# "parent" Makefile.langcommon in the parent directory.
|
||||
|
||||
clean: clean_common
|
||||
rm -f $(LANG)Main.dict.gz *.bin
|
||||
35
xwords4/xwords4/dawg/English/info.data
Normal file
35
xwords4/xwords4/dawg/English/info.data
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
# I'm a comment. Any line beginning with this char will be dropped
|
||||
|
||||
LANGCODE:en_US
|
||||
|
||||
<BEGIN>
|
||||
2 0 {"_"}
|
||||
9 1 'A'
|
||||
2 3 'B'
|
||||
2 3 'C'
|
||||
4 2 'D'
|
||||
12 1 'E'
|
||||
2 4 'F'
|
||||
3 2 'G'
|
||||
2 4 'H'
|
||||
9 1 'I'
|
||||
1 8 'J'
|
||||
1 5 'K'
|
||||
4 1 'L'
|
||||
2 3 'M'
|
||||
6 1 'N'
|
||||
8 1 'O'
|
||||
2 3 'P'
|
||||
1 10 'Q'
|
||||
6 1 'R'
|
||||
4 1 'S'
|
||||
6 1 'T'
|
||||
4 1 'U'
|
||||
2 4 'V'
|
||||
2 4 'W'
|
||||
1 8 'X'
|
||||
2 4 'Y'
|
||||
1 10 'Z'
|
||||
|
||||
<END>
|
||||
# should ignore all after the <END> above
|
||||
71
xwords4/xwords4/dawg/English/info.txt
Normal file
71
xwords4/xwords4/dawg/English/info.txt
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
LANGCODE:en_US
|
||||
|
||||
# deal with DOS files
|
||||
LANGFILTER_PRECLIP: tr -d '\r' |
|
||||
|
||||
LANGFILTER_POSTCLIP: | tr [a-z] [A-Z]
|
||||
LANGFILTER_POSTCLIP: | grep '^[A-Z]*$'
|
||||
LANGFILTER_POSTCLIP: | tr -s '\n\r' '\000\000'
|
||||
LANGFILTER_POSTCLIP: | sort -z
|
||||
|
||||
# We can trust sort (above) to do the right thing since there's no
|
||||
# high ascii. dict2dawg.pl is much faster if I can trust that its
|
||||
# input is in sorted order.
|
||||
NEEDSSORT:false
|
||||
|
||||
LANGINFO: <p>English dictionaries can contain words with any of the 26
|
||||
LANGINFO: letters you think of as making up the alphabet: A-Z. At
|
||||
LANGINFO: this point any word in your list containing anything else
|
||||
LANGINFO: will simply be excluded from the dictionary.</p>
|
||||
|
||||
# High bit means "official". Next 7 bits are an enum where
|
||||
# English==1. Low byte is padding
|
||||
XLOC_HEADER:0x8100
|
||||
|
||||
<BEGIN_TILES>
|
||||
2 0 {"_"}
|
||||
9 1 'A'
|
||||
2 3 'B'
|
||||
2 3 'C'
|
||||
4 2 'D'
|
||||
12 1 'E'
|
||||
2 4 'F'
|
||||
3 2 'G'
|
||||
2 4 'H'
|
||||
9 1 'I'
|
||||
1 8 'J'
|
||||
1 5 'K'
|
||||
4 1 'L'
|
||||
2 3 'M'
|
||||
6 1 'N'
|
||||
8 1 'O'
|
||||
2 3 'P'
|
||||
1 10 'Q'
|
||||
6 1 'R'
|
||||
4 1 'S'
|
||||
6 1 'T'
|
||||
4 1 'U'
|
||||
2 4 'V'
|
||||
2 4 'W'
|
||||
1 8 'X'
|
||||
2 4 'Y'
|
||||
1 10 'Z'
|
||||
<END_TILES>
|
||||
|
||||
# should ignore all after the <END> above
|
||||
7
xwords4/xwords4/dawg/Makefile.2to8
Normal file
7
xwords4/xwords4/dawg/Makefile.2to8
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
# -*-mode: Makefile -*-
|
||||
|
||||
# These are the targets that almost all language makefiles will want.
|
||||
|
||||
SHORT_WORD = 2
|
||||
LONG_WORD = 8
|
||||
|
||||
249
xwords4/xwords4/dawg/Makefile.langcommon
Normal file
249
xwords4/xwords4/dawg/Makefile.langcommon
Normal file
|
|
@ -0,0 +1,249 @@
|
|||
# -*-mode: Makefile -*-
|
||||
|
||||
# Copyright 2000-2002 by Eric House (fixin@peak.org)
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
FRANK_EXT = xwd
|
||||
|
||||
# this will make all dicts the new, larger type
|
||||
#FORCE_4 = -force4
|
||||
|
||||
PALM_DICT_TYPE = DAWG
|
||||
PAR = ../par.pl
|
||||
#PAR = par # available from djw.org
|
||||
|
||||
LANGUAGE = $(shell basename $$(pwd))
|
||||
|
||||
#all: target_all
|
||||
|
||||
# let languages set this first, but we always add blank to it.
|
||||
BLANK_INFO = "_" /dev/null /dev/null
|
||||
|
||||
# Supply a default so don't have to type so much; feel free to change
|
||||
TARGET_TYPE ?= FRANK
|
||||
|
||||
ifdef NEWDAWG
|
||||
TABLE_ARG = -mn
|
||||
else
|
||||
TABLE_ARG = -m
|
||||
endif
|
||||
|
||||
##############################################################################
|
||||
# PalmOS rules
|
||||
##############################################################################
|
||||
ifeq ($(TARGET_TYPE),PALM)
|
||||
|
||||
ifdef NEWDAWG
|
||||
PDBTYPE = Xwr4
|
||||
else
|
||||
PDBTYPE = Xwr3
|
||||
endif
|
||||
|
||||
all: $(LANG)2to8.pdb
|
||||
|
||||
empty: $(LANG)0to0.pdb
|
||||
|
||||
# Those languages that have bitmap files for custom glyphs will need to
|
||||
# define BMPBINFILES and perhaps provide a rule for building the files
|
||||
binfiles.stamp: $(BMPBINFILES)
|
||||
touch binfiles.stamp
|
||||
|
||||
palmspecials.bin: ../palm_mkspecials.pl $(BMPFILES)
|
||||
$< $(BLANK_INFO) $(LANG_SPECIAL_INFO) > $@
|
||||
|
||||
# can't just use values.bin because the specials bitmap info is
|
||||
# platform-specific
|
||||
palmvalues.bin: values.bin palmspecials.bin
|
||||
cat $^ > $@
|
||||
|
||||
# values.bin: palmspecials.bin ../xloc binfiles.stamp
|
||||
# cd ../ && $(MAKE) xloc
|
||||
# binfileparms=""; \
|
||||
# if [ "$(BMPBINFILES)" != "" ]; then \
|
||||
# for f in $(BMPBINFILES)""; \
|
||||
# do binfileparms="$$binfileparms -i $$f"; \
|
||||
# done; \
|
||||
# fi; \
|
||||
# ../xloc -l $(LANGCODE) $$binfileparms -T $@
|
||||
# cat palmspecials.bin >> $@
|
||||
|
||||
# header (first record) is node count (long) and 4 chars:
|
||||
# unsigned char firstEdgeRecNum;
|
||||
# unsigned char charTableRecNum;
|
||||
# unsigned char valTableRecNum;
|
||||
# unsigned char reserved[3]; // worst case this points to a new resource
|
||||
|
||||
# include "flags" as used on the other platforms
|
||||
palmheader%.bin: $(LANG)%_wordcount.bin $(LANG)%_flags.bin
|
||||
rm -f $@
|
||||
touch $@
|
||||
ifdef NEWDAWG
|
||||
cat $(LANG)$*_flags.bin >> $@
|
||||
endif
|
||||
cat $< >> $@
|
||||
perl -e "print pack(\"C\",3)" >> $@ # first edge
|
||||
perl -e "print pack(\"C\",1)" >> $@ # char table rec number
|
||||
perl -e "print pack(\"C\",2)" >> $@ # valTable rec number
|
||||
perl -e "print pack(\"CCC\",0)" >> $@ # reserved 3 bytes
|
||||
perl -e "print pack(\"CC\",0)" >> $@ # c code added two more...
|
||||
|
||||
|
||||
# This works, but leaves out the header info that the current version
|
||||
# has. I'm not sure anybody cares, though...
|
||||
$(LANG)%.pdb: dawg$(LANG)%.stamp table.bin palmvalues.bin palmheader%.bin
|
||||
$(PAR) c -a backup $@ \
|
||||
$(basename $(@F)) $(PALM_DICT_TYPE) $(PDBTYPE) \
|
||||
palmheader$*.bin table.bin palmvalues.bin dawg$(LANG)$*_*.bin
|
||||
|
||||
# start=$$(echo $@ | sed -e 's/$(LANG)\([0-9]*\)to[0-9]*.pdb/\1/'); \
|
||||
# end=$$(echo $@ | sed -e 's/$(LANG)[0-9]*to\([0-9]*\).pdb/\1/'); \
|
||||
# zcat $< | grep "^.\{$${start},$${end}\}$$" | \
|
||||
# ../dict2pdb -t table.bin -v values.bin -n $(basename $(@F)) \
|
||||
# > $@
|
||||
|
||||
# the files to export for byod
|
||||
byodbins: table.bin values.bin palmvalues.bin
|
||||
|
||||
#endif # TARGET_TYPE==PALM
|
||||
|
||||
##############################################################################
|
||||
# Franklin ebook rules
|
||||
##############################################################################
|
||||
else
|
||||
ifeq ($(TARGET_TYPE),FRANK)
|
||||
|
||||
all: $(LANG)2to8.seb
|
||||
|
||||
empty: $(LANG)0to0.seb
|
||||
|
||||
# get defn of ESDK_CREATESEB_EXE
|
||||
include ${EBOOKMAN_SDK}/ebsdk.uses
|
||||
|
||||
# a binary file (one byte) giving the number of tiles in the dict
|
||||
charcount.bin: table.bin
|
||||
ifdef NEWDAWG
|
||||
siz=$$(wc -c $< | sed -e 's/$<//'); \
|
||||
perl -e "print pack(\"c\",$$siz/2)" > $@
|
||||
else
|
||||
siz=$$(wc -c $< | sed -e 's/$<//'); \
|
||||
perl -e "print pack(\"c\",$$siz)" > $@
|
||||
endif
|
||||
|
||||
# For each entry in the table whose face < 32, there needs to be a pair of
|
||||
# pbitm files and a string giving the printing form
|
||||
frankspecials.bin: ../frank_mkspecials.pl $(BMPFILES)
|
||||
$< $(BLANK_INFO) $(LANG_SPECIAL_INFO) > $@
|
||||
|
||||
$(LANG)%.$(FRANK_EXT): dawg$(LANG)%.stamp $(LANG)%_flags.bin charcount.bin table.bin values.bin frankspecials.bin
|
||||
cat $(LANG)$*_flags.bin charcount.bin table.bin values.bin \
|
||||
frankspecials.bin $(LANG)StartLoc.bin $$(ls dawg$(LANG)$*_*.bin) > $@
|
||||
cp $@ saveme.bin
|
||||
|
||||
$(LANG)%.seb: $(LANG)%.$(FRANK_EXT) $(LANG)%.atts
|
||||
${ESDK_CREATESEB_EXE} $<
|
||||
cp $< $<.saved
|
||||
|
||||
$(LANG)%.atts: #recreate it each time based on params
|
||||
echo '_PUB|global+read-only|"Eric_House"' >> $@
|
||||
echo "_NAME|global+read-only|\"$(LANG)2to8\"" >> $@
|
||||
echo "_EXT|global+read-only|\"$(FRANK_EXT)\"" >> $@
|
||||
echo '_LCAT|nosign+global|"CONTENT"' >> $@
|
||||
echo '_PERM|global+read-only|"r"' >> $@
|
||||
|
||||
# values.bin: ../xloc
|
||||
# cd ../ && $(MAKE) xloc
|
||||
# ../xloc -l $(LANGCODE) -T $@
|
||||
|
||||
# the files to export for byod
|
||||
byodbins: table.bin values.bin frankspecials.bin
|
||||
|
||||
|
||||
else
|
||||
(Need to define TARGET_TYPE if get error poining to this line)
|
||||
endif #ifeq ($(TARGET_TYPE),FRANK)
|
||||
endif
|
||||
|
||||
ifeq (s$(TARGET_TYPE),s)
|
||||
It's an error not to specify a TARGET_TYPE
|
||||
endif
|
||||
|
||||
##############################################################################
|
||||
# shared rules
|
||||
##############################################################################
|
||||
|
||||
# For some reason I can't fathom dawg$(LANG)% gets nuked every time
|
||||
# the top-level rule fires (all: for whatever TARGET_TYPE.) It
|
||||
# happens after the rule finishes....
|
||||
|
||||
# 16 bits worth of flags for the start of the eventual file. At this
|
||||
# point, the flags mean this:
|
||||
# 1: old-style DAWG.
|
||||
# 2: new-style DAWG, three bytes per node.
|
||||
# 3: new-style DAWG, four bytes per node
|
||||
$(LANG)%_flags.bin: dawg$(LANG)%.stamp
|
||||
ifdef NEWDAWG
|
||||
if [ 3 == $$(cat $(LANG)$*_nodesize.bin) ] ; \
|
||||
then perl -e "print pack(\"n\",0x0002)" > $@; echo "flags=2"; \
|
||||
else perl -e "print pack(\"n\",0x0003)" > $@; echo "flags=3"; \
|
||||
fi
|
||||
else
|
||||
if [ 3 == $$(cat $(LANG)$*_nodesize.bin) ] ; \
|
||||
then perl -e "print pack(\"n\",0x0001)" > $@; echo "flags=1"; \
|
||||
else echo "ERROR: old format can't handle 4-byte"; exit 1; \
|
||||
fi
|
||||
endif
|
||||
|
||||
dawg$(LANG)%.stamp: $(LANG)Main.dict.gz ../dict2dawg.pl table.bin ../Makefile.langcommon
|
||||
start=$$(echo $@ | sed -e 's/dawg$(LANG)\([0-9]*\)to[0-9]*.stamp/\1/'); \
|
||||
end=$$(echo $@ | sed -e 's/dawg$(LANG)[0-9]*to\([0-9]*\).stamp/\1/'); \
|
||||
echo $${start} and $$end; \
|
||||
zcat $< | grep "^.\{$${start},$${end}\}$$" | tr '\n' '\0'| \
|
||||
sort -z | ../dict2dawg.pl $(TABLE_ARG) table.bin -b 28000 \
|
||||
-ob dawg$(LANG)$* \
|
||||
-sn $(LANG)StartLoc.bin -k -term 0 -wc $(LANG)$*_wordcount.bin \
|
||||
$(FORCE_4) -ns $(LANG)$*_nodesize.bin
|
||||
touch $@
|
||||
|
||||
$(LANG)%_wordcount.bin: dawg$(LANG)%.stamp
|
||||
@echo
|
||||
|
||||
# the files to export for byod
|
||||
allbins:
|
||||
$(MAKE) TARGET_TYPE=PALM byodbins
|
||||
$(MAKE) TARGET_TYPE=FRANK byodbins
|
||||
|
||||
table.bin: ../xloc.pl
|
||||
ifdef NEWDAWG
|
||||
perl -I../ ../xloc.pl -tn > $@
|
||||
else
|
||||
perl -I../ ../xloc.pl -t > $@
|
||||
endif
|
||||
|
||||
values.bin: ../xloc.pl
|
||||
perl -I../ ../xloc.pl -v > $@
|
||||
|
||||
%.dict: %.dict.gz
|
||||
zcat $< > $@
|
||||
|
||||
clean_common:
|
||||
rm -f $(LANG)Main.dict *.bin *.pdb *.seb dawg*.stamp *.$(FRANK_EXT) \
|
||||
$(LANG)*.pdb $(LANG)*.seb
|
||||
|
||||
help:
|
||||
@echo "make TARGET_TYPE=[FRANK|PALM]"
|
||||
|
||||
test:
|
||||
@echo $(LANGUAGE)
|
||||
7
xwords4/xwords4/dawg/allchars.pl
Executable file
7
xwords4/xwords4/dawg/allchars.pl
Executable file
|
|
@ -0,0 +1,7 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
use strict;
|
||||
|
||||
for (my $i = 1; $i < 255; ++$i ) {
|
||||
printf( "%d: %s (0x%x)\n", $i, chr($i), $i );
|
||||
}
|
||||
47
xwords4/xwords4/dawg/dawg.h
Normal file
47
xwords4/xwords4/dawg/dawg.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*
|
||||
* Copyright 1998 by Eric House. All rights reserved.
|
||||
* fixin@peak.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
typedef struct dawg_header {
|
||||
unsigned long numWords;
|
||||
unsigned char firstEdgeRecNum;
|
||||
unsigned char charTableRecNum;
|
||||
unsigned char valTableRecNum;
|
||||
unsigned char reserved[3]; // worst case this points to a new resource
|
||||
} dawg_header;
|
||||
|
||||
typedef struct array_edge {
|
||||
unsigned char highByte;
|
||||
unsigned char lowByte;
|
||||
unsigned char bits;
|
||||
} array_edge;
|
||||
|
||||
/*
|
||||
* the bits field has five bits for the character (0-based rather than
|
||||
* 'a'-based, of course; one bit each indicating whether the edge may
|
||||
* be terminal and whether it's the last edge of a sub-array; and a final
|
||||
* bit that's overflow from the highByte field allowing indices to be in
|
||||
* the range 0-(2^^17)-1
|
||||
*/
|
||||
#define LETTERMASK 0x1f
|
||||
#define ACCEPTINGMASK 0x20
|
||||
#define LASTEDGEMASK 0x40
|
||||
#define LASTBITMASK 0x80
|
||||
|
||||
//#define ushort_byte_swap(d) ((unsigned short)(d<<8 | d>>8))
|
||||
|
||||
685
xwords4/xwords4/dawg/dict2DAWG.c
Normal file
685
xwords4/xwords4/dawg/dict2DAWG.c
Normal file
|
|
@ -0,0 +1,685 @@
|
|||
// -*-mode: C; fill-column: 80; compile-command: "make dict2pdb"; -*-
|
||||
/*
|
||||
* Copyright 1997 by Eric House. All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
Converts a <CR>-separated list of words, in stdin, to a DAWG written
|
||||
to stdout in PalmOS .pdb file format.
|
||||
|
||||
Called like this: dict2dawg > dict.pdb <<.
|
||||
car
|
||||
cars
|
||||
cat
|
||||
does
|
||||
dog
|
||||
.
|
||||
|
||||
Records in the database are of 48K length by default, except that
|
||||
the last will likely be smaller and that they always end with the end
|
||||
of a sub-array (so that iteration over a subarray doesn't have to
|
||||
worry about boundaries.)
|
||||
|
||||
Records ought to hold two parallel arrays (but don't yet): first the
|
||||
index array, of shorts, and then the bits array of unsigned chars.
|
||||
Remember that one bit of the bits entry is actually the 17th bit of
|
||||
the index value...
|
||||
|
||||
Ultimately we want to associate xloc-like date with each dictionary so
|
||||
that langauges whose relevant letters aren't all in an ascii sequence can
|
||||
be accomodated. In most cases we'll be passed in a file containing a table
|
||||
to be used for the mapping -- just a text file with one character per line
|
||||
where A might be the 0th line, umlaut-A the first, etc. But we'll also
|
||||
generate such a table ourselves when not given one, and output it when
|
||||
asked.
|
||||
|
||||
Bugs: It's currently necessary that input to this program be sorted
|
||||
or some data may be lost.
|
||||
|
||||
To do:
|
||||
Make it two parallel arrays.
|
||||
Some sort of hashing on pruning. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#include "swap.h"
|
||||
|
||||
#define PRE_EDGE_RECORDCOUNT 3
|
||||
|
||||
/* #include "pdb.h" */
|
||||
#include "dawg.h"
|
||||
/* #include "swap.c" */
|
||||
|
||||
typedef char boolean;
|
||||
#define true 1
|
||||
#define false 0
|
||||
|
||||
typedef unsigned char Tile;
|
||||
|
||||
typedef struct tree_edge {
|
||||
unsigned char letter;
|
||||
unsigned long index;
|
||||
boolean terminal;
|
||||
struct tree_edge* prev;
|
||||
struct tree_edge* next;
|
||||
struct tree_edge* children;
|
||||
} tree_edge;
|
||||
|
||||
#define MAXLENGTH 15
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// prototypes
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
static void addToTree( unsigned char* buf, short buflen, tree_edge* nodege );
|
||||
tree_edge* newNode( unsigned char letter, boolean terminal );
|
||||
static void remember( unsigned char* c );
|
||||
void readInTables( char* orderTableFile );
|
||||
void init_prune_data();
|
||||
void prune_tree( tree_edge* edge );
|
||||
/* unsigned short byte_swap( unsigned short d ); */
|
||||
void write_children( array_edge* mainArray, tree_edge* edge );
|
||||
int count_nodes( tree_edge* edge );
|
||||
unsigned long index_children( tree_edge* edge, unsigned long firstIndex );
|
||||
void write_as_pdb( array_edge* edges, unsigned long edgeCount );
|
||||
void usage( char* progName );
|
||||
void initTables( void );
|
||||
Tile CharToTile( unsigned char ch );
|
||||
static short fileSize( char* fileName );
|
||||
void write_as_files( array_edge* edges, unsigned long edgeCount,
|
||||
char* fileNameBase );
|
||||
|
||||
unsigned long gWordCount = 0;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// globals
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
boolean verbose = 0;
|
||||
tree_edge* rootEdge;
|
||||
int gNodeCount = 0;
|
||||
long gNodesCreated;
|
||||
long gPulled;
|
||||
char gDictName[32];
|
||||
char* gOrderTableFileName = NULL;
|
||||
/* char* gValueTableFileName = NULL; */
|
||||
short gNumUniqueTiles;
|
||||
typedef struct OrderResEntry {
|
||||
/* unsigned char count; */
|
||||
/* unsigned char value; */
|
||||
unsigned char ch;
|
||||
} OrderResEntry;
|
||||
static OrderResEntry gOrderTable[32];
|
||||
static signed short gLookupTable[256];
|
||||
|
||||
dawg_header gDawgHeader;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// main
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
int main( int argc, char** argv ) {
|
||||
char buf[MAXLENGTH+10];
|
||||
unsigned long edgeCount;
|
||||
long maxWordLen = MAXLENGTH;
|
||||
int got;
|
||||
char* baseName = NULL;
|
||||
array_edge* mainArray = NULL;
|
||||
|
||||
initTables();
|
||||
memset( &gDawgHeader, 0, sizeof(gDawgHeader) );
|
||||
|
||||
gDictName[0] = '\0';
|
||||
|
||||
while ( (got = getopt(argc, argv, "t:vhn:")) != EOF ) {
|
||||
switch ( got ) {
|
||||
case 'm':
|
||||
sscanf( optarg, "%ld", &maxWordLen );
|
||||
fprintf( stderr, "maxWordLen set to %ld\n", maxWordLen );
|
||||
break;
|
||||
case 'n':
|
||||
baseName = optarg;
|
||||
break;
|
||||
case 'v':
|
||||
verbose = true;
|
||||
fprintf( stderr, "verbose set\n" );
|
||||
break;
|
||||
case 't':
|
||||
gOrderTableFileName = optarg;
|
||||
break;
|
||||
case 'h':
|
||||
default:
|
||||
usage( argv[0] );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( gOrderTableFileName != NULL ) {
|
||||
readInTables( gOrderTableFileName );
|
||||
}
|
||||
|
||||
assert( baseName );
|
||||
|
||||
rootEdge = newNode( '\0', 0 );
|
||||
gNodesCreated = 0;
|
||||
gPulled = 0;
|
||||
|
||||
while ( fgets( buf, MAXLENGTH+9, stdin ) ) {
|
||||
unsigned char* cr = (unsigned char*)strchr( buf, '\n' );
|
||||
short wordlen;
|
||||
if ( cr ) {
|
||||
*cr = '\0';
|
||||
}
|
||||
|
||||
wordlen = strlen( buf );
|
||||
|
||||
if ( (maxWordLen != MAXLENGTH) && (wordlen > maxWordLen) ) {
|
||||
continue;
|
||||
} else if ( wordlen > MAXLENGTH ) {
|
||||
fprintf( stderr, "word %s too long\n", buf );
|
||||
exit(1);
|
||||
}
|
||||
|
||||
// remember that *cr may be 0 *after* the call to remember
|
||||
for ( cr = buf; *cr; ++cr ) {
|
||||
remember(cr);
|
||||
}
|
||||
|
||||
addToTree( buf, wordlen, rootEdge );
|
||||
++gWordCount;
|
||||
}
|
||||
|
||||
fprintf( stderr, "done with addToTree (%ld nodes; %ld words)\n",
|
||||
gNodesCreated, gWordCount );
|
||||
|
||||
init_prune_data();
|
||||
prune_tree( rootEdge );
|
||||
|
||||
fprintf( stderr, "done with prune_tree: %ld pulled\n", gPulled );
|
||||
|
||||
edgeCount = index_children( rootEdge, 0 );
|
||||
|
||||
if ( edgeCount >= 0x1FFFF ) {
|
||||
fprintf( stderr, "ERROR: too many edges: %ld (max is %ld)\n",
|
||||
edgeCount, (long)0x1FFFF );
|
||||
exit( 1 );
|
||||
}
|
||||
|
||||
fprintf( stderr, "done with index_children; edgeCount = %ld\n", edgeCount);
|
||||
mainArray = (array_edge*)malloc( edgeCount * sizeof(array_edge) );
|
||||
assert( mainArray );
|
||||
|
||||
/* largestDiff = smallestDiff = 0; */
|
||||
write_children( mainArray, rootEdge );
|
||||
fprintf( stderr, "done with write_children\n" );
|
||||
/* fprintf( stderr, "largestDiff = %ld, smallestDiff = %ld\n", */
|
||||
/* largestDiff, smallestDiff ); */
|
||||
|
||||
// Now we have a huge array in memory and need to write it to pdb
|
||||
// format.
|
||||
write_as_files( mainArray, edgeCount, baseName );
|
||||
|
||||
/* if ( verbose ) { */
|
||||
/* fprintf( stderr, "Writing %d nodes\n", edgeCount ); */
|
||||
/* fprintf( stderr, "{letter, next_index, terminal, lastEdge}\n" ); */
|
||||
/* for ( i = 0; i < edgeCount; ++i ) { */
|
||||
/* array_edge* edge = &gArray[i]; */
|
||||
// fprintf( stderr, "/*[%d]*/ {%c, %d, %s, %s}\n", */
|
||||
/* i, */
|
||||
/* (edge->bits & LETTERMASK) + 'a', */
|
||||
/* ushort_byte_swap(edge->first_child), */
|
||||
/* (edge->bits&TERMINALMASK)?"true":"false", */
|
||||
/* (edge->bits&LASTEDGEMASK)?"true":"false" ); */
|
||||
/* } */
|
||||
/* } */
|
||||
|
||||
/* fprintf( stderr, "writing %ld edges to file\n", edgeCount ); */
|
||||
/* for ( i = 0; i < edgeCount; ++i ) { */
|
||||
/* fwrite( &gArray[i], sizeof(array_edge), 1, stdout ); */
|
||||
/* } */
|
||||
|
||||
return 0;
|
||||
} // main
|
||||
|
||||
/* Given a node on the tree (not yet converted to a directed graph)
|
||||
* walk down it using letters where they exist and adding them where
|
||||
* the don't.
|
||||
*
|
||||
* The structure we're building here looks like this, for input "CAT"
|
||||
* and "CAR":
|
||||
* /T
|
||||
* *-C-A
|
||||
* \R
|
||||
* That is, words beginning with the same letters share the same initial
|
||||
* branches of the tree. Thus on entering a given level of recursion
|
||||
* there are these possibilities:
|
||||
* a) There's nothing here: create a new node and recurse on it.
|
||||
* b) We find a node that holds the letter we seek: recurse on it.
|
||||
* c) We reach the end of the list of letters without finding what we
|
||||
* seek: create a new node at the end and recurse on it.
|
||||
* d) We reach a node before which ours should have been found: create a
|
||||
* new node in the right place and recurse on it.
|
||||
*/
|
||||
static void addToTree( unsigned char* buf, short buflen, tree_edge* node ) {
|
||||
unsigned char target = *buf;
|
||||
boolean terminal = (buflen == 1);
|
||||
tree_edge* child;
|
||||
tree_edge* prev = NULL;
|
||||
tree_edge* new_node;
|
||||
|
||||
/* if ( !target ) { */
|
||||
/* assert( buflen == 0 ); */
|
||||
/* return; */
|
||||
/* } */
|
||||
if ( buflen == 0 ) return;
|
||||
assert( buflen > 0 );
|
||||
|
||||
if ( node->children == NULL ) {
|
||||
addToTree( buf+1, buflen-1,
|
||||
node->children = newNode( target, terminal ) );
|
||||
return;
|
||||
}
|
||||
|
||||
for ( child = node->children; child != NULL; child = child->next ) {
|
||||
if ( child->letter == target ) {
|
||||
addToTree( buf+1, buflen-1, child );
|
||||
return;
|
||||
} else if ( child->letter > target ) { // it's not in the tree yet.
|
||||
new_node = newNode( target, terminal );
|
||||
new_node->next = child;
|
||||
new_node->prev = child->prev;
|
||||
if ( child->prev ) {
|
||||
child->prev->next = new_node;
|
||||
} else { // it's the first node!
|
||||
node->children = new_node;
|
||||
}
|
||||
child->prev = new_node;
|
||||
|
||||
addToTree( buf+1, buflen-1, new_node );
|
||||
return;
|
||||
}
|
||||
prev = child;
|
||||
}
|
||||
|
||||
assert( prev != NULL );
|
||||
new_node = newNode( target, terminal );
|
||||
prev->next = new_node;
|
||||
new_node->prev = prev;
|
||||
addToTree( buf+1, buflen-1, new_node );
|
||||
return;
|
||||
}
|
||||
|
||||
tree_edge* newNode( unsigned char letter, boolean terminal ) {
|
||||
tree_edge* result = (tree_edge*)malloc( sizeof(tree_edge ));
|
||||
assert( result );
|
||||
++gNodesCreated;
|
||||
result->letter = letter;
|
||||
result->index = 0xFFFF;
|
||||
result->terminal = terminal;
|
||||
result->children = result->next = result->prev = NULL;
|
||||
|
||||
++gNodeCount;
|
||||
return result;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// prune_tree (and helpers)
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
boolean sameStructure( tree_edge* node1, tree_edge* node2 ) {
|
||||
// simple cases first.
|
||||
if ( node1 == node2 ) return true;
|
||||
else if ( node1 == NULL || node2 == NULL ) return false;
|
||||
else if ( node1->letter != node2->letter ) return false;
|
||||
else if ( node1->terminal != node2->terminal ) return false;
|
||||
//else if ( count_nodes( node1 ) != count_nodes( node2 ) ) return false;
|
||||
else {
|
||||
tree_edge* children1;
|
||||
tree_edge* children2;
|
||||
for ( children1 = node1->children, children2 = node2->children;
|
||||
children1 || children2;
|
||||
children1 = children1->next, children2 = children2->next ) {
|
||||
if ( !sameStructure( children1, children2 ) )
|
||||
return false;
|
||||
}
|
||||
for ( children1 = node1->next, children2 = node2->next;
|
||||
children1 || children2;
|
||||
children1 = children1->next, children2 = children2->next ) {
|
||||
if ( !sameStructure( children1, children2 ) )
|
||||
return false;
|
||||
}
|
||||
return (children1 == NULL) && (children2 == NULL);
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct visited_edge {
|
||||
tree_edge* theEdge;
|
||||
struct visited_edge* next;
|
||||
} visited_edge;
|
||||
static visited_edge* visitedEdges[256];
|
||||
|
||||
void init_prune_data() {
|
||||
short i;
|
||||
for ( i = 0; i < 26; ++i ) {
|
||||
visitedEdges[i] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
tree_edge* visited( tree_edge* node ) {
|
||||
short hash = node->letter;// - 'a';
|
||||
//assert( hash >=0 && hash < 26 );
|
||||
if ( visitedEdges[hash] == NULL ) {
|
||||
visitedEdges[hash] = (visited_edge*)malloc(sizeof(visited_edge));
|
||||
assert( visitedEdges[hash] );
|
||||
visitedEdges[hash]->theEdge = node;
|
||||
visitedEdges[hash]->next = NULL;
|
||||
return node;
|
||||
} else {
|
||||
visited_edge* visited;
|
||||
for ( visited = visitedEdges[hash]; visited;
|
||||
visited = visited->next ) {
|
||||
if ( verbose ) {
|
||||
fprintf( stderr, "looking at %c and %c\n",
|
||||
node->letter, visited->theEdge->letter );
|
||||
}
|
||||
if ( sameStructure( node, visited->theEdge ) ) {
|
||||
if ( verbose ) {
|
||||
fprintf( stderr, "pruning tree beginning with %c\n",
|
||||
node->letter );
|
||||
}
|
||||
return visited->theEdge;
|
||||
}
|
||||
}
|
||||
// didn't find it. Insert new entry at head of list.
|
||||
visited = (visited_edge*)malloc(sizeof(visited_edge));
|
||||
assert( visited );
|
||||
visited->theEdge = node;
|
||||
visited->next = visitedEdges[hash];
|
||||
visitedEdges[hash] = visited;
|
||||
return node;
|
||||
}
|
||||
} // visited
|
||||
|
||||
int count_nodes( tree_edge* edge ) {
|
||||
short result = 0;
|
||||
while ( edge ) {
|
||||
result += count_nodes( edge->children );
|
||||
++result;
|
||||
edge = edge->next;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Walk the tree. Starting at the lowest points, lookup each node to see
|
||||
* if an equivalent one has already been visited. If so, replace it with
|
||||
* (a ptr to) the first one seen.
|
||||
*/
|
||||
void prune_tree( tree_edge* edge ) {
|
||||
tree_edge* child = edge->children;
|
||||
tree_edge* tmp;
|
||||
|
||||
// fprintf( stderr, "prune_tree called\n" );
|
||||
|
||||
if ( !child ) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* if( edge->letter == 'c' ) { */
|
||||
/* fprintf( stderr, "C\n" ); */
|
||||
/* } */
|
||||
|
||||
while ( child ) {
|
||||
prune_tree( child );
|
||||
child = child->next;
|
||||
}
|
||||
|
||||
tmp = visited( edge->children );
|
||||
if ( tmp != edge->children ) {
|
||||
short pulled = count_nodes(edge->children);
|
||||
/* fprintf( stderr, "Removing %d nodes\n", pulled ); */
|
||||
gPulled += pulled;
|
||||
edge->children = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// write_edge (and helpers)
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
unsigned long index_children( tree_edge* edge, unsigned long firstIndex ) {
|
||||
tree_edge* child;
|
||||
for ( child = edge->children; child; child = child->next ) {
|
||||
if ( child->index == 0xFFFF ) {
|
||||
child->index = firstIndex++;
|
||||
/* assert( firstIndex != 0xFFFF ); */
|
||||
/* fprintf( stderr, "set index of %c (%x) to %d\n", child->letter, */
|
||||
/* child, child->index ); */
|
||||
}
|
||||
}
|
||||
|
||||
for ( child = edge->children; child; child = child->next ) {
|
||||
firstIndex = index_children( child, firstIndex );
|
||||
}
|
||||
return firstIndex;
|
||||
}
|
||||
|
||||
void write_child( array_edge* mainArray, tree_edge* child ) {
|
||||
if ( child ) {
|
||||
array_edge* entry = &mainArray[child->index];
|
||||
unsigned char bits = 0;
|
||||
unsigned long childIndex
|
||||
= (child->children!=NULL)? child->children->index : 0;
|
||||
assert( childIndex <= 0x0001FFFF );
|
||||
|
||||
entry->lowByte = childIndex & 0x000000FF;
|
||||
entry->highByte = (childIndex>>8) & 0x000000FF;
|
||||
|
||||
bits = CharToTile(child->letter) & LETTERMASK;
|
||||
|
||||
if ( childIndex & 0x00010000 ) {
|
||||
bits |= LASTBITMASK;
|
||||
}
|
||||
if ( child->terminal ) {
|
||||
bits |= ACCEPTINGMASK;
|
||||
}
|
||||
if ( child->next == NULL ) {
|
||||
bits |= LASTEDGEMASK;
|
||||
}
|
||||
entry->bits = bits;
|
||||
}
|
||||
}
|
||||
|
||||
void write_children( array_edge* mainArray, tree_edge* edge ) {
|
||||
tree_edge* child;
|
||||
for ( child = edge->children; child; child = child->next ) {
|
||||
write_child( mainArray, child );
|
||||
write_children( mainArray, child );
|
||||
|
||||
// gather some stats
|
||||
/* if ( child->index != 0 ) { */
|
||||
/* diff = edge->index - child->index; */
|
||||
/* if ( diff > largestDiff ) { */
|
||||
/* largestDiff = diff; */
|
||||
/* } */
|
||||
/* if ( diff < smallestDiff ) { */
|
||||
/* smallestDiff = diff; */
|
||||
/* } */
|
||||
/* } */
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// write_as_pdb and helpers
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void write_pdb_record_data( array_edge* edges, unsigned long startCount,
|
||||
unsigned long count ) {
|
||||
unsigned long i;
|
||||
for ( i = startCount; i < startCount + count; ++i ) {
|
||||
fwrite( &edges[i], sizeof(array_edge), 1, stdout );
|
||||
}
|
||||
}
|
||||
|
||||
// I *think* that the upper bound on this is 0xFFFF/edgesize minus enough that
|
||||
// I can add edges out to the end of the subarray in which the line falls
|
||||
// can be accomodated -- which I guess is about 32-1-1 (minus one because
|
||||
// blanks take up one of the 32 slots though they don't appear in DAWGs,
|
||||
// and minus another because the boundary must appear after at least the
|
||||
// first or we just leave it there.)
|
||||
|
||||
#define EDGES_PER_RECORD 0x3FFF
|
||||
#ifndef EDGES_PER_RECORD
|
||||
# define EDGES_PER_RECORD 0x00005528
|
||||
#endif
|
||||
|
||||
/* Write as binary files segmented appropriately in case the target is PalmOS or
|
||||
* other platform with restricted-length databases.
|
||||
*/
|
||||
void write_as_files( array_edge* edges, unsigned long edgeCount,
|
||||
char* fileNameBase ) {
|
||||
unsigned long firstUnhousedEdge = 0;
|
||||
short numEdgesThisFile;
|
||||
boolean exitNext = false;
|
||||
/* unsigned long prevEdgeCount; */
|
||||
/* unsigned long curOffset = 0; */
|
||||
short fileNum;
|
||||
|
||||
for ( fileNum = 0; !exitNext; ++fileNum ) {
|
||||
unsigned long lastEdge;
|
||||
char buf[40];
|
||||
FILE* dawgOutF;
|
||||
unsigned long firstEdgeThisFile = 0;
|
||||
|
||||
/* from the first edge not yet in a record, go forward EDGES_PER_RECORD
|
||||
edges, and than march forward further until the current subarray is
|
||||
finished. */
|
||||
lastEdge = firstUnhousedEdge + EDGES_PER_RECORD - 1;
|
||||
if ( lastEdge + 1 >= edgeCount ) {
|
||||
lastEdge = edgeCount - 1;
|
||||
assert( (edges[lastEdge].bits & LASTEDGEMASK) );
|
||||
exitNext = true;
|
||||
}
|
||||
while ( (edges[lastEdge].bits & LASTEDGEMASK) == 0 ) {
|
||||
++lastEdge;
|
||||
}
|
||||
|
||||
numEdgesThisFile = lastEdge - firstUnhousedEdge + 1;
|
||||
|
||||
sprintf( buf, "%s_%d.bin", fileNameBase, fileNum );
|
||||
dawgOutF = fopen( buf, "wb" );
|
||||
fwrite( &edges[firstUnhousedEdge], sizeof(array_edge),
|
||||
numEdgesThisFile, dawgOutF );
|
||||
fclose( dawgOutF );
|
||||
|
||||
fprintf( stderr, "wrote edges from %ld to %ld to file %s\n",
|
||||
firstUnhousedEdge, firstUnhousedEdge+numEdgesThisFile, buf );
|
||||
|
||||
firstUnhousedEdge = lastEdge + 1;
|
||||
}
|
||||
|
||||
fprintf( stderr, "%ld edges yielded %d records of up to %ld edges each\n",
|
||||
edgeCount, fileNum, (long)EDGES_PER_RECORD );
|
||||
|
||||
} // write_as_files
|
||||
|
||||
/******************************************************************************
|
||||
* Read in a file of letters, one per line, whose position in the file will
|
||||
* determine the translation from char to Tile when the dawg is written out.
|
||||
* If no such file is passed in, we'll create our own based on the ascii order
|
||||
* of those chars we see in processing the dictionary. If one is passed in,
|
||||
* we'll use it, but we'll fail if we encounter a letter not on the list.
|
||||
*
|
||||
* Also, for faster lookup of Tile values we maintain a second table mapping
|
||||
* chars to tiles. 'A' might map to 1, A-umlaut to 2, etc., if 0 is the blank
|
||||
* char
|
||||
*****************************************************************************/
|
||||
void initTables() {
|
||||
memset( gOrderTable, 0, 32*sizeof(*gOrderTable) );
|
||||
memset( gLookupTable, -1, 256*sizeof(*gLookupTable) );
|
||||
} // initTables
|
||||
|
||||
void readInTables( char* orderTableFile ) {
|
||||
unsigned char ch = 0;
|
||||
FILE* f = fopen( orderTableFile, "rb" );
|
||||
assert( f );
|
||||
|
||||
gNumUniqueTiles = 0;
|
||||
while ( fscanf( f, "%c\n", &ch ) != EOF ) {
|
||||
assert( gNumUniqueTiles <= 32 );
|
||||
assert( ch < 255 );
|
||||
assert( gOrderTable[gNumUniqueTiles].ch == 0 );
|
||||
gOrderTable[gNumUniqueTiles].ch = ch;
|
||||
gLookupTable[ch] = gNumUniqueTiles;
|
||||
++gNumUniqueTiles;
|
||||
}
|
||||
fclose( f );
|
||||
|
||||
} // readInTables
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
static void remember( unsigned char* c ) {
|
||||
signed short tile = gLookupTable[*c];
|
||||
assert( gOrderTableFileName != NULL );
|
||||
if ( tile == -1 ) {
|
||||
fprintf( stderr, "ERROR: unexpected character '%c' (0x%x)\n",
|
||||
*c, (short)*c );
|
||||
exit(1);
|
||||
}
|
||||
assert( tile < 32 );
|
||||
*c = tile;
|
||||
} // remember
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
Tile CharToTile( unsigned char ch ) {
|
||||
return ch;
|
||||
/* assert( gLookupTable[ch] < 32 ); */
|
||||
/* return (Tile)gLookupTable[ch]; */
|
||||
} // CharToTile
|
||||
|
||||
static short fileSize( char* fileName ) {
|
||||
short result;
|
||||
FILE* f = fopen( fileName, "rb" );
|
||||
assert( f );
|
||||
if ( fseek( f, 0L, SEEK_END ) != 0 ) {
|
||||
fprintf( stderr, "error from fseek\n" );
|
||||
exit(1);
|
||||
}
|
||||
result = ftell( f );
|
||||
fclose( f );
|
||||
return (short)result;
|
||||
} // fileSize
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// usage
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
void usage( char* progName ) {
|
||||
fprintf( stderr,
|
||||
"USAGE: %s\n"
|
||||
" [-m<maxLength>]\n"
|
||||
" [-v] (verbose) \n"
|
||||
/* " [-t char-order-table-file] \n" */
|
||||
/* " [-n <pdbName>] \n" */
|
||||
" <word_list >dawg_file\n",
|
||||
progName );
|
||||
exit( 1 );
|
||||
}
|
||||
|
||||
798
xwords4/xwords4/dawg/dict2dawg.pl
Executable file
798
xwords4/xwords4/dawg/dict2dawg.pl
Executable file
|
|
@ -0,0 +1,798 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
##############################################################################
|
||||
# adapted from C++ code Copyright (C) 2000 Falk Hueffner
|
||||
# This version Copyright (C) 2002 Eric House (fixin@peak.org)
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful, but
|
||||
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
||||
# USA
|
||||
##############################################################################
|
||||
|
||||
# inputs: 0. Name of file mapping letters to 0..31 values. In English
|
||||
# case just contains A..Z. This will be used to translate the tries
|
||||
# on output.
|
||||
# 1. Max number of bytes per binary output file.
|
||||
#
|
||||
# 2. Basename of binary files for output.
|
||||
|
||||
# 3. Name of file to which to write the number of the
|
||||
# startNode, since I'm not rewriting a bunch of code to expect Falk's
|
||||
# '*' node at the start.
|
||||
#
|
||||
|
||||
# In STDIN, the text file to be compressed. It absolutely
|
||||
# must be sorted. The sort doesn't have to follow the order in the
|
||||
# map file, however.
|
||||
|
||||
# This is meant eventually to be runnable as part of a cgi system for
|
||||
# letting users generating Crosswords dicts online.
|
||||
|
||||
|
||||
|
||||
use strict;
|
||||
use POSIX;
|
||||
|
||||
my $gFirstDiff;
|
||||
my @gCurrentWord;
|
||||
my $gCurrentWord; # save so can check for sortedness
|
||||
my $gDone = 0;
|
||||
my @gInputStrings;
|
||||
my $gNeedsSort = 1; # read from cmd line eventually
|
||||
my @gNodes; # final array of nodes
|
||||
my $gNBytesPerOutfile = 0xFFFFFFFF;
|
||||
my $gTableFile;
|
||||
my $gOutFileBase;
|
||||
my $gStartNodeOut;
|
||||
my $gInFileName;
|
||||
my $gKillIfMissing = 1;
|
||||
my $gTermChar = '/n';
|
||||
my $gDumpText = 0; # dump the dict as text after?
|
||||
my $gCountFile;
|
||||
my $gBytesPerNodeFile; # where to write whether node size 3 or 4
|
||||
my $gWordCount = 0;
|
||||
my %gTableHash;
|
||||
my @gRevMap;
|
||||
my $debug = 0;
|
||||
my %gSubsHash;
|
||||
my $gForceFour = 0; # use four bytes regardless of need?
|
||||
my $gNBytesPerNode;
|
||||
my $gUseUnicode;
|
||||
|
||||
main();
|
||||
|
||||
exit;
|
||||
|
||||
##############################################################################
|
||||
|
||||
sub main() {
|
||||
|
||||
if ( !parseARGV() ) {
|
||||
usage();
|
||||
exit();
|
||||
}
|
||||
|
||||
makeTableHash();
|
||||
|
||||
my $infile;
|
||||
|
||||
if ( $gInFileName ) {
|
||||
open $infile, "<$gInFileName";
|
||||
} else {
|
||||
$infile = \*STDIN;
|
||||
}
|
||||
|
||||
@gInputStrings = parseAndSort( $infile );
|
||||
if ( $gInFileName ) {
|
||||
close $infile;
|
||||
}
|
||||
|
||||
# Do I need this stupid thing? Better to move the first row to
|
||||
# the front of the array and patch everything else. Or fix the
|
||||
# non-palm dictionary format to include the offset of the first
|
||||
# node.
|
||||
|
||||
my $dummyNode = 0xFFFFFFFF;
|
||||
@gNodes = ( $dummyNode );
|
||||
|
||||
readNextWord();
|
||||
|
||||
my $firstRootChildOffset = buildNode(0);
|
||||
|
||||
moveTopToFront( \$firstRootChildOffset );
|
||||
|
||||
if ( $gStartNodeOut ) {
|
||||
writeOutStartNode( $gStartNodeOut, $firstRootChildOffset );
|
||||
}
|
||||
|
||||
print STDERR "\n... dumping table ...\n" if $debug;
|
||||
printNodes( \@gNodes, "done with main" ) if $debug;
|
||||
|
||||
# write out the number of nodes if requested
|
||||
if ( $gCountFile ) {
|
||||
open OFILE, "> $gCountFile";
|
||||
print OFILE pack( "N", $gWordCount );
|
||||
close OFILE;
|
||||
print STDERR "wrote out: got $gWordCount words\n";
|
||||
}
|
||||
|
||||
if ( $gOutFileBase ) {
|
||||
emitNodes( $gNBytesPerOutfile, $gOutFileBase );
|
||||
}
|
||||
|
||||
if ( $gDumpText && @gNodes > 0 ) {
|
||||
printOneLevel( $firstRootChildOffset, "" );
|
||||
}
|
||||
|
||||
if ( $gBytesPerNodeFile ) {
|
||||
open OFILE, "> $gBytesPerNodeFile";
|
||||
print OFILE $gNBytesPerNode;
|
||||
close OFILE;
|
||||
}
|
||||
print STDERR "Used $gNBytesPerNode per node.\n";
|
||||
} # main
|
||||
|
||||
# We now have an array of nodes with the last subarray being the
|
||||
# logical top of the tree. Move them to the start, fixing all fco
|
||||
# refs, so that legacy code like Palm can assume top==0.
|
||||
#
|
||||
# Note: It'd probably be a bit faster to integrate this with emitNodes
|
||||
# -- unless I need to have an in-memory list that can be used for
|
||||
# lookups. But that's best for debugging, so keep it this way for now.
|
||||
#
|
||||
# Also Note: the first node is a dummy that can and should be tossed
|
||||
# now.
|
||||
|
||||
sub moveTopToFront($) {
|
||||
my ( $firstRef ) = @_;
|
||||
|
||||
my $firstChild = ${$firstRef};
|
||||
${$firstRef} = 0;
|
||||
my @lastSub;
|
||||
|
||||
if ( $firstChild > 0 ) {
|
||||
# remove the last (the root) subarray
|
||||
@lastSub = splice( @gNodes, $firstChild );
|
||||
} else {
|
||||
die "there should be no words!!" if $gWordCount != 0;
|
||||
}
|
||||
# remove the first (garbage) node
|
||||
shift @gNodes;
|
||||
|
||||
my $diff;
|
||||
if ( $firstChild > 0 ) {
|
||||
# -1 because all move down by 1; see prev line
|
||||
$diff = @lastSub - 1;
|
||||
die "something wrong with len\n" if $diff < 0;
|
||||
} else {
|
||||
$diff = 0;
|
||||
}
|
||||
|
||||
# stick it on the front
|
||||
splice( @gNodes, 0, 0, @lastSub);
|
||||
|
||||
# We add $diff to everything. There's no subtracting because
|
||||
# nobody had any refs to the top list.
|
||||
|
||||
for ( my $i = 0; $i < @gNodes; ++$i ) {
|
||||
my $fco = TrieNodeGetFirstChildOffset( $gNodes[$i] );
|
||||
if ( $fco != 0 ) { # 0 means NONE, not 0th!!
|
||||
TrieNodeSetFirstChildOffset( \$gNodes[$i], $fco+$diff );
|
||||
}
|
||||
}
|
||||
} # moveTopToFront
|
||||
|
||||
|
||||
sub buildNode {
|
||||
my ( $depth ) = @_;
|
||||
|
||||
if ( @gCurrentWord == $depth ) {
|
||||
# End of word reached. If the next word isn't a continuation
|
||||
# of the current one, then we've reached the bottom of the
|
||||
# recursion tree.
|
||||
readNextWord();
|
||||
if ($gFirstDiff < $depth || $gDone) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
my @newedges;
|
||||
|
||||
do {
|
||||
my $letter = $gCurrentWord[$depth];
|
||||
my $isTerminal = @gCurrentWord - 1 == $depth ? 1:0;
|
||||
|
||||
my $nodeOffset = buildNode($depth+1);
|
||||
my $newNode = MakeTrieNode($letter, $isTerminal, $nodeOffset);
|
||||
push( @newedges, $newNode );
|
||||
|
||||
} while ( ($gFirstDiff == $depth) && !$gDone);
|
||||
|
||||
TrieNodeSetIsLastSibling( \@newedges[@newedges-1], 1 );
|
||||
|
||||
return addNodes( \@newedges );
|
||||
} # buildNode
|
||||
|
||||
sub addNodes {
|
||||
my ( $newedgesR ) = @_;
|
||||
|
||||
my $found = findSubArray( $newedgesR );
|
||||
|
||||
if ( $found >= 0 ) {
|
||||
die "0 is an invalid match!!!" if $found == 0;
|
||||
return $found;
|
||||
} else {
|
||||
|
||||
my $firstFreeIndex = @gNodes;
|
||||
|
||||
print STDERR "adding...\n" if $debug;
|
||||
printNodes( $newedgesR ) if $debug;
|
||||
|
||||
push @gNodes, (@{$newedgesR});
|
||||
|
||||
registerSubArray( $newedgesR, $firstFreeIndex );
|
||||
return $firstFreeIndex;
|
||||
}
|
||||
} # addNodes
|
||||
|
||||
sub printNode {
|
||||
my ( $index, $node ) = @_;
|
||||
|
||||
print STDERR "[$index] ";
|
||||
|
||||
printf( STDERR
|
||||
"letter=%d; isTerminal=%d; isLastSib=%d; fco=%d;\n",
|
||||
TrieNodeGetLetter($node),
|
||||
TrieNodeGetIsTerminal($node),
|
||||
TrieNodeGetIsLastSibling($node),
|
||||
TrieNodeGetFirstChildOffset($node));
|
||||
} # printNode
|
||||
|
||||
sub printNodes {
|
||||
my ( $nodesR, $name ) = @_;
|
||||
|
||||
my $len = @{$nodesR};
|
||||
# print "printNodes($name): len = $len\n";
|
||||
|
||||
for ( my $i = 0; $i < $len; ++$i ) {
|
||||
my $node = ${$nodesR}[$i];
|
||||
printNode( $i, $node );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
# Hashing. We'll keep a hash of offsets into the existing nodes
|
||||
# array, and as the key use a string that represents the entire sub
|
||||
# array. Since the key is what we're matching for, there should never
|
||||
# be more than one value per hash and so we don't need buckets.
|
||||
# Return -1 if there's no match.
|
||||
|
||||
sub findSubArray {
|
||||
my ( $newedgesR ) = @_;
|
||||
|
||||
my $key = join('', @{$newedgesR});
|
||||
|
||||
if ( exists( $gSubsHash{$key} ) ) {
|
||||
return $gSubsHash{$key};
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
} # findSubArray
|
||||
|
||||
# add to the hash
|
||||
sub registerSubArray {
|
||||
my ( $edgesR, $nodeLoc ) = @_;
|
||||
|
||||
my $key = join( '', @{$edgesR} );
|
||||
|
||||
if ( exists $gSubsHash{$key} ) {
|
||||
die "entry for key shouldn't exist!!";
|
||||
} else {
|
||||
$gSubsHash{$key} = $nodeLoc;
|
||||
}
|
||||
|
||||
} # registerSubArray
|
||||
|
||||
sub readNextWord() {
|
||||
my @word;
|
||||
|
||||
if ( !$gDone ) {
|
||||
$gDone = @gInputStrings == 0;
|
||||
if ( !$gDone ) {
|
||||
@word = @{shift @gInputStrings};
|
||||
} else {
|
||||
print STDERR "gDone set to true\n" if $debug;
|
||||
}
|
||||
|
||||
print STDERR "got word: ", join(',',@word), "\n" if $debug;
|
||||
}
|
||||
my $numCommonLetters = 0;
|
||||
my $len = @word;
|
||||
if ( @gCurrentWord < $len ) {
|
||||
$len = @gCurrentWord;
|
||||
}
|
||||
|
||||
while ( @gCurrentWord[$numCommonLetters] eq @word[$numCommonLetters]
|
||||
&& $numCommonLetters < $len) {
|
||||
++$numCommonLetters;
|
||||
}
|
||||
|
||||
$gFirstDiff = $numCommonLetters;
|
||||
die "words ", join(",",@gCurrentWord), " and ", join(",", @word), " out of order" if #$debug &&
|
||||
@gCurrentWord > 0 && @word > 0
|
||||
&& !firstBeforeSecond( \@gCurrentWord, \@word );
|
||||
@gCurrentWord = @word;
|
||||
} # readNextWord
|
||||
|
||||
sub firstBeforeSecond {
|
||||
my ( $firstR, $secondR ) = @_;
|
||||
|
||||
for ( my $i = 0; ; ++$i ) {
|
||||
|
||||
# if we reach the end of the first word/list, we're done.
|
||||
if ( $i == @{$firstR} ) {
|
||||
die "duplicate!!!" if $i == @{$secondR};
|
||||
return 1;
|
||||
# but if we reach the second end first, we've failed
|
||||
} elsif ( $i == @{$secondR} ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
my $diff = ${$firstR}[$i] <=> ${$secondR}[$i];
|
||||
|
||||
if ( $diff == 0 ) {
|
||||
next;
|
||||
} else {
|
||||
return $diff < 0;
|
||||
}
|
||||
}
|
||||
} # firstBeforeSecond
|
||||
|
||||
# passed to sort. Should remain unprototyped for effeciency's sake
|
||||
|
||||
sub cmpWords {
|
||||
|
||||
my $lenA = @{$a};
|
||||
my $lenB = @{$b};
|
||||
my $min = $lenA > $lenB? $lenB: $lenA;
|
||||
|
||||
for ( my $i = 0; $i < $min; ++$i ) {
|
||||
my $ac = ${$a}[$i];
|
||||
my $bc = ${$b}[$i];
|
||||
|
||||
my $res = $ac <=> $bc;
|
||||
|
||||
if ( $res != 0 ) {
|
||||
return $res; # we're done
|
||||
}
|
||||
}
|
||||
|
||||
# If we got here, they match up to their common length. Longer is
|
||||
# greater.
|
||||
my $res = @{$a} <=> @{$b};
|
||||
return $res; # which is longer?
|
||||
} # cmpWords
|
||||
|
||||
sub parseAndSort() {
|
||||
my ( $infile ) = @_;
|
||||
|
||||
my @wordlist;
|
||||
my @word;
|
||||
|
||||
WORDLOOP:
|
||||
for ( ; ; ) {
|
||||
|
||||
my $dropWord = 0;
|
||||
splice @word; # empty it
|
||||
|
||||
# for each byte
|
||||
for ( ; ; ) {
|
||||
my $byt = getc($infile);
|
||||
|
||||
if ( $byt eq undef ) {
|
||||
last WORDLOOP;
|
||||
} elsif ( $byt eq $gTermChar ) {
|
||||
if ( !$dropWord ) {
|
||||
push @wordlist, [ @word ];
|
||||
++$gWordCount;
|
||||
}
|
||||
next WORDLOOP;
|
||||
} elsif ( exists( $gTableHash{$byt} ) ) {
|
||||
if ( !$dropWord ) {
|
||||
push @word, $gTableHash{$byt};
|
||||
die "word too long" if @word > 15;
|
||||
}
|
||||
} elsif ($gKillIfMissing) {
|
||||
die "char $byt (", $byt+0, ") not in map file $gTableFile\n";
|
||||
} else {
|
||||
$dropWord = 1;
|
||||
splice @word; # lose anything we already have
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( $gNeedsSort && ($gWordCount > 0) ) {
|
||||
@wordlist = sort cmpWords @wordlist;
|
||||
}
|
||||
|
||||
print STDERR "length of list is ", @wordlist + 0, ".\n" if $debug;
|
||||
|
||||
return @wordlist;
|
||||
} # parseAndSort
|
||||
|
||||
# Print binary representation of trie array. This isn't used yet, but
|
||||
# eventually it'll want to dump to multiple files appropriate for Palm
|
||||
# that can be catenated together on other platforms. There'll need to
|
||||
# be a file giving the offset of the first node too. Also, might want
|
||||
# to move to 4-byte representation when the input can't otherwise be
|
||||
# handled.
|
||||
|
||||
sub dumpNodes {
|
||||
|
||||
for ( my $i = 0; $i < @gNodes; ++$i ) {
|
||||
my $node = $gNodes[$i];
|
||||
my $bstr = pack( "I", $node );
|
||||
print STDOUT $bstr;
|
||||
}
|
||||
}
|
||||
|
||||
##############################################################################
|
||||
# Little node-field setters and getters to hide what bits represent
|
||||
# what.
|
||||
##############################################################################
|
||||
|
||||
sub TrieNodeSetIsTerminal {
|
||||
my ( $nodeR, $isTerminal ) = @_;
|
||||
|
||||
if ( $isTerminal ) {
|
||||
${$nodeR} |= 1 << 31;
|
||||
} else {
|
||||
${$nodeR} &= ~(1 << 31);
|
||||
}
|
||||
}
|
||||
|
||||
sub TrieNodeGetIsTerminal {
|
||||
my ( $node ) = @_;
|
||||
return ($node & 1 << 31) != 0;
|
||||
}
|
||||
|
||||
sub TrieNodeSetIsLastSibling {
|
||||
my ( $nodeR, $isLastSibling ) = @_;
|
||||
if ( $isLastSibling ) {
|
||||
${$nodeR} |= 1 << 30;
|
||||
} else {
|
||||
${$nodeR} &= ~(1 << 30);
|
||||
}
|
||||
}
|
||||
|
||||
sub TrieNodeGetIsLastSibling {
|
||||
my ( $node ) = @_;
|
||||
return ($node & 1 << 30) != 0;
|
||||
}
|
||||
|
||||
sub TrieNodeSetLetter {
|
||||
my ( $nodeR, $letter ) = @_;
|
||||
|
||||
die "letter ", $letter, " too big" if $letter >= 32;
|
||||
|
||||
my $mask = ~(0x1F << 25);
|
||||
${$nodeR} &= $mask; # clear all the bits
|
||||
${$nodeR} |= ($letter << 25); # set new ones
|
||||
}
|
||||
|
||||
sub TrieNodeGetLetter {
|
||||
my ( $node ) = @_;
|
||||
$node >>= 25;
|
||||
$node &= 0x1F;
|
||||
return $node;
|
||||
}
|
||||
|
||||
sub TrieNodeSetFirstChildOffset {
|
||||
my ( $nodeR, $fco ) = @_;
|
||||
|
||||
die "$fco larger than 25 bits" if ($fco & 0xFE000000) != 0;
|
||||
|
||||
my $mask = ~0x01FFFFFF;
|
||||
${$nodeR} &= $mask; # clear all the bits
|
||||
${$nodeR} |= $fco; # set new ones
|
||||
}
|
||||
|
||||
sub TrieNodeGetFirstChildOffset {
|
||||
my ( $node ) = @_;
|
||||
$node &= 0x01FFFFFF; # 24 bits
|
||||
return $node;
|
||||
}
|
||||
|
||||
|
||||
sub MakeTrieNode {
|
||||
my ( $letter, $isTerminal, $firstChildOffset, $isLastSibling ) = @_;
|
||||
my $result = 0;
|
||||
|
||||
TrieNodeSetIsTerminal( \$result, $isTerminal );
|
||||
TrieNodeSetIsLastSibling( \$result, $isLastSibling );
|
||||
TrieNodeSetLetter( \$result, $letter );
|
||||
TrieNodeSetFirstChildOffset( \$result, $firstChildOffset );
|
||||
|
||||
return $result;
|
||||
} # MakeTrieNode
|
||||
|
||||
# Caller may need to know the offset of the first top-level node.
|
||||
# Write it here.
|
||||
sub writeOutStartNode {
|
||||
my ( $startNodeOut, $firstRootChildOffset ) = @_;
|
||||
|
||||
open NODEOUT, ">$startNodeOut";
|
||||
print NODEOUT pack( "N", $firstRootChildOffset );
|
||||
close NODEOUT;
|
||||
} # writeOutStartNode
|
||||
|
||||
# build the hash for translating. I'm using a hash assuming it'll be
|
||||
# fast. Key is the letter; value is the 0..31 value to be output.
|
||||
sub makeTableHash {
|
||||
my $i;
|
||||
open TABLEFILE, "< $gTableFile";
|
||||
|
||||
splice @gRevMap; # empty it
|
||||
|
||||
for ( $i = 0; ; ++$i ) {
|
||||
my $ch = getc(TABLEFILE);
|
||||
if ( $ch eq undef ) {
|
||||
last;
|
||||
}
|
||||
|
||||
if ( $gUseUnicode ) { # skip the first byte each time: tmp HACK!!!
|
||||
$ch = getc(TABLEFILE);
|
||||
}
|
||||
if ( $ch eq undef ) {
|
||||
last;
|
||||
}
|
||||
|
||||
push @gRevMap, $ch;
|
||||
|
||||
if ( ord($ch) == 0 ) { # blank
|
||||
next; # we want to increment i when blank seen since
|
||||
# it is a tile value
|
||||
}
|
||||
|
||||
die "$gTableFile too large\n" if $i > 32;
|
||||
die "only blank (0) can be 32nd char\n" if ($i == 32 && $ch != 0);
|
||||
|
||||
$gTableHash{$ch} = $i;
|
||||
}
|
||||
|
||||
close TABLEFILE;
|
||||
} # makeTableHash
|
||||
|
||||
# emitNodes. "input" is $gNodes. From it we write up to
|
||||
# $nBytesPerOutfile to files named $outFileBase0..n, mapping the
|
||||
# letter field down to 5 bits with a hash built from $tableFile. If
|
||||
# at any point we encounter a letter not in the hash we fail with an
|
||||
# error.
|
||||
|
||||
sub emitNodes($$) {
|
||||
my ( $gNBytesPerOutfile, $outFileBase ) = @_;
|
||||
|
||||
# now do the emit.
|
||||
|
||||
# is 17 bits enough?
|
||||
printf STDOUT ("There are %d (0x%x) nodes in this DAWG.\n",
|
||||
0 + @gNodes, 0 + @gNodes );
|
||||
if ( @gNodes > 0x1FFFF || $gForceFour ) {
|
||||
$gNBytesPerNode = 4;
|
||||
} else {
|
||||
$gNBytesPerNode = 3;
|
||||
}
|
||||
|
||||
my $nextIndex = 0;
|
||||
my $nextFileNum = 0;
|
||||
|
||||
for ( $nextFileNum = 0; ; ++$nextFileNum ) {
|
||||
|
||||
if ( $nextIndex >= @gNodes ) {
|
||||
last; # we're done
|
||||
}
|
||||
|
||||
die "Too many outfiles; infinite loop?" if $nextFileNum > 99;
|
||||
|
||||
my $outName = sprintf("${outFileBase}_%03d.bin", $nextFileNum);
|
||||
open OUTFILE, "> $outName";
|
||||
my $curSize = 0;
|
||||
|
||||
while ( $nextIndex < @gNodes ) {
|
||||
|
||||
# scan to find the next terminal
|
||||
my $i;
|
||||
for ( $i = $nextIndex;
|
||||
!TrieNodeGetIsLastSibling($gNodes[$i]);
|
||||
++$i ) {
|
||||
|
||||
# do nothing but a sanity check
|
||||
if ( $i >= @gNodes) {
|
||||
die "bad trie format: last node not last sibling" ;
|
||||
}
|
||||
|
||||
}
|
||||
++$i; # move beyond the terminal
|
||||
my $nextSize = ($i - $nextIndex) * $gNBytesPerNode;
|
||||
if ($curSize + $nextSize > $gNBytesPerOutfile) {
|
||||
last;
|
||||
} else {
|
||||
# emit the subarray
|
||||
while ( $nextIndex < $i ) {
|
||||
outputNode( $gNodes[$nextIndex], $gNBytesPerNode,
|
||||
\*OUTFILE );
|
||||
++$nextIndex;
|
||||
}
|
||||
$curSize += $nextSize;
|
||||
}
|
||||
}
|
||||
|
||||
close OUTFILE;
|
||||
}
|
||||
|
||||
} # emitNodes
|
||||
|
||||
sub printWord {
|
||||
my ( $str ) = @_;
|
||||
|
||||
print STDERR "$str\n";
|
||||
}
|
||||
|
||||
# print out the entire dictionary, as text, to STDERR.
|
||||
|
||||
sub printOneLevel {
|
||||
|
||||
my ( $index, $str ) = @_;
|
||||
|
||||
for ( ; ; ) {
|
||||
|
||||
my $newStr = $str;
|
||||
my $node = $gNodes[$index++];
|
||||
|
||||
my $lindx = $gRevMap[TrieNodeGetLetter($node)];
|
||||
|
||||
if ( ord($lindx) >= 0x20 ) {
|
||||
$newStr .= "$lindx";
|
||||
} else {
|
||||
print STDERR "sub space" if $debug;
|
||||
$newStr .= "\\" . chr('0'+$lindx);
|
||||
}
|
||||
|
||||
if ( TrieNodeGetIsTerminal($node) ) {
|
||||
printWord( $newStr );
|
||||
}
|
||||
|
||||
my $fco = TrieNodeGetFirstChildOffset( $node );
|
||||
if ( $fco != 0 ) {
|
||||
printOneLevel( $fco, $newStr );
|
||||
}
|
||||
|
||||
if ( TrieNodeGetIsLastSibling($node) ) {
|
||||
last;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sub outputNode {
|
||||
my ( $node, $nBytes, $outfile ) = @_;
|
||||
|
||||
my $fco = TrieNodeGetFirstChildOffset($node);
|
||||
my $fourthByte;
|
||||
|
||||
if ( $nBytes == 4 ) {
|
||||
$fourthByte = $fco >> 17;
|
||||
die "fco too big" if $fourthByte > 0xFF;
|
||||
$fco &= 0x1FFFF;
|
||||
}
|
||||
|
||||
# format according to dawg.h:
|
||||
# typedef struct array_edge {
|
||||
# unsigned char highByte;
|
||||
# unsigned char lowByte;
|
||||
# unsigned char bits;
|
||||
#ifdef FOUR_BYTE
|
||||
# unsigned char moreBits;
|
||||
#endif
|
||||
# } array_edge;
|
||||
|
||||
# define LETTERMASK 0x1f
|
||||
# define ACCEPTINGMASK 0x20
|
||||
# define LASTEDGEMASK 0x40
|
||||
# define LASTBITMASK 0x80
|
||||
|
||||
# write the fco (less that one bit). We want two bytes worth
|
||||
# in three-byte mode, and three in four-byte mode (which is
|
||||
# untested)
|
||||
for ( my $i = 1; $i >= 0; --$i ) {
|
||||
my $tmp = ($fco >> ($i * 8)) & 0xFF;
|
||||
print $outfile pack( "C", $tmp );
|
||||
}
|
||||
$fco >>= 16; # it should now be 1 or 0
|
||||
die "fco not 1 or 0" if $fco > 1;
|
||||
|
||||
my $chIn5 = TrieNodeGetLetter($node);
|
||||
my $bits = $chIn5;
|
||||
|
||||
if ( TrieNodeGetIsLastSibling($node) ) {
|
||||
$bits |= 0x40;
|
||||
}
|
||||
if ( TrieNodeGetIsTerminal($node) ) {
|
||||
$bits |= 0x20;
|
||||
}
|
||||
if ( $fco != 0 ) {
|
||||
$bits |= 0x80;
|
||||
}
|
||||
print $outfile pack( "C", $bits );
|
||||
|
||||
# the final byte, if in use
|
||||
if ( $nBytes == 4 ) {
|
||||
print $outfile pack( "C", $fourthByte );
|
||||
}
|
||||
} # outputNode
|
||||
|
||||
sub usage {
|
||||
print STDERR "usage: $0 \n"
|
||||
. "\t[-b bytesPerFile] (default = 0xFFFFFFFF)\n"
|
||||
. "\t-m mapFile\n"
|
||||
. "\t-ob outFileBase\n"
|
||||
. "\t-sn start node out file\n"
|
||||
. "\t[-if input file name] -- default = stdin\n"
|
||||
. "\t[-term ch] (word terminator -- default = '\\0'\n"
|
||||
. "\t[-nosort] (input already sorted in accord with -m; " .
|
||||
" default=sort'\n"
|
||||
. "\t[-dump] (write dictionary as text to STDERR for testing)\n"
|
||||
. "\t[-force4](use 4 bytes per node regardless of need)\n"
|
||||
. "\t[-r] (reject words with letters not in mapfile)\n"
|
||||
. "\t[-k] (kill if any letters no in mapfile -- default)\n"
|
||||
;
|
||||
|
||||
} # usage
|
||||
|
||||
sub parseARGV {
|
||||
|
||||
my $arg;
|
||||
while ( my $arg = shift(@ARGV) ) {
|
||||
|
||||
SWITCH: {
|
||||
if ($arg =~ /-b/) {$gNBytesPerOutfile = shift(@ARGV), last SWITCH;}
|
||||
if ($arg =~ /-mn/) {$gTableFile = shift(@ARGV);
|
||||
$gUseUnicode = 1;
|
||||
last SWITCH;}
|
||||
if ($arg =~ /-m/) {$gTableFile = shift(@ARGV); last SWITCH;}
|
||||
if ($arg =~ /-ob/) {$gOutFileBase = shift(@ARGV), last SWITCH;}
|
||||
if ($arg =~ /-sn/) {$gStartNodeOut = shift(@ARGV), last SWITCH;}
|
||||
if ($arg =~ /-if/) {$gInFileName = shift(@ARGV), last SWITCH;}
|
||||
if ($arg =~ /-r/) {$gKillIfMissing = 0; last SWITCH;}
|
||||
if ($arg =~ /-k/) {$gKillIfMissing = 1; last SWITCH;}
|
||||
if ($arg =~ /-term/) {$gTermChar = chr(shift(@ARGV)); last SWITCH;}
|
||||
if ($arg =~ /-dump/) {$gDumpText = 1; last SWITCH;}
|
||||
if ($arg =~ /-nosort/) {$gNeedsSort = 0; last SWITCH;}
|
||||
if ($arg =~ /-wc/) {$gCountFile = shift(@ARGV); last SWITCH;}
|
||||
if ($arg =~ /-ns/) {$gBytesPerNodeFile = shift(@ARGV); last SWITCH;}
|
||||
if ($arg =~ /-force4/) {$gForceFour = 1; last SWITCH;}
|
||||
die "unexpected arg $arg\n";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
print STDERR "gNBytesPerOutfile=$gNBytesPerOutfile\n" if $debug;
|
||||
print STDERR "gTableFile=$gTableFile\n" if $debug;
|
||||
print STDERR "gOutFileBase=$gOutFileBase\n" if $debug;
|
||||
print STDERR "gStartNodeOut=$gStartNodeOut\n" if $debug;
|
||||
printf STDERR "gTermChar=%s(%d)\n", $gTermChar, ord($gTermChar) if $debug;
|
||||
|
||||
return $gTableFile;
|
||||
|
||||
} # parseARGV
|
||||
45
xwords4/xwords4/dawg/frank_mkspecials.pl
Executable file
45
xwords4/xwords4/dawg/frank_mkspecials.pl
Executable file
|
|
@ -0,0 +1,45 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2001 by Eric House (fixin@peak.org)
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
# Given arguments consisting of triples, first a string and then pbitm
|
||||
# files representing bitmaps. For each triple, print out the string and
|
||||
# then the converted bitmaps.
|
||||
|
||||
use strict;
|
||||
|
||||
while ( @ARGV ) {
|
||||
my $str = shift();
|
||||
my $largebmp = shift();
|
||||
my $smallbmp = shift();
|
||||
|
||||
doOne( $str, $largebmp, $smallbmp );
|
||||
}
|
||||
|
||||
sub doOne {
|
||||
my ( $str, $largebmp, $smallbmp ) = @_;
|
||||
|
||||
print pack( "C", length($str) );
|
||||
print $str;
|
||||
|
||||
print STDERR "looking at $largebmp", "\n";
|
||||
|
||||
print `cat $largebmp | ../pbitm2bin.pl`;
|
||||
print `cat $smallbmp | ../pbitm2bin.pl`;
|
||||
}
|
||||
|
||||
|
||||
99
xwords4/xwords4/dawg/gendict.c
Normal file
99
xwords4/xwords4/dawg/gendict.c
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
* Copyright 1998 by Eric House. All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
typedef char boolean;
|
||||
#define true 1
|
||||
#define false 0
|
||||
|
||||
#define MAXWORDLEN 15
|
||||
|
||||
boolean writeOneWord( char* word, int len );
|
||||
void usage();
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
// main
|
||||
// This program generates all possible combinations of letters 'A'-'Z' of
|
||||
// lengths between 2 and MAXWORDLEN, writing them to stdout. It's meant
|
||||
// to be used to test the dawg dictionary and a state machine based on
|
||||
// it: if the output of this program is used as input to that machine, the
|
||||
// list of words accepted by the machine should be identical to the list
|
||||
// from which the dawg was created -- provided sufficient length words
|
||||
// are created.
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
int main( int argc, char** argv ) {
|
||||
int i, j;
|
||||
long lowerbound = 0;
|
||||
long upperbound = 0;
|
||||
char buffer[MAXWORDLEN+1];
|
||||
|
||||
if ( argc ==3 ) {
|
||||
sscanf( argv[1], "%d", &lowerbound );
|
||||
sscanf( argv[2], "%d", &upperbound );
|
||||
if ( lowerbound < 2 || upperbound < 2 ) {
|
||||
usage();
|
||||
}
|
||||
} else {
|
||||
usage();
|
||||
}
|
||||
|
||||
for ( i = lowerbound; i <= upperbound; ++i ) {
|
||||
buffer[0] = '\0';
|
||||
for ( j = 0; j < i; ++j ) {
|
||||
strcat( buffer, "A" );
|
||||
}
|
||||
while ( !writeOneWord( buffer, i-1 ) ) {
|
||||
// do nothing
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Increment the last letter if possible. Otherwise reset it and find
|
||||
* the first letter above it that can be incremented, resetting along
|
||||
* the way. If the *first* letter needs to be reset we're finished.
|
||||
*/
|
||||
boolean writeOneWord( char* word, int len ) {
|
||||
fprintf( stdout, "%s\n", word );
|
||||
|
||||
if ( word[len] != 'Z' ) {
|
||||
word[len]++;
|
||||
} else {
|
||||
int i;
|
||||
word[len] = 'A';
|
||||
for ( i = len-1; ; --i ) {
|
||||
if ( word[i] != 'Z' ) {
|
||||
word[i]++;
|
||||
break;
|
||||
} else if ( i == 0 ) { // they're *all* Zs...
|
||||
return true; // we wrote all the words!
|
||||
} else {
|
||||
word[i] = 'A';
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void usage() {
|
||||
fprintf( stderr,
|
||||
"USAGE: gendict upperbound lowerbound\n"
|
||||
" (Both must be >= 2.)\n" );
|
||||
exit( 0 );
|
||||
}
|
||||
|
||||
36
xwords4/xwords4/dawg/listchars.pl
Executable file
36
xwords4/xwords4/dawg/listchars.pl
Executable file
|
|
@ -0,0 +1,36 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2001 by Eric House
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
use strict;
|
||||
|
||||
my %lettersHash;
|
||||
|
||||
|
||||
while ( <> ) {
|
||||
chomp;
|
||||
foreach my $byte (split //) {
|
||||
++$lettersHash{$byte};
|
||||
}
|
||||
}
|
||||
|
||||
foreach my $key (sort keys(%lettersHash)) {
|
||||
my $count = $lettersHash{$key};
|
||||
if ( $count ) {
|
||||
printf( "%.3d: %s: %.7d\n", ord($key), $key, $count );
|
||||
}
|
||||
}
|
||||
111
xwords4/xwords4/dawg/palm_mkspecials.pl
Executable file
111
xwords4/xwords4/dawg/palm_mkspecials.pl
Executable file
|
|
@ -0,0 +1,111 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2002 by Eric House
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
# Given arguments consisting of triples, first a string and then pbitm
|
||||
# files representing bitmaps. The format looks like this:
|
||||
|
||||
# array [0-n] of { char len;
|
||||
# char[3] alt txt;
|
||||
# int16 offsetOfLarge;
|
||||
# int16 offsetOfSmall;
|
||||
# }
|
||||
# array [0-n] of {
|
||||
# bitmapLargeIfPresent;
|
||||
# bitmapSmallIfPresent;
|
||||
# }
|
||||
#
|
||||
# In addition, there's padding between bitmaps if needed to get the next
|
||||
# one to a 2-byte boundary. And the input files are not in PalmOS bitmap
|
||||
# format, so thay have to get converted into a tmp file before the sizes
|
||||
# can be known and included in the eventual output.
|
||||
|
||||
use strict;
|
||||
|
||||
my $tmpfile = "/tmp/tmpout$$";
|
||||
|
||||
my $nSpecials = @ARGV / 3;
|
||||
die "wrong number of args" if (@ARGV % 3) != 0;
|
||||
my $gOffset = $nSpecials * 8; # sizeof(Xloc_specialEntry)
|
||||
|
||||
open TMPFILE, "> $tmpfile";
|
||||
|
||||
for ( my $i = 0; $i < $nSpecials; ++$i ) {
|
||||
|
||||
my $size;
|
||||
|
||||
my $str = shift( @ARGV );
|
||||
my $len = length($str);
|
||||
die "string $str too long" if $len > 3;
|
||||
print $str;
|
||||
while ( $len < 4 ) {
|
||||
++$len;
|
||||
print pack("c", 0 );
|
||||
}
|
||||
|
||||
doOneFile( shift( @ARGV ), \*TMPFILE, \$gOffset );
|
||||
doOneFile( shift( @ARGV ), \*TMPFILE, \$gOffset );
|
||||
}
|
||||
|
||||
close TMPFILE;
|
||||
|
||||
# now append the tempfile
|
||||
open TMPFILE, "< $tmpfile";
|
||||
while ( read( TMPFILE, my $buffer, 128 ) ) {
|
||||
print $buffer;
|
||||
}
|
||||
close TMPFILE;
|
||||
|
||||
unlink $tmpfile;
|
||||
|
||||
exit 0;
|
||||
|
||||
|
||||
sub doOneFile($$) {
|
||||
my ( $fil, $fh, $offsetR ) = @_;
|
||||
|
||||
my $size = convertBmp($fil, $fh );
|
||||
if ( ($size % 2) != 0 ) {
|
||||
++$size;
|
||||
print $fh pack( "c", 0 );
|
||||
}
|
||||
|
||||
print pack( "n", $size > 0? ${$offsetR} : 0 );
|
||||
|
||||
${$offsetR} += $size;
|
||||
} # doOneFile
|
||||
|
||||
sub convertBmp($$) {
|
||||
my ( $pbitmfile, $fhandle ) = @_;
|
||||
|
||||
if ( $pbitmfile eq "/dev/null" ) {
|
||||
return 0;
|
||||
} else {
|
||||
|
||||
# for some reason I can't get quote marks to print into tmp.rcp using just `echo`
|
||||
open TMP, "> tmp.rcp";
|
||||
print TMP "BITMAP ID 1000 \"$pbitmfile\" AUTOCOMPRESS";
|
||||
close TMP;
|
||||
|
||||
`pilrc tmp.rcp`;
|
||||
print $fhandle `cat Tbmp03e8.bin`;
|
||||
my $siz = -s "Tbmp03e8.bin";
|
||||
`rm -f tmp.rcp Tbmp03e8.bin`;
|
||||
|
||||
return $siz;
|
||||
}
|
||||
}
|
||||
234
xwords4/xwords4/dawg/par.pl
Executable file
234
xwords4/xwords4/dawg/par.pl
Executable file
|
|
@ -0,0 +1,234 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2002 by Eric House (fixin@peak.org) All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
# Only enough of par's features to support building a crosswords dict
|
||||
# pdb
|
||||
|
||||
use strict;
|
||||
|
||||
my $debug = 0;
|
||||
|
||||
|
||||
# stolen from par source
|
||||
my $PRC_FLAGS_RESOURCE = (0x1<<0);
|
||||
my $PRC_FLAGS_READONLY = (0x1<<1);
|
||||
my $PRC_FLAGS_DIRTY = (0x1<<2);
|
||||
my $PRC_FLAGS_BACKUP = (0x1<<3);
|
||||
my $PRC_FLAGS_NEWER = (0x1<<4);
|
||||
my $PRC_FLAGS_RESET = (0x1<<5);
|
||||
my $PRC_FLAGS_COPYPREVENT = (0x1<<6);
|
||||
my $PRC_FLAGS_STREAM = (0x1<<7);
|
||||
my $PRC_FLAGS_HIDDEN = (0x1<<8);
|
||||
my $PRC_FLAGS_LAUNCHABLE = (0x1<<9);
|
||||
my $PRC_FLAGS_RECYCLABLE = (0x1<<10);
|
||||
my $PRC_FLAGS_BUNDLE = (0x1<<11);
|
||||
my $PRC_FLAGS_OPEN = (0x1<<15);
|
||||
|
||||
|
||||
my $gAttrs = 0;
|
||||
my $gVersion = 1; # par defaults this to 1
|
||||
|
||||
my $cmd = shift( @ARGV );
|
||||
die "only 'c' supported now" if $cmd ne "c" && $cmd ne "-c";
|
||||
|
||||
readHOptions( \@ARGV );
|
||||
|
||||
my $dbfile = shift( @ARGV );
|
||||
my $name = shift( @ARGV );
|
||||
die "name $name too long" if length($name) > 31;
|
||||
my $type = shift( @ARGV );
|
||||
die "type $type must be of length 4" if length($type) != 4;
|
||||
my $cid = shift( @ARGV );
|
||||
die "cid $cid must be of length 4" if length($cid) != 4;
|
||||
|
||||
my @fileNames;
|
||||
my @fileLengths;
|
||||
|
||||
my $nFiles = 0;
|
||||
|
||||
while ( @ARGV > 0 ) {
|
||||
my $filename = shift( @ARGV );
|
||||
push @fileNames, $filename;
|
||||
push @fileLengths, -s $filename;
|
||||
++$nFiles;
|
||||
}
|
||||
|
||||
# from par's prcp.h; thanks djw!
|
||||
# typedef struct prc_file_t {
|
||||
# prc_byte_t name[32];
|
||||
# prc_byte_t flags[2];
|
||||
# prc_byte_t version[2];
|
||||
# prc_byte_t ctime[4];
|
||||
# prc_byte_t mtime[4];
|
||||
# prc_byte_t btime[4];
|
||||
# prc_byte_t modnum[4];
|
||||
# prc_byte_t appinfo[4];
|
||||
# prc_byte_t sortinfo[4];
|
||||
# prc_byte_t type[4];
|
||||
# prc_byte_t cid[4];
|
||||
# prc_byte_t unique_id_seed[4];
|
||||
# prc_byte_t next_record_list[4];
|
||||
# prc_byte_t nrecords[2];
|
||||
# } prc_file_t;
|
||||
|
||||
my $str;
|
||||
my $offset = 0;
|
||||
|
||||
open OUTFILE, "> $dbfile" or die "couldn't open outfile $dbfile for writing";
|
||||
|
||||
# print the string, then pad with 0s
|
||||
$offset = length($name);
|
||||
print OUTFILE $name;
|
||||
while ( $offset < 32 ) {
|
||||
print OUTFILE pack("c", 0);
|
||||
++$offset;
|
||||
}
|
||||
|
||||
$str = pack("n", $gAttrs); # flags
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$str = pack("n", $gVersion); # version
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
my $time = time() + 2082844800;
|
||||
$str = pack("NNN", $time, $time, 0); # ctime, mtime, btime
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$str = pack("N", 0 ); # mod num
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$str = pack("N", 0 ); # appinfo
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$str = pack("N", 0 ); # sortinfo
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
|
||||
print OUTFILE $type; # type
|
||||
print OUTFILE $cid; # cid
|
||||
$offset += 8;
|
||||
|
||||
$str = pack("NN", 0, 0 ); # unique_id_seed, next_record_list
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$str = pack("n", $nFiles ); # nrecords
|
||||
print OUTFILE $str;
|
||||
$offset += length($str);
|
||||
|
||||
$offset += $nFiles * 8;
|
||||
$offset += 2; # djw adds 2 bytes after size list; see below
|
||||
foreach my $len ( @fileLengths ) {
|
||||
print OUTFILE pack( "N", $offset );
|
||||
print OUTFILE pack( "N", 0 );
|
||||
$offset += $len;
|
||||
}
|
||||
|
||||
print OUTFILE pack( "n", 0 ); # djw does this sans comment: flush.c, line 87
|
||||
|
||||
foreach my $file ( @fileNames ) {
|
||||
open INFILE, "<$file" or die "couldn't open infile $file\n";
|
||||
my $buffer;
|
||||
while ( read INFILE, $buffer, 1024 ) {
|
||||
print OUTFILE $buffer;
|
||||
}
|
||||
close INFILE;
|
||||
}
|
||||
|
||||
|
||||
close OUTFILE;
|
||||
|
||||
exit 0;
|
||||
|
||||
##############################################################################
|
||||
# Subroutines
|
||||
##############################################################################
|
||||
|
||||
sub readHOptions {
|
||||
|
||||
my ( $argvR ) = @_;
|
||||
|
||||
for ( ; ; ) {
|
||||
my $opt = ${$argvR}[0];
|
||||
|
||||
if ( $opt !~ /^-/ ) {
|
||||
last;
|
||||
}
|
||||
|
||||
# it starts with a '-': use it; else don't consume anything
|
||||
shift @{$argvR};
|
||||
|
||||
if ( $opt eq "-a" ) {
|
||||
my $attrs = shift @{$argvR};
|
||||
processAttrString( $attrs );
|
||||
} elsif ( $opt eq "-v" ) {
|
||||
$gVersion = shift @{$argvR};
|
||||
} else {
|
||||
die "what's with \"$opt\": -a and -v are the only hattrs supported";
|
||||
}
|
||||
}
|
||||
|
||||
} # readHOptions
|
||||
|
||||
sub processAttrString {
|
||||
|
||||
my ( $attrs ) = @_;
|
||||
|
||||
foreach my $flag ( split /\|/, $attrs ) {
|
||||
|
||||
print STDERR "looking at flag $flag\n" if $debug;
|
||||
|
||||
if ( $flag =~ /resource/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_RESOURCE;
|
||||
die "resource attr not supported";
|
||||
} elsif ( $flag =~ /readonly/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_READONLY;
|
||||
} elsif ( $flag =~ /dirty/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_DIRTY;
|
||||
} elsif ( $flag =~ /backup/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_BACKUP;
|
||||
} elsif ( $flag =~ /newer/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_NEWER;
|
||||
} elsif ( $flag =~ /reset/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_RESET;
|
||||
} elsif ( $flag =~ /copyprevent/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_COPYPREVENT;
|
||||
} elsif ( $flag =~ /stream/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_STREAM;
|
||||
die "stream attr not supported";
|
||||
} elsif ( $flag =~ /hidden/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_HIDDEN;
|
||||
} elsif ( $flag =~ /launchable/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_LAUNCHABLE;
|
||||
} elsif ( $flag =~ /recyclable/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_RECYCLABLE;
|
||||
} elsif ( $flag =~ /bundle/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_BUNDLE;
|
||||
} elsif ( $flag =~ /open/ ) {
|
||||
$gAttrs |= $PRC_FLAGS_OPEN;
|
||||
} else {
|
||||
die "flag $flag not supportd";
|
||||
}
|
||||
}
|
||||
} # processAttrString
|
||||
87
xwords4/xwords4/dawg/pbitm2bin.pl
Executable file
87
xwords4/xwords4/dawg/pbitm2bin.pl
Executable file
|
|
@ -0,0 +1,87 @@
|
|||
#!/usr/bin/perl
|
||||
#
|
||||
# Copyright 2001 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
#
|
||||
#
|
||||
# Given a pbitm on stdin, a text bitmap file where '#' indicates a set
|
||||
# bit and '-' indicates a clear bit, convert into binary form (on
|
||||
# stdout) where there's one bit per bit plus a byte each for the width
|
||||
# and height. Nothing for bitdepth at this point. And no padding: if
|
||||
# the number of bits in a row isn't a multiple of 8 then one byte will
|
||||
# hold the last bits of one row and the first of another.
|
||||
|
||||
use strict;
|
||||
|
||||
my $nRows = 0;
|
||||
my $nCols = 0;
|
||||
my $bits = ""; # save the chars in a single string to start
|
||||
|
||||
# first gather information and sanity-check the data
|
||||
|
||||
while (<>) {
|
||||
chomp;
|
||||
my $len = length();
|
||||
|
||||
if ( $nCols == 0 ) {
|
||||
$nCols = $len;
|
||||
} else {
|
||||
die "line of inconsistent length" if $nCols != $len ;
|
||||
}
|
||||
if ( $nCols == 0 ) {
|
||||
last;
|
||||
}
|
||||
|
||||
$bits .= $_;
|
||||
++$nRows;
|
||||
}
|
||||
|
||||
my $len = length($bits);
|
||||
print pack( "C", $nCols );
|
||||
|
||||
# if we've been given an empty file, print out a single null byte and
|
||||
# be done. That'll be the convention for "non-existant bitmap".
|
||||
if ( $len == 0 ) {
|
||||
exit 0;
|
||||
}
|
||||
print pack( "C", $nRows );
|
||||
printf STDERR "emitting %dx%d bitmap\n", $nCols, $nRows;
|
||||
|
||||
|
||||
my @charlist = split( //,$bits);
|
||||
my $byte = 0;
|
||||
|
||||
for ( my $count = 0; ; ++$count ) {
|
||||
|
||||
my $ch = $charlist[$count];
|
||||
my $bitindex = $count % 8;
|
||||
|
||||
$ch == '-' || $ch == '#' || die "unknown char $ch";
|
||||
|
||||
my $bit = ($ch eq '#')? 1:0;
|
||||
|
||||
$byte |= $bit << (7 - $bitindex);
|
||||
|
||||
my $lastPass = $count + 1 == $len;
|
||||
if ( $bitindex == 7 || $lastPass ) {
|
||||
print pack( "C", $byte );
|
||||
if ( $lastPass ) {
|
||||
last;
|
||||
}
|
||||
$byte = 0;
|
||||
}
|
||||
|
||||
} # for loop
|
||||
49
xwords4/xwords4/dawg/pdb.h
Normal file
49
xwords4/xwords4/dawg/pdb.h
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
|
||||
/*
|
||||
* Copyright 1997 - 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
typedef unsigned long DWORD;
|
||||
typedef unsigned short WORD;
|
||||
|
||||
// all numbers in these structs are big-endian, MAC format
|
||||
typedef struct DocHeader {
|
||||
char sName[32]; // 0x00
|
||||
DWORD dwUnknown1; // 0x20 bytes
|
||||
DWORD dwTime1; // 0x24 bytes
|
||||
DWORD dwTime2; // 0x28
|
||||
DWORD dwTime3; // 0x2C
|
||||
DWORD dwLastSync; // 0x30
|
||||
DWORD ofsSort; // 0x34
|
||||
DWORD ofsCatagories;// 0x38
|
||||
DWORD dwType; // 0x3C
|
||||
DWORD dwCreator; // 0x40
|
||||
DWORD dwUnknown2; // 0x44
|
||||
DWORD dwUnknown3; // 0x48
|
||||
WORD wNumRecs; // 0x4C
|
||||
} DocHeader;
|
||||
|
||||
#define DOCHEADSZ 78
|
||||
|
||||
typedef struct RecordHeader {
|
||||
// <eeh> added type in experimentally! on 4/14
|
||||
/* char type[4]; */
|
||||
DWORD offset;
|
||||
DWORD bits; // high byte is flags, remaining three are a unique id
|
||||
} RecordHeader;
|
||||
|
||||
#define RECHEADSZ 8
|
||||
272
xwords4/xwords4/dawg/pdb2dict.c
Executable file
272
xwords4/xwords4/dawg/pdb2dict.c
Executable file
|
|
@ -0,0 +1,272 @@
|
|||
// -*-mode: C; fill-column: 80; compile-command: "make pdb2dict"; -*-
|
||||
|
||||
/*
|
||||
* Copyright 1997 - 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "pdb.h"
|
||||
#include "dawg.h"
|
||||
|
||||
#include "swap.h"
|
||||
|
||||
/////////////////////////////// prototypes //////////////////////////////////
|
||||
static void generate_dict( array_edge* memoryFile );
|
||||
static void write_words( array_edge* memoryFile, long edgeIndex,
|
||||
short charIndex, char* wordBuffer );
|
||||
static void skipNHeaders( FILE* file, int n, RecordHeader* recHeader );
|
||||
static array_edge* loadEdgesArray( FILE* dictFile, unsigned char* charTable );
|
||||
static void* readNthRecord( FILE* files, void* where, int whereMaxSize,
|
||||
int whichRec, int* foundSize );
|
||||
static void getNthOffset( FILE* file, int n, long* offset,
|
||||
unsigned short* size );
|
||||
static void printWord( char* wordBuffer );
|
||||
|
||||
///////////////////////////////// globals ///////////////////////////////////
|
||||
static unsigned char charTable[32];
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
void usage() {
|
||||
fprintf( stderr, "Usage: pdb2dict <file.pdb>\n" );
|
||||
exit( 1 );
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
int main( int argc, char** argv ) {
|
||||
char* pdbName;
|
||||
array_edge* memoryFile;
|
||||
FILE* dictFile;
|
||||
if ( argc < 2 ) {
|
||||
usage();
|
||||
}
|
||||
|
||||
// fprintf( stderr, "sizeof(WORD)=%d\n", sizeof(WORD) );
|
||||
|
||||
pdbName = argv[1];
|
||||
if ( (argv < 2) || (strchr( pdbName, '.' ) == NULL) ||
|
||||
strcmp( (char*)strchr( pdbName, '.' ), ".pdb" ) ) {
|
||||
usage();
|
||||
}
|
||||
|
||||
dictFile = fopen( pdbName, "r" );
|
||||
if ( dictFile == NULL ) {
|
||||
fprintf( stderr, "%s: No such file %s\n", argv[0], pdbName );
|
||||
exit(1);
|
||||
}
|
||||
memoryFile = loadEdgesArray( dictFile, charTable );
|
||||
fclose( dictFile );
|
||||
|
||||
generate_dict( memoryFile );
|
||||
free( memoryFile );
|
||||
return 0;
|
||||
} // main
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
static array_edge* loadEdgesArray( FILE* dictFile, unsigned char* charTable ) {
|
||||
DocHeader pdbHeader;
|
||||
dawg_header dawgHeader;
|
||||
array_edge* firstEdge = NULL;
|
||||
fpos_t firstHeaderOffset;
|
||||
int curSize, i;
|
||||
|
||||
// read in the main pdb header
|
||||
fread( &pdbHeader, DOCHEADSZ, 1, dictFile );
|
||||
assert( (strncmp( (char*)&pdbHeader.dwCreator, "Xwr3", 4) == 0)
|
||||
&& (strncmp( (char*)&pdbHeader.dwType, "DAWG", 4) == 0) );
|
||||
|
||||
(void)fgetpos( dictFile, &firstHeaderOffset );
|
||||
|
||||
(void)readNthRecord( dictFile, &dawgHeader, sizeof(dawgHeader), 0, NULL );
|
||||
//fprintf( stderr, "word count = %ld\n", swap_long(dawgHeader.numWords) );
|
||||
assert( dawgHeader.firstEdgeRecNum == 3 );
|
||||
|
||||
(void)readNthRecord( dictFile, charTable, 32, dawgHeader.charTableRecNum,
|
||||
NULL );
|
||||
|
||||
firstEdge = (array_edge*)malloc(0);
|
||||
curSize = 0;
|
||||
for ( i = dawgHeader.firstEdgeRecNum; i < swap_short(pdbHeader.wNumRecs);
|
||||
++i ) {
|
||||
int newSize;
|
||||
void* rec = readNthRecord( dictFile, NULL, 0, i, &newSize );
|
||||
|
||||
firstEdge = (array_edge*)realloc( firstEdge, curSize + newSize );
|
||||
memcpy( ((char*)firstEdge) + curSize, rec, newSize );
|
||||
free( rec );
|
||||
curSize += newSize;
|
||||
}
|
||||
return firstEdge;
|
||||
} // loadEdgesArray
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
static void* readNthRecord( FILE* file, void* where, int whereMaxSize,
|
||||
int whichRec, int* foundSize ) {
|
||||
void* result = NULL;
|
||||
fpos_t pos;
|
||||
long offset;
|
||||
unsigned short size;
|
||||
|
||||
(void)fgetpos( file, &pos);
|
||||
|
||||
getNthOffset( file, whichRec, &offset, &size );
|
||||
fseek( file, offset, 0 );
|
||||
|
||||
if ( where == NULL ) {
|
||||
result = malloc( size );
|
||||
fread( result, size, 1, file );
|
||||
} else {
|
||||
assert( size <= whereMaxSize );
|
||||
fread( where, size, 1, file );
|
||||
}
|
||||
if ( foundSize ) {
|
||||
*foundSize = size;
|
||||
}
|
||||
|
||||
(void)fsetpos( file, &pos);
|
||||
return result;
|
||||
} // readNthRecord
|
||||
|
||||
/******************************************************************************
|
||||
* Size is my offset subtracted from the one after me, unless I'm the last
|
||||
* entry in which case it's file size minus my offset.
|
||||
*****************************************************************************/
|
||||
static void getNthOffset( FILE* file, int n, long* offset,
|
||||
unsigned short* size ) {
|
||||
DocHeader pdbHeader;
|
||||
RecordHeader recHeader;
|
||||
fpos_t pos;
|
||||
long sizeCalc;
|
||||
|
||||
(void)fgetpos( file, &pos);
|
||||
rewind( file );
|
||||
|
||||
//fprintf( stderr, "sizeof(pdbHeader)=%d\n", sizeof(pdbHeader) );
|
||||
fread( &pdbHeader, DOCHEADSZ, 1, file );
|
||||
assert( swap_short(pdbHeader.wNumRecs) > n );
|
||||
|
||||
skipNHeaders( file, n+1, &recHeader );
|
||||
*offset = sizeCalc = swap_long( recHeader.offset );
|
||||
if ( n+1 == swap_short(pdbHeader.wNumRecs) ) { // use file size
|
||||
fseek( file, 0, SEEK_END );
|
||||
sizeCalc = ftell( file ) - sizeCalc;
|
||||
} else {
|
||||
skipNHeaders( file, 1, &recHeader );
|
||||
sizeCalc = swap_long( recHeader.offset ) - sizeCalc;
|
||||
}
|
||||
*size = sizeCalc;
|
||||
|
||||
(void)fsetpos( file, &pos);
|
||||
} // getNthOffset
|
||||
|
||||
/******************************************************************************
|
||||
* Skip over the given number of headers, returning with the last one read
|
||||
* into the supplied buffer.
|
||||
*****************************************************************************/
|
||||
static void skipNHeaders( FILE* file, int n, RecordHeader* recHeader ) {
|
||||
short i;
|
||||
for ( i = 0; i < n; ++i ) {
|
||||
fread( recHeader, sizeof(*recHeader), 1, file );
|
||||
}
|
||||
} // skipNHeaders
|
||||
|
||||
/******************************************************************************
|
||||
* beginning with an array of NULL chars, on each level of the tree
|
||||
* iterate over each child replacing the appropriate char with the
|
||||
* letter from the edge. When an edge is terminal, print the word
|
||||
* formed. And when returning replace the letter with a null char.
|
||||
*****************************************************************************/
|
||||
static void generate_dict( array_edge* memoryFile ) {
|
||||
char wordBuffer[31];
|
||||
(void)memset( wordBuffer, '\0', 31 );
|
||||
|
||||
write_words( memoryFile, 0, 0, wordBuffer );
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
void write_words( array_edge* memoryFile, long edgeIndex, short charIndex,
|
||||
char* wordBuffer ) {
|
||||
array_edge* child = &memoryFile[edgeIndex];
|
||||
for ( ; ; child = &memoryFile[++edgeIndex] ) {
|
||||
unsigned char bits = child->bits;
|
||||
long index = 0;
|
||||
wordBuffer[charIndex] = charTable[(bits & LETTERMASK)];
|
||||
if ( bits & ACCEPTINGMASK ) {
|
||||
printWord( wordBuffer );
|
||||
}
|
||||
|
||||
index = (child->highByte * 256) + child->lowByte;
|
||||
if ( bits & LASTBITMASK ) {
|
||||
index += 0x00010000;
|
||||
}
|
||||
|
||||
if ( index > 0 ) {
|
||||
write_words( memoryFile, index, charIndex+1, wordBuffer );
|
||||
}
|
||||
if ( bits & LASTEDGEMASK ) {
|
||||
wordBuffer[charIndex] = '\0';
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
*****************************************************************************/
|
||||
static void printWord( char* wordBuffer ) {
|
||||
unsigned char buf[32], ch;
|
||||
unsigned char* next = buf;
|
||||
|
||||
while ( (ch = *wordBuffer++) != '\0' ) {
|
||||
if ( ch >= 0x20 ) {
|
||||
*next++ = ch;
|
||||
} else {
|
||||
char* str = NULL;
|
||||
switch ( ch ) {
|
||||
case 1:
|
||||
str = "CH";
|
||||
break;
|
||||
case 2:
|
||||
str = "LL";
|
||||
break;
|
||||
case 3:
|
||||
str = "RR";
|
||||
break;
|
||||
default:
|
||||
fprintf( stderr, "Got %d\n", ch );
|
||||
assert( 0 );
|
||||
}
|
||||
strcpy( next, str );
|
||||
next += strlen(str);
|
||||
}
|
||||
}
|
||||
*next = '\0';
|
||||
fprintf( stdout, "%s\n", buf );
|
||||
} // appendChars
|
||||
9
xwords4/xwords4/dawg/swap.c
Normal file
9
xwords4/xwords4/dawg/swap.c
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
|
||||
/* #ifdef BIG_ENDIAN */
|
||||
/* unsigned short swap_short(unsigned short s) { return s; } */
|
||||
/* unsigned long swap_long(unsigned long l ) { return l; } */
|
||||
|
||||
/* #else */
|
||||
|
||||
|
||||
/* #endif */
|
||||
35
xwords4/xwords4/dawg/swap.h
Normal file
35
xwords4/xwords4/dawg/swap.h
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/*
|
||||
* Copyright 1997 by Eric House (fixin@peak.org). All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef _SWAP_H_
|
||||
#define _SWAP_H_
|
||||
|
||||
#if BYTE_ORDER == LITTLE_ENDIAN
|
||||
static unsigned short swap_short( unsigned short s ) {
|
||||
return s >> 8 | s << 8;
|
||||
}
|
||||
|
||||
static unsigned long swap_long( unsigned long l ) {
|
||||
return l >> 24 | (l>>8 & 0x0000FF00) | (l<<8 & 0x00FF0000) | l << 24;
|
||||
}
|
||||
#else
|
||||
# define swap_short(s) (s)
|
||||
# define swap_long(l) (l)
|
||||
#endif
|
||||
|
||||
#endif /* _SWAP_H_ */
|
||||
673
xwords4/xwords4/dawg/xloc.c
Normal file
673
xwords4/xwords4/dawg/xloc.c
Normal file
|
|
@ -0,0 +1,673 @@
|
|||
// -*-mode: C; fill-column: 80; compile-command: "make xloc"; -*-
|
||||
/*
|
||||
* Copyright 1998 - 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
/* This is where the langauge tile tables live. There's one for each
|
||||
* supported langauge. Tile tables give the face of each tile (e.g. "A")
|
||||
* the value (1), and the number in the game (8).
|
||||
*
|
||||
* This program generates two output files, a text file which has each
|
||||
* face on a separate line: "\0\nA\nB\n..." (where the \0 will later
|
||||
* be mapped to BLANK), and a binary file giving the values and counts
|
||||
* of those tiles in table form *and* additional data for any tiles with
|
||||
* non-printing faces mapping them to alternative printing values (e.g. "_"
|
||||
* for BLANK) and (optionally) to custom pilot bitmaps for representation
|
||||
* on-screen.
|
||||
*
|
||||
* This program comes after I've attempted to do something simpler with
|
||||
* shell scripts in makefiles. There are too many problems with the null
|
||||
* and sub-0x20 bytes for the non-printing characters' faces. Thus for now
|
||||
* rather than pass in tables I'll just maintain one for each language here.
|
||||
*/
|
||||
|
||||
/* Here's the old comment:
|
||||
* Build a resource for Crosswords representing the letters in the
|
||||
* game, and the number and value of each letter. The arrays for
|
||||
* each language for which a version of Crosswords exists are also
|
||||
* stored in this file.
|
||||
*
|
||||
* This resource is meant to replace the gInitialLetterCounts and
|
||||
* gTileValues arrays as well as to provide indirection aiding in
|
||||
* localization
|
||||
*
|
||||
* In order to keep the size of an in-memory game down, letters are
|
||||
* stored in five bits (and in null-terminated strings) so we have a
|
||||
* range of 31 values available. Each will then be an index into a
|
||||
* table built here. This extra level of abstraction permits
|
||||
* non-contiguous ranges of characters as, for instance, is required
|
||||
* by the German characters having umlauts. Note, however, that a
|
||||
* language requiring *more* than 31 characters (including 1 for each
|
||||
* blank) will require some redesign.
|
||||
*
|
||||
* An additional problem is created by the need to convert letters
|
||||
* from lower case to upper on input to the blank-setting dialog as a
|
||||
* courtesy to players (already present in the shipping version,
|
||||
* alas). For now I'll simply search the array of printing values (col.
|
||||
* 2 below) and if I fail to find it try various transformations the first
|
||||
* of which will be to upper-case a value in the a-z range
|
||||
*
|
||||
* The arrays below consist of three columns each:
|
||||
* ASCII value numTilesThatValue tileValue
|
||||
* The latter two are compressed into one byte, four bits each, limiting
|
||||
* each to the range 1..16. (Actually, I ought to confirm that the code
|
||||
* required to deal with shifting and masking isn't bigger than the extra
|
||||
* <= 31 bytes I'm saving.... so skip the compression for now.)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <assert.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "xwcommon3.h"
|
||||
//#include "../../../../xwcommon3.h"
|
||||
|
||||
//#define MASH(a,b) ((a)<<4)|(b)
|
||||
#define MASH(a,b) (a),(b)
|
||||
|
||||
static short endian_short( short in ) {
|
||||
if ( 0 ) {
|
||||
return in;
|
||||
} else {
|
||||
return ((in >> 8) & 0x00ff) | ((in << 8) & 0xFF00);
|
||||
}
|
||||
}
|
||||
|
||||
void errexit( char* msg ) {
|
||||
fprintf( stderr, msg );
|
||||
exit(1);
|
||||
}
|
||||
|
||||
static short fileSize( char* fileName ) {
|
||||
short result;
|
||||
FILE* f = fopen( fileName, "rb" );
|
||||
printf( "opening %s\n", fileName );
|
||||
if ( f == NULL ) {
|
||||
errexit( "fopen failed\n" );
|
||||
}
|
||||
if ( fseek( f, 0L, SEEK_END ) != 0 ) {
|
||||
errexit( "error from fseek" );
|
||||
}
|
||||
result = ftell( f );
|
||||
fclose( f );
|
||||
printf( "length of file %s is %d\n", fileName, result );
|
||||
return (short)result;
|
||||
}
|
||||
|
||||
#if 0
|
||||
Graham writes:
|
||||
> PORTUGUESE
|
||||
>
|
||||
>
|
||||
> Letter Distribution Face value
|
||||
>
|
||||
> A 12 1
|
||||
> B 2 3
|
||||
> C 4 3
|
||||
> CH 1 5
|
||||
> D 5 2
|
||||
> E 12 1
|
||||
> F 1 4
|
||||
> G 2 2
|
||||
> H 2 4
|
||||
> I 6 1
|
||||
> J 1 8
|
||||
> (K) 0
|
||||
> L 4 1
|
||||
> LL 1 8
|
||||
> M 2 3
|
||||
> N 5 1
|
||||
> N tilde 1 8
|
||||
> O 9 1
|
||||
> P 2 3
|
||||
> Q 1 5
|
||||
> R 5 1
|
||||
> RR 1 8
|
||||
> S 6 1
|
||||
> T 4 1
|
||||
> U 5 1
|
||||
> V 1 4
|
||||
> (W) 0
|
||||
> X 1 8
|
||||
> Y 1 4
|
||||
> Z 1 10
|
||||
> BLANK 2 0
|
||||
>
|
||||
> Total 100
|
||||
|
||||
> GREEK
|
||||
>
|
||||
> Letter Distribution Face value
|
||||
>
|
||||
> alpha 12 1
|
||||
> beta 1 8
|
||||
> gamma 2 4
|
||||
> delta 2 4
|
||||
> epsilon 8 1
|
||||
> zeta 1 10
|
||||
> eta 7 1
|
||||
> theta 1 10
|
||||
> iota 8 1
|
||||
> kappa 4 2
|
||||
> lambda 3 3
|
||||
> mu 3 3
|
||||
> nu 6 1
|
||||
> xi 1 10
|
||||
> omicron 9 1
|
||||
> pi 4 2
|
||||
> rho 5 2
|
||||
> sigma 7 1
|
||||
> tau 8 1
|
||||
> upsilon 4 2
|
||||
> phi 1 8
|
||||
> chi 1 8
|
||||
> psi 1 10
|
||||
> omega 3 3
|
||||
> blank 2 0
|
||||
>
|
||||
> Total 104
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
unsigned char finnish_table[] = {
|
||||
#if 0
|
||||
from yarik@avalon.merikoski.fi
|
||||
amount points letter
|
||||
10 1 A
|
||||
1 8 B
|
||||
1 10 C
|
||||
1 7 D
|
||||
8 1 E
|
||||
1 8 F
|
||||
1 8 G
|
||||
2 4 H
|
||||
10 1 I
|
||||
2 4 J
|
||||
5 2 K
|
||||
5 2 L
|
||||
3 3 M
|
||||
8 1 N
|
||||
5 2 O
|
||||
2 4 P
|
||||
2 4 R
|
||||
7 1 S
|
||||
9 1 T
|
||||
5 3 U
|
||||
2 4 V
|
||||
2 4 Y
|
||||
5 2 D // an A with two dots above
|
||||
1 7 V // an O with two dots above
|
||||
2 ? ? // the 'wild card'
|
||||
#endif
|
||||
};
|
||||
|
||||
unsigned char US_english_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(9, 1), 'A',
|
||||
MASH(2, 3), 'B',
|
||||
MASH(2, 3), 'C',
|
||||
MASH(4, 2), 'D',
|
||||
MASH(12, 1), 'E',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(3, 2), 'G',
|
||||
MASH(2, 4), 'H',
|
||||
MASH(9, 1), 'I',
|
||||
MASH(1, 8), 'J',
|
||||
MASH(1, 5), 'K',
|
||||
MASH(4, 1), 'L',
|
||||
MASH(2, 3), 'M',
|
||||
MASH(6, 1), 'N',
|
||||
MASH(8, 1), 'O',
|
||||
MASH(2, 3), 'P',
|
||||
MASH(1, 10), 'Q',
|
||||
MASH(6, 1), 'R',
|
||||
MASH(4, 1), 'S',
|
||||
MASH(6, 1), 'T',
|
||||
MASH(4, 1), 'U',
|
||||
MASH(2, 4), 'V',
|
||||
MASH(2, 4), 'W',
|
||||
MASH(1, 8), 'X',
|
||||
MASH(2, 4), 'Y',
|
||||
MASH(1, 10), 'Z',
|
||||
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // US_english_table
|
||||
|
||||
unsigned char norwegian_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(7, 1), 'A',
|
||||
MASH(3, 4), 'B',
|
||||
MASH(1, 10), 'C',
|
||||
MASH(5, 1), 'D',
|
||||
MASH(9, 1), 'E',
|
||||
MASH(4, 2), 'F',
|
||||
MASH(4, 2), 'G',
|
||||
MASH(3, 3), 'H',
|
||||
MASH(5, 1), 'I',
|
||||
MASH(2, 4), 'J',
|
||||
MASH(4, 2), 'K',
|
||||
MASH(5, 1), 'L',
|
||||
MASH(3, 2), 'M',
|
||||
MASH(6, 1), 'N',
|
||||
MASH(4, 2), 'O',
|
||||
MASH(2, 4), 'P',
|
||||
MASH(6, 1), 'R',
|
||||
MASH(6, 1), 'S',
|
||||
MASH(6, 1), 'T',
|
||||
MASH(3, 4), 'U',
|
||||
MASH(3, 4), 'V',
|
||||
MASH(1, 8), 'W',
|
||||
MASH(1, 6), 'Y',
|
||||
MASH(1, 6), 'Æ',
|
||||
MASH(2, 5), 'Ø',
|
||||
MASH(2, 4), 'Å',
|
||||
};
|
||||
|
||||
unsigned char swedish_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(8, 1), 'A',
|
||||
MASH(2, 4), 'Å', // A with circle
|
||||
MASH(2, 3), 'Ä', // A with two dots
|
||||
MASH(2, 4), 'B',
|
||||
MASH(1, 10), 'C',
|
||||
MASH(5, 1), 'D',
|
||||
MASH(7, 1), 'E', // 15's the max....
|
||||
MASH(2, 3), 'F',
|
||||
MASH(3, 2), 'G',
|
||||
MASH(2, 2), 'H',
|
||||
MASH(5, 1), 'I',
|
||||
MASH(1, 7), 'J',
|
||||
MASH(3, 2), 'K',
|
||||
MASH(5, 1), 'L',
|
||||
MASH(3, 2), 'M',
|
||||
MASH(6, 1), 'N',
|
||||
MASH(5, 2), 'O',
|
||||
MASH(2, 4), 'Ö', // O with two dots
|
||||
MASH(2, 4), 'P',
|
||||
MASH(8, 1), 'R',
|
||||
MASH(8, 1), 'S',
|
||||
MASH(8, 1), 'T',
|
||||
MASH(3, 4), 'U',
|
||||
MASH(2, 3), 'V',
|
||||
MASH(1, 8), 'X',
|
||||
MASH(1, 7), 'Y',
|
||||
MASH(1, 8), 'Z',
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // swedish_table
|
||||
|
||||
unsigned char polish_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
// NO BLANK; there are already 32 tiles....
|
||||
// MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(8, 1), 'A',
|
||||
MASH(1, 5), '¡',
|
||||
MASH(2, 3), 'B',
|
||||
MASH(3, 2), 'C',
|
||||
MASH(1, 6), 'Æ',
|
||||
MASH(3, 2), 'D',
|
||||
MASH(7, 1), 'E',
|
||||
MASH(1, 5), 'Ê',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(2, 3), 'G',
|
||||
MASH(2, 3), 'H',
|
||||
MASH(8, 1), 'I',
|
||||
MASH(2, 3), 'J',
|
||||
MASH(3, 2), 'K',
|
||||
MASH(3, 2), 'L',
|
||||
MASH(2, 3), '£',
|
||||
MASH(3, 2), 'M',
|
||||
MASH(5, 1), 'N',
|
||||
MASH(1, 7), 'Ñ',
|
||||
MASH(6, 1), 'O',
|
||||
MASH(1, 5), 'Ó',
|
||||
MASH(3, 2), 'P',
|
||||
MASH(4, 1), 'R',
|
||||
MASH(4, 1), 'S',
|
||||
MASH(1, 5), '¦',
|
||||
MASH(3, 2), 'T',
|
||||
MASH(2, 3), 'U',
|
||||
MASH(4, 1), 'W',
|
||||
MASH(4, 2), 'Y',
|
||||
MASH(5, 1), 'Z',
|
||||
MASH(1, 7), '¬',
|
||||
MASH(1, 5), '¯',
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // polish_table
|
||||
|
||||
unsigned char french_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(9, 1), 'A',
|
||||
MASH(2, 3), 'B',
|
||||
MASH(2, 3), 'C',
|
||||
MASH(3, 2), 'D',
|
||||
MASH(15, 1), 'E',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(2, 2), 'G',
|
||||
MASH(2, 4), 'H',
|
||||
MASH(8, 1), 'I',
|
||||
MASH(1, 8), 'J',
|
||||
MASH(1, 10), 'K',
|
||||
MASH(5, 1), 'L',
|
||||
MASH(3, 2), 'M',
|
||||
MASH(6, 1), 'N',
|
||||
MASH(6, 1), 'O',
|
||||
MASH(2, 3), 'P',
|
||||
MASH(1, 8), 'Q',
|
||||
MASH(6, 1), 'R',
|
||||
MASH(6, 1), 'S',
|
||||
MASH(6, 1), 'T',
|
||||
MASH(6, 1), 'U',
|
||||
MASH(2, 4), 'V',
|
||||
MASH(1, 10), 'W',
|
||||
MASH(1, 10), 'X',
|
||||
MASH(1, 10), 'Y',
|
||||
MASH(1, 10), 'Z',
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // french_table
|
||||
|
||||
unsigned char german_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(5, 1), 'A',
|
||||
MASH(1, 6), 196, // A mit umlaut
|
||||
MASH(2, 3), 'B',
|
||||
MASH(2, 4), 'C',
|
||||
MASH(4, 1), 'D',
|
||||
MASH(15, 1), 'E',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(3, 2), 'G',
|
||||
MASH(4, 2), 'H',
|
||||
MASH(6, 1), 'I',
|
||||
MASH(1, 6), 'J',
|
||||
MASH(2, 4), 'K',
|
||||
MASH(3, 2), 'L',
|
||||
MASH(4, 3), 'M',
|
||||
MASH(9, 1), 'N',
|
||||
MASH(3, 2), 'O',
|
||||
MASH(1, 8), 214, // O mit umlaut
|
||||
MASH(1, 4), 'P',
|
||||
MASH(1, 10), 'Q',
|
||||
MASH(6, 1), 'R',
|
||||
MASH(7, 1), 'S',
|
||||
MASH(6, 1), 'T',
|
||||
MASH(6, 1), 'U',
|
||||
MASH(1, 6), 220, // U mit umlaut
|
||||
MASH(1, 6), 'V',
|
||||
MASH(1, 3), 'W',
|
||||
MASH(1, 8), 'X',
|
||||
MASH(1, 10), 'Y',
|
||||
MASH(1, 3), 'Z',
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // german_table
|
||||
|
||||
unsigned char dutch_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(6, 1), 'A',
|
||||
MASH(2, 3), 'B',
|
||||
MASH(2, 5), 'C',
|
||||
MASH(5, 2), 'D',
|
||||
MASH(16, 1), 'E',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(2, 3), 'G',
|
||||
MASH(2, 4), 'H',
|
||||
MASH(4, 1), 'I',
|
||||
MASH(2, 4), 'J',
|
||||
MASH(3, 3), 'K',
|
||||
MASH(3, 3), 'L',
|
||||
MASH(3, 3), 'M',
|
||||
MASH(8, 1), 'N',
|
||||
MASH(6, 1), 'O',
|
||||
MASH(3, 3), 'P',
|
||||
MASH(1, 10), 'Q',
|
||||
MASH(5, 2), 'R',
|
||||
MASH(5, 2), 'S',
|
||||
MASH(5, 2), 'T',
|
||||
MASH(4, 4), 'U',
|
||||
MASH(4, 2), 'V',
|
||||
MASH(2, 5), 'W',
|
||||
MASH(1, 8), 'X',
|
||||
MASH(2, 4), 'Y',
|
||||
MASH(2, 4), 'Z',
|
||||
//0 /* TERMINATES ARRAY */
|
||||
}; // dutch_table
|
||||
|
||||
unsigned char italian_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(2, 0), BLANK_FACE, /* BLANK1 */
|
||||
MASH(13, 1), 'A',
|
||||
MASH(3, 5), 'B',
|
||||
MASH(4, 4), 'C',
|
||||
MASH(3, 5), 'D',
|
||||
MASH(13, 1), 'E',
|
||||
MASH(2, 8), 'F',
|
||||
MASH(2, 5), 'G',
|
||||
MASH(2, 8), 'H',
|
||||
MASH(13, 1), 'I',
|
||||
MASH(5, 3), 'L',
|
||||
MASH(5, 3), 'M',
|
||||
MASH(6, 2), 'N',
|
||||
MASH(13, 1), 'O',
|
||||
MASH(3, 5), 'P',
|
||||
MASH(1, 10), 'Q',
|
||||
MASH(6, 2), 'R',
|
||||
MASH(6, 2), 'S',
|
||||
MASH(6, 2), 'T',
|
||||
MASH(5, 3), 'U',
|
||||
MASH(4, 4), 'V',
|
||||
MASH(2, 8), 'Z',
|
||||
// 0 /* TERMINATES ARRAY */
|
||||
}; // italian_table
|
||||
|
||||
unsigned char spanish_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH( 12, 1), 'A',
|
||||
MASH( 2, 3), 'B',
|
||||
MASH( 4, 3), 'C',
|
||||
MASH( 1, 5), 1, /*'CH'*/
|
||||
MASH( 5, 2), 'D',
|
||||
MASH( 12, 1), 'E',
|
||||
MASH( 1, 4), 'F',
|
||||
MASH( 2, 2), 'G',
|
||||
MASH( 2, 4), 'H',
|
||||
MASH( 6, 1), 'I',
|
||||
MASH( 1, 8), 'J',
|
||||
MASH( 4, 1), 'L',
|
||||
MASH( 1, 8), 2, /*'LL'*/
|
||||
MASH( 2, 3), 'M',
|
||||
MASH( 5, 1), 'N',
|
||||
MASH( 1, 8), 209, /*'N~'*/
|
||||
MASH( 9, 1), 'O',
|
||||
MASH( 2, 3), 'P',
|
||||
MASH( 1, 5), 'Q',
|
||||
MASH( 5, 1), 'R',
|
||||
MASH( 1, 8), 3, /*'RR'*/
|
||||
MASH( 6, 1), 'S',
|
||||
MASH( 4, 1), 'T',
|
||||
MASH( 5, 1), 'U',
|
||||
MASH( 1, 4), 'V',
|
||||
MASH( 1, 8), 'X',
|
||||
MASH( 1, 4), 'Y',
|
||||
MASH( 1, 10), 'Z',
|
||||
MASH( 2, 0), BLANK_FACE, /* BLANK1 */
|
||||
}; // spanish_table
|
||||
|
||||
/* Test case that reverses char order and puts blank at the end, violating the
|
||||
* sometimes-assumption that blank==0. */
|
||||
unsigned char hex_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(9, 1), 'A',
|
||||
MASH(2, 3), 'B',
|
||||
MASH(2, 3), 'C',
|
||||
MASH(4, 2), 'D',
|
||||
MASH(12, 1), 'E',
|
||||
MASH(2, 4), 'F',
|
||||
MASH(4, 0), BLANK_FACE, /* BLANK1 */
|
||||
//0 /* TERMINATES ARRAY */
|
||||
}; // hex_table
|
||||
|
||||
unsigned char test_table[] = {
|
||||
// numTiles, tileValue ASCII value
|
||||
MASH(1, 1), 'A',
|
||||
MASH(1, 5), 'B',
|
||||
MASH(1, 10), 'E',
|
||||
//0 /* TERMINATES ARRAY */
|
||||
}; // test_table
|
||||
|
||||
//#define NONFILEARGS 3
|
||||
#define MAXSPECIALS 20
|
||||
|
||||
int main( int argc, char** argv ) {
|
||||
char* lang = NULL;
|
||||
// char* fileName;
|
||||
char* facesFileName = NULL;
|
||||
char* binaryFileName = NULL;
|
||||
|
||||
FILE* facesFile;
|
||||
FILE* binFile;
|
||||
Xloc_header header;
|
||||
unsigned char* table;
|
||||
short tableLength = 0;
|
||||
//char* name = "";
|
||||
short i;
|
||||
short fileArgsUsed;
|
||||
short offset;
|
||||
int got;
|
||||
|
||||
while ( (got = getopt(argc, argv, "l:O:T:h")) != EOF ) {
|
||||
switch ( got ) {
|
||||
case 'l':
|
||||
lang = optarg;
|
||||
break;
|
||||
case 'O':
|
||||
facesFileName = optarg;
|
||||
break;
|
||||
case 'T':
|
||||
binaryFileName = optarg;
|
||||
break;
|
||||
case 'h':
|
||||
default:
|
||||
errexit( "Usage: xloc -l lang_code "
|
||||
"-O tableOutfile -T valCountOutfile\n" );
|
||||
}
|
||||
}
|
||||
|
||||
fprintf( stderr, "binoutfile = %s\n",
|
||||
binaryFileName?binaryFileName:"null" );
|
||||
fprintf( stderr, "facesFileName = %s\n",
|
||||
facesFileName?facesFileName:"null" );
|
||||
fprintf( stderr, "lang = %s\n", lang );
|
||||
|
||||
header.padding = 0;
|
||||
|
||||
if ( strcmp( lang, "en_US" ) == 0 ) {
|
||||
table = US_english_table;
|
||||
tableLength = sizeof(US_english_table);
|
||||
header.langCodeFlags = US_ENGLISH;
|
||||
} else if ( strcmp( lang, "sv_SE" ) == 0 ) {
|
||||
table = swedish_table;
|
||||
tableLength = sizeof(swedish_table);
|
||||
header.langCodeFlags = SWEDISH_SWEDISH;
|
||||
} else if ( strcmp( lang, "no_NO" ) == 0 ) {
|
||||
table = norwegian_table;
|
||||
tableLength = sizeof(norwegian_table);
|
||||
header.langCodeFlags = NORWEGIAN_NORWEGIAN;
|
||||
} else if ( strcmp( lang, "pl_PL" ) == 0 ) {
|
||||
table = polish_table;
|
||||
tableLength = sizeof(polish_table);
|
||||
header.langCodeFlags = POLISH_POLISH;
|
||||
} else if ( strcmp( lang, "fr_FR" ) == 0 ) {
|
||||
table = french_table;
|
||||
tableLength = sizeof(french_table);
|
||||
header.langCodeFlags = FRENCH_FRENCH;
|
||||
} else if ( strcmp( lang, "de_DE" ) == 0 ) {
|
||||
table = german_table;
|
||||
tableLength = sizeof(german_table);
|
||||
header.langCodeFlags = GERMAN_GERMAN;
|
||||
} else if ( strcmp( lang, "nl_NL" ) == 0 ) {
|
||||
table = dutch_table;
|
||||
tableLength = sizeof(dutch_table);
|
||||
header.langCodeFlags = DUTCH_DUTCH;
|
||||
} else if ( strcmp( lang, "it_IT" ) == 0 ) {
|
||||
table = italian_table;
|
||||
tableLength = sizeof(italian_table);
|
||||
header.langCodeFlags = ITALIAN_ITALIAN;
|
||||
} else if ( strcmp( lang, "es_ES" ) == 0 ) {
|
||||
table = spanish_table;
|
||||
tableLength = sizeof(spanish_table);
|
||||
header.langCodeFlags = SPANISH_SPANISH;
|
||||
} else if ( strcmp( lang, "hex" ) == 0 ) {
|
||||
table = hex_table;
|
||||
tableLength = sizeof(hex_table);
|
||||
} else if ( strcmp( lang, "test" ) == 0 ) {
|
||||
table = test_table;
|
||||
tableLength = sizeof(test_table);
|
||||
} else {
|
||||
fprintf( stderr, "unknown language code %s\n", lang );
|
||||
exit(1);
|
||||
}
|
||||
|
||||
header.langCodeFlags |= 1<<XLOC_LANG_OFFSET;
|
||||
|
||||
////////////////////////////////////////////////////
|
||||
// first the char table file
|
||||
////////////////////////////////////////////////////
|
||||
if ( facesFileName != NULL ) {
|
||||
facesFile = fopen( facesFileName, "w" );
|
||||
assert( facesFile );
|
||||
assert( tableLength > 0 );
|
||||
|
||||
for ( i = 0; i < tableLength; i += BYTES_PER_LETTER ) {
|
||||
fprintf( facesFile, "%c", table[i+2] );
|
||||
}
|
||||
|
||||
fclose( facesFile );
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////
|
||||
// now the binary file
|
||||
////////////////////////////////////////////////////
|
||||
if ( binaryFileName != NULL ) {
|
||||
|
||||
binFile = fopen( binaryFileName, "w" );
|
||||
assert( binFile );
|
||||
|
||||
fwrite( &header, sizeof(header), 1, binFile );
|
||||
|
||||
// now write out the table, where header.specialCharStart is length
|
||||
for ( i = 0; i < tableLength; i += BYTES_PER_LETTER ) {
|
||||
fwrite( &table[i], sizeof(table[i])+sizeof(table[i+1]), 1,
|
||||
binFile );
|
||||
}
|
||||
|
||||
// record file sizes
|
||||
|
||||
// write data with file size included
|
||||
|
||||
// append the files themselves
|
||||
|
||||
fclose( binFile );
|
||||
}
|
||||
return 0;
|
||||
} // main
|
||||
42
xwords4/xwords4/dawg/xloc.pl
Executable file
42
xwords4/xwords4/dawg/xloc.pl
Executable file
|
|
@ -0,0 +1,42 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
# test and wrapper file for xloc.pm
|
||||
|
||||
use strict;
|
||||
use xloc;
|
||||
|
||||
|
||||
|
||||
my $arg = shift(@ARGV);
|
||||
my $lang = shift(@ARGV);
|
||||
my $path = "./$lang";
|
||||
my $infoFile = "$path/info.txt";
|
||||
|
||||
die "info file $infoFile not found\n" if ! -s $infoFile;
|
||||
|
||||
|
||||
my $xlocToken = xloc::ParseTileInfo($infoFile);
|
||||
|
||||
if ( $arg eq "-t" ) {
|
||||
xloc::WriteMapFile( $xlocToken, 0, \*STDOUT );
|
||||
} elsif ( $arg eq "-tn" ) {
|
||||
xloc::WriteMapFile( $xlocToken, 1, \*STDOUT );
|
||||
} elsif ( $arg eq "-v" ) {
|
||||
xloc::WriteValuesFile( $xlocToken, \*STDOUT );
|
||||
}
|
||||
180
xwords4/xwords4/dawg/xloc.pm
Normal file
180
xwords4/xwords4/dawg/xloc.pm
Normal file
|
|
@ -0,0 +1,180 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# Copyright 2002 by Eric House (fixin@peak.org). All rights reserved.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# as published by the Free Software Foundation; either version 2
|
||||
# of the License, or (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
# The idea here is that all that matters about a language is stored in
|
||||
# one file (possibly excepting rules for prepping a dictionary).
|
||||
# There's a list of tile faces, counts and values, and also some
|
||||
# name-value pairs as needed. The pairs come first, and then a list
|
||||
# of tiles.
|
||||
|
||||
package xloc;
|
||||
|
||||
use strict;
|
||||
use warnings;
|
||||
|
||||
BEGIN {
|
||||
use Exporter ();
|
||||
our ($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
|
||||
|
||||
$VERSION = 1.00;
|
||||
|
||||
@ISA = qw(Exporter);
|
||||
@EXPORT = qw(&ParseTileInfo &GetNTiles &TileFace &TileValue
|
||||
&TileCount &GetValue &WriteMapFile &WriteValuesFile);
|
||||
%EXPORT_TAGS = ( );
|
||||
}
|
||||
|
||||
# Returns what's meant to be an opaque object that can be passed back
|
||||
# for queries. It's a hash with name-value pairs and an _INFO entry
|
||||
# containing a list of tile info lists.
|
||||
|
||||
sub ParseTileInfo($) {
|
||||
my ( $filePath ) = @_;
|
||||
my %result;
|
||||
|
||||
open INPUT, "<$filePath" or die "couldn't open $filePath";
|
||||
|
||||
my $inTiles = 0;
|
||||
my @tiles;
|
||||
while ( <INPUT> ) {
|
||||
|
||||
chomp;
|
||||
s/\#.*$//;
|
||||
s/^\s*$//; # nuke all-white-space lines
|
||||
next if !length;
|
||||
|
||||
if ( $inTiles ) {
|
||||
if ( /<END_TILES>/ ) {
|
||||
last;
|
||||
} else {
|
||||
my ( $count, $val, $face ) = m/^\s*(\w+)\s+(\w+)\s+(.*)\s*$/;
|
||||
push @tiles, [ $count, $val, $face ];
|
||||
}
|
||||
} elsif ( /\w:/ ) {
|
||||
my ( $nam, $val ) = split ':', $_, 2;
|
||||
$result{$nam} .= $val;
|
||||
} elsif ( /<BEGIN_TILES>/ ) {
|
||||
$inTiles = 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
close INPUT;
|
||||
|
||||
$result{"_TILES"} = [ @tiles ];
|
||||
|
||||
return \%result;
|
||||
}
|
||||
|
||||
sub GetNTiles($) {
|
||||
my ( $hashR ) = @_;
|
||||
|
||||
my $listR = ${$hashR}{"_TILES"};
|
||||
|
||||
return 0 + @{$listR};
|
||||
}
|
||||
|
||||
sub GetValue($$) {
|
||||
my ( $hashR, $name ) = @_;
|
||||
return ${$hashR}{$name};
|
||||
}
|
||||
|
||||
sub WriteMapFile($$$) {
|
||||
my ( $hashR, $unicode, $fhr ) = @_;
|
||||
|
||||
my $packStr;
|
||||
if ( $unicode ) {
|
||||
$packStr = "n";
|
||||
} else {
|
||||
$packStr = "C";
|
||||
}
|
||||
|
||||
my $count = GetNTiles($hashR);
|
||||
my $specialCount = 0;
|
||||
for ( my $i = 0; $i < $count; ++$i ) {
|
||||
my $tileR = GetNthTile( $hashR, $i );
|
||||
my $str = ${$tileR}[2];
|
||||
|
||||
if ( $str =~ /\'(.)\'/ ) {
|
||||
print $fhr pack($packStr, ord($1) );
|
||||
} elsif ( $str =~ /\"(.+)\"/ ) {
|
||||
print $fhr pack($packStr, $specialCount++ );
|
||||
} elsif ( $str =~ /(\d+)/ ) {
|
||||
print $fhr pack( $packStr, chr($1) );
|
||||
} else {
|
||||
die "WriteMapFile: unrecognized face format $str";
|
||||
}
|
||||
}
|
||||
} # WriteMapFile
|
||||
|
||||
sub WriteValuesFile($$) {
|
||||
my ( $hashR, $fhr ) = @_;
|
||||
|
||||
my $header = GetValue( $hashR,"XLOC_HEADER" );
|
||||
die "no XLOC_HEADER found" if ! $header;
|
||||
|
||||
print STDERR "header is $header\n";
|
||||
|
||||
print $fhr pack( "n", hex($header) );
|
||||
|
||||
my $count = GetNTiles($hashR);
|
||||
for ( my $i = 0; $i < $count; ++$i ) {
|
||||
my $tileR = GetNthTile( $hashR, $i );
|
||||
|
||||
print $fhr pack( "c", TileValue($tileR) );
|
||||
print $fhr pack( "c", TileCount($tileR) );
|
||||
}
|
||||
|
||||
} # WriteValuesFile
|
||||
|
||||
sub GetNthTile($$) {
|
||||
my ( $hashR, $n ) = @_;
|
||||
my $listR = ${$hashR}{"_TILES"};
|
||||
|
||||
return ${$listR}[$n];
|
||||
}
|
||||
|
||||
sub TileFace($) {
|
||||
my ( $tileR ) = @_;
|
||||
|
||||
my $str = ${$tileR}[2];
|
||||
|
||||
if ( $str =~ /\'(.)\'/ ) {
|
||||
return $1;
|
||||
} elsif ( $str =~ /\"(.+)\"/ ) {
|
||||
return $1;
|
||||
} elsif ( $str =~ /(\d+)/ ) {
|
||||
return chr($1);
|
||||
} else {
|
||||
die "TileFace: unrecognized face format: $str";
|
||||
}
|
||||
}
|
||||
|
||||
sub TileValue($) {
|
||||
my ( $tileR ) = @_;
|
||||
|
||||
return ${$tileR}[0];
|
||||
}
|
||||
|
||||
sub TileCount($) {
|
||||
my ( $tileR ) = @_;
|
||||
|
||||
return ${$tileR}[1];
|
||||
}
|
||||
|
||||
1;
|
||||
132
xwords4/xwords4/dawg/xwcommon3.h
Normal file
132
xwords4/xwords4/dawg/xwcommon3.h
Normal file
|
|
@ -0,0 +1,132 @@
|
|||
// -*-mode: C; fill-column: 80; -*-
|
||||
|
||||
/*
|
||||
* Copyright 1997 by Eric House (fixin@peak.org). All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
#ifndef __XWCOMMON__
|
||||
#define __XWCOMMON__
|
||||
|
||||
//#include <Hardware/Hardware.h>
|
||||
// so sue me :-)
|
||||
//#include "/home/pilot/usr/local/gnu/m68k-palmos-coff/include/PalmOS2/Hardware/Hardware.h"
|
||||
|
||||
enum { BLANK=0,
|
||||
EMPTY = 32,
|
||||
DOUBLE_LETTER,
|
||||
DOUBLE_WORD,
|
||||
TRIPLE_LETTER,
|
||||
TRIPLE_WORD
|
||||
};
|
||||
|
||||
// a single-width diagonal stripe
|
||||
#define PAT_DOUBLE_LETTER { 0x8844, 0x2211, 0x8844, 0x2211 }
|
||||
// a double-width diagonal stripe
|
||||
#define PAT_DOUBLE_WORD { 0xaa55, 0xaa55, 0xaa55, 0xaa55 }
|
||||
// grey pattern (single-pixel checkboard)
|
||||
#define PAT_TRIPLE_LETTER { 0xCC66, 0x3399, 0xCC66, 0x3399 }
|
||||
// 2-pixel checkboard
|
||||
#define PAT_TRIPLE_WORD { 0xCCCC, 0x3333, 0xCCCC, 0x3333 }
|
||||
|
||||
|
||||
#define BOARD_RES_TYPE 'Xbrd'
|
||||
#define TILES_RES_TYPE 'Xloc'
|
||||
#define STRL_RES_TYPE 'StrL'
|
||||
#define XW_STRL_RESOURCE_ID 1000
|
||||
// both the above resources use this ID
|
||||
#define XW_CONFIGABLE_RESOURCE_ID 1001
|
||||
|
||||
#define BYTES_PER_LETTER 3
|
||||
|
||||
#define BLANK_FACE '\0'
|
||||
//#define A_TILE 1
|
||||
#define A_TILE 0
|
||||
|
||||
#define MAX_NUM_TILES 110
|
||||
#define MAX_UNIQUE_TILES (32-A_TILE)
|
||||
//b#define NUM_BLANKS 2
|
||||
#define MAX_NUM_BLANKS 4
|
||||
|
||||
/* language header:
|
||||
* specialCharStart simply gives the number of bytes needed to skip beyond the
|
||||
* standard tiles table to the first of the "special" entries.
|
||||
*
|
||||
* langCodeFlags is more ambitious. Each language I release will have an
|
||||
* assigned code. The code has a least two purposes: to prevent viewing a game
|
||||
* with the wrong language; and to tie a language to the dictionary that can be
|
||||
* used by the computer player.
|
||||
*
|
||||
* For a dictionary and language (set of tile rules) to work together, the
|
||||
* mapping of index to character must be in sync. In the German case, 0 must be
|
||||
* A, 1 umlaut-A, etc. But the number of characters and values assigned each
|
||||
* tile do not matter. Thus XWConfig can allow those aspects of a language to
|
||||
* be edited. but if a user wants to add or delete a character in an "official"
|
||||
* language XWConfig must disallow this, forcing him instead to "clone" the
|
||||
* language to something whose offical flag will be cleared.
|
||||
*/
|
||||
|
||||
typedef struct Xloc_header {
|
||||
//unsigned char specialCharStart;
|
||||
unsigned char langCodeFlags; // can't do bitfields; gcc for pilot and x86
|
||||
// seem to generate different code
|
||||
unsigned char padding; // ptrs to the shorts in Xloc_specialEntry
|
||||
// will otherwise be odd
|
||||
} Xloc_header;
|
||||
|
||||
#define XLOC_LANG_MASK 0x80 // high bit is "official"
|
||||
#define XLOC_LANG_OFFSET 7
|
||||
#define XLOC_OFFICIAL_MASK 0x7F // rest are for the enums below
|
||||
|
||||
enum {
|
||||
HOMEBREW = 0,
|
||||
US_ENGLISH = 1,
|
||||
FRENCH_FRENCH = 2,
|
||||
GERMAN_GERMAN = 3,
|
||||
DUTCH_DUTCH = 4,
|
||||
ITALIAN_ITALIAN = 5,
|
||||
SPANISH_SPANISH = 6,
|
||||
SWEDISH_SWEDISH = 7,
|
||||
POLISH_POLISH = 8,
|
||||
NORWEGIAN_NORWEGIAN = 9,
|
||||
};
|
||||
|
||||
/* "Special chars", added to support Spanish "LL" and "RR", replace
|
||||
* the ascii character code in the Xloc charinfo array with an integer
|
||||
* between 1 and 0X1F which is an index into an larger array appended
|
||||
* to the charinfo array. Fields in the structs located in that array
|
||||
* include the string to be used to represent the Tile when drawing in
|
||||
* text (e.g. formatting for the Tile values dialog) and the IDs of
|
||||
* resources holding bitmaps to be used when drawing tiles large
|
||||
* (tray) and small (board).
|
||||
*/
|
||||
typedef struct Xloc_specialEntry {
|
||||
unsigned char textVersion[4]; /* string can be up to 3 chars long */
|
||||
short hasLarge;
|
||||
short hasSmall;
|
||||
} Xloc_specialEntry;
|
||||
|
||||
|
||||
|
||||
|
||||
/* #define LARGE_CH_BMP_ID 2000 */
|
||||
/* #define SMALL_CH_BMP_ID 2001 */
|
||||
/* #define LARGE_LL_BMP_ID 2002 */
|
||||
/* #define SMALL_LL_BMP_ID 2003 */
|
||||
/* #define LARGE_RR_BMP_ID 2004 */
|
||||
/* #define SMALL_RR_BMP_ID 2005 */
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue