Changeset e7de6cc


Ignore:
Timestamp:
02/21/12 20:02:51 (13 years ago)
Author:
Tomasz Obrebski <to@…>
Branches:
master
Children:
b242df2
Parents:
354ba3d
git-author:
Tomasz Obrebski <to@…> (02/21/12 20:02:51)
git-committer:
Tomasz Obrebski <to@…> (02/21/12 20:02:51)
Message:

new version of dgp
added dgc, tre and compdic components
compiledic renamed to compdic_utf8
./configure updated

Files:
33 added
17 edited
11 moved

Legend:

Unmodified
Added
Removed

  • Makefile

    rcfdf333 re7de6cc  
    4141# ------------------------------------------------------------------ 
    4242.PHONY: clean 
    43 clean: clean_components clean_documentation clean_config 
     43clean: clean_components clean_documentation clean_config clean_config_mak 
    4444        @echo "All files cleaned successfully!" 
    4545 
    … …  
    5858clean_config: 
    5959        cd $(CUR_DIR)/conf && make clean; cd $(CUR_DIR) 
     60 
     61.PHONY: clean_config_mak 
     62clean_config_mak: 
     63        rm config.mak || true 
    6064 
    6165# ------------------------------------------------------------------ 

  • configure

    rac25afd re7de6cc  
    99 
    1010# list of components to compile 
    11 CMPLIST="compiledic cor dgp fla gph grp gue kon kor kot lem mar rm12 rs12 sen sen-nl ser tags tok.c tok.l tok.pl unfla" 
     11CMPLIST="compdic cor dgc dgp fla gph grp gue kon kor kot lem mar rm12 rs12 sen sen-nl ser tags tok.c tok.l tok.pl tre unfla" 
    1212COMP= 
    1313 

  • share/cats.dgc

    r5f4d9c3 re7de6cc  
    1 ADJ/DcNpCaGp 
    2 ADJ/DcNpCd 
    3 ADJ/DcNpCgl 
    4 ADJ/DcNpCi 
    5 ADJ/DcNpCnavGaifn 
    6 ADJ/DcNpCnvGp 
    7 ADJ/DcNsCaGi 
    8 ADJ/DcNsCaGpa 
    9 ADJ/DcNsCaiGf 
    10 ADJ/DcNsCavGf 
    11 ADJ/DcNsCdGpain 
    12 ADJ/DcNsCgdlGf 
    13 ADJ/DcNsCgGpain 
    14 ADJ/DcNsCilGpain 
    15 ADJ/DcNsCnavGn 
    16 ADJ/DcNsCnvGpai 
    17 ADJ/DpNpCaGp 
    18 ADJ/DpNpCd 
    19 ADJ/DpNpCgl 
    20 ADJ/DpNpCi 
    21 ADJ/DpNpCnavGaifn 
    22 ADJ/DpNpCnvGp 
    23 ADJ/DpNsCaGi 
    24 ADJ/DpNsCaGpa 
    25 ADJ/DpNsCaiGf 
    26 ADJ/DpNsCavGf 
    27 ADJ/DpNsCdGpain 
    28 ADJ/DpNsCgdlGf 
    29 ADJ/DpNsCgGpain 
    30 ADJ/DpNsCilGpain 
    31 ADJ/DpNsCnavGn 
    32 ADJ/DpNsCnvGpai 
    33 ADJ/DsNpCaGp 
    34 ADJ/DsNpCd 
    35 ADJ/DsNpCgl 
    36 ADJ/DsNpCi 
    37 ADJ/DsNpCnavGaifn 
    38 ADJ/DsNpCnvGp 
    39 ADJ/DsNsCaGi 
    40 ADJ/DsNsCaGpa 
    41 ADJ/DsNsCaiGf 
    42 ADJ/DsNsCavGf 
    43 ADJ/DsNsCdGpain 
    44 ADJ/DsNsCgdlGf 
    45 ADJ/DsNsCgGpain 
    46 ADJ/DsNsCilGpain 
    47 ADJ/DsNsCnavGn 
    48 ADJ/DsNsCnvGpai 
    49 ADJNUM/NpCaGp 
    50 ADJNUM/NpCd 
    51 ADJNUM/NpCgl 
    52 ADJNUM/NpCi 
    53 ADJNUM/NpCnavGaifn 
    54 ADJNUM/NpCnvGp 
    55 ADJNUM/NsCaGi 
    56 ADJNUM/NsCaGpa 
    57 ADJNUM/NsCaiGf 
    58 ADJNUM/NsCavGf 
    59 ADJNUM/NsCdGpain 
    60 ADJNUM/NsCgdlGf 
    61 ADJNUM/NsCgGpain 
    62 ADJNUM/NsCilGpain 
    63 ADJNUM/NsCnavGn 
    64 ADJNUM/NsCnvGpai 
    65 ADJPAP/NpCaGp 
    66 ADJPAP/NpCd 
    67 ADJPAP/NpCgl 
    68 ADJPAP/NpCi 
    69 ADJPAP/NpCnavGaifn 
    70 ADJPAP/NpCnvGp 
    71 ADJPAP/NsCaGi 
    72 ADJPAP/NsCaGpa 
    73 ADJPAP/NsCaiGf 
    74 ADJPAP/NsCavGf 
    75 ADJPAP/NsCdGpain 
    76 ADJPAP/NsCgdlGf 
    77 ADJPAP/NsCgGpain 
    78 ADJPAP/NsCilGpain 
    79 ADJPAP/NsCnavGn 
    80 ADJPAP/NsCnvGpai 
    81 ADJPP/NpCaGp 
    82 ADJPP/NpCd 
    83 ADJPP/NpCgl 
    84 ADJPP/NpCi 
    85 ADJPP/NpCnavGaifn 
    86 ADJPP/NpCnvGp 
    87 ADJPP/NsCaGi 
    88 ADJPP/NsCaGpa 
    89 ADJPP/NsCaiGf 
    90 ADJPP/NsCavGf 
    91 ADJPP/NsCdGpain 
    92 ADJPP/NsCgdlGf 
    93 ADJPP/NsCgGpain 
    94 ADJPP/NsCilGpain 
    95 ADJPP/NsCnavGn 
    96 ADJPP/NsCnvGpai 
    97 ADJPRO/NpCaGp 
    98 ADJPRO/NpCd 
    99 ADJPRO/NpCgl 
    100 ADJPRO/NpCi 
    101 ADJPRO/NpCnavGaifn 
    102 ADJPRO/NpCnvGp 
    103 ADJPRO/NsCaGi 
    104 ADJPRO/NsCaGpa 
    105 ADJPRO/NsCaiGf 
    106 ADJPRO/NsCavGf 
    107 ADJPRO/NsCdGpain 
    108 ADJPRO/NsCgdlGf 
    109 ADJPRO/NsCgGpain 
    110 ADJPRO/NsCilGpain 
    111 ADJPRO/NsCnavGn 
    112 ADJPRO/NsCnvGpai 
    113 ADJPRO/ZdNpCaGp 
    114 ADJPRO/ZdNpCd 
    115 ADJPRO/ZdNpCgl 
    116 ADJPRO/ZdNpCi 
    117 ADJPRO/ZdNpCnavGaifn 
    118 ADJPRO/ZdNpCnvGp 
    119 ADJPRO/ZdNsCaGi 
    120 ADJPRO/ZdNsCaGpa 
    121 ADJPRO/ZdNsCaiGf 
    122 ADJPRO/ZdNsCavGf 
    123 ADJPRO/ZdNsCdGpain 
    124 ADJPRO/ZdNsCgdlGf 
    125 ADJPRO/ZdNsCgGpain 
    126 ADJPRO/ZdNsCilGpain 
    127 ADJPRO/ZdNsCnavGn 
    128 ADJPRO/ZdNsCnvGpai 
    129 ADJPRO/ZgNpCaGp 
    130 ADJPRO/ZgNpCd 
    131 ADJPRO/ZgNpCgl 
    132 ADJPRO/ZgNpCi 
    133 ADJPRO/ZgNpCnavGaifn 
    134 ADJPRO/ZgNpCnvGp 
    135 ADJPRO/ZgNsCaGi 
    136 ADJPRO/ZgNsCaGpa 
    137 ADJPRO/ZgNsCaiGf 
    138 ADJPRO/ZgNsCavGf 
    139 ADJPRO/ZgNsCdGpain 
    140 ADJPRO/ZgNsCgdlGf 
    141 ADJPRO/ZgNsCgGpain 
    142 ADJPRO/ZgNsCilGpain 
    143 ADJPRO/ZgNsCnavGn 
    144 ADJPRO/ZgNsCnvGpai 
    145 ADJPRO/ZiNpCaGp 
    146 ADJPRO/ZiNpCd 
    147 ADJPRO/ZiNpCgl 
    148 ADJPRO/ZiNpCi 
    149 ADJPRO/ZiNpCnavGaifn 
    150 ADJPRO/ZiNpCnvGp 
    151 ADJPRO/ZiNsCaGi 
    152 ADJPRO/ZiNsCaGpa 
    153 ADJPRO/ZiNsCaiGf 
    154 ADJPRO/ZiNsCavGf 
    155 ADJPRO/ZiNsCdGpain 
    156 ADJPRO/ZiNsCgdlGf 
    157 ADJPRO/ZiNsCgGpain 
    158 ADJPRO/ZiNsCilGpain 
    159 ADJPRO/ZiNsCnavGn 
    160 ADJPRO/ZiNsCnvGpai 
    161 ADJPRO/ZnNpCaGp 
    162 ADJPRO/ZnNpCd 
    163 ADJPRO/ZnNpCgl 
    164 ADJPRO/ZnNpCi 
    165 ADJPRO/ZnNpCnavGaifn 
    166 ADJPRO/ZnNpCnvGp 
    167 ADJPRO/ZnNsCaGi 
    168 ADJPRO/ZnNsCaGpa 
    169 ADJPRO/ZnNsCaiGf 
    170 ADJPRO/ZnNsCavGf 
    171 ADJPRO/ZnNsCdGpain 
    172 ADJPRO/ZnNsCgdlGf 
    173 ADJPRO/ZnNsCgGpain 
    174 ADJPRO/ZnNsCilGpain 
    175 ADJPRO/ZnNsCnavGn 
    176 ADJPRO/ZnNsCnvGpai 
    177 ADJPRO/ZqNpCaGp 
    178 ADJPRO/ZqNpCd 
    179 ADJPRO/ZqNpCgl 
    180 ADJPRO/ZqNpCi 
    181 ADJPRO/ZqNpCnavGaifn 
    182 ADJPRO/ZqNpCnvGp 
    183 ADJPRO/ZqNsCaGi 
    184 ADJPRO/ZqNsCaGpa 
    185 ADJPRO/ZqNsCaiGf 
    186 ADJPRO/ZqNsCavGf 
    187 ADJPRO/ZqNsCdGpain 
    188 ADJPRO/ZqNsCgdlGf 
    189 ADJPRO/ZqNsCgGpain 
    190 ADJPRO/ZqNsCilGpain 
    191 ADJPRO/ZqNsCnavGn 
    192 ADJPRO/ZqNsCnvGpai 
    193 ADJPRO/ZqrNpCaGp 
    194 ADJPRO/ZqrNpCd 
    195 ADJPRO/ZqrNpCgl 
    196 ADJPRO/ZqrNpCi 
    197 ADJPRO/ZqrNpCnavGaifn 
    198 ADJPRO/ZqrNpCnvGp 
    199 ADJPRO/ZqrNsCaGi 
    200 ADJPRO/ZqrNsCaGpa 
    201 ADJPRO/ZqrNsCaiGf 
    202 ADJPRO/ZqrNsCavGf 
    203 ADJPRO/ZqrNsCdGpain 
    204 ADJPRO/ZqrNsCgdlGf 
    205 ADJPRO/ZqrNsCgGpain 
    206 ADJPRO/ZqrNsCilGpain 
    207 ADJPRO/ZqrNsCnavGn 
    208 ADJPRO/ZqrNsCnvGpai 
    209 ADJPRO/ZsNpCaGp 
    210 ADJPRO/ZsNpCd 
    211 ADJPRO/ZsNpCgl 
    212 ADJPRO/ZsNpCi 
    213 ADJPRO/ZsNpCnavGaifn 
    214 ADJPRO/ZsNpCnvGp 
    215 ADJPRO/ZsNsCaGi 
    216 ADJPRO/ZsNsCaGpa 
    217 ADJPRO/ZsNsCaiGf 
    218 ADJPRO/ZsNsCavGf 
    219 ADJPRO/ZsNsCdGpain 
    220 ADJPRO/ZsNsCgdlGf 
    221 ADJPRO/ZsNsCgGpain 
    222 ADJPRO/ZsNsCilGpain 
    223 ADJPRO/ZsNsCnavGn 
    224 ADJPRO/ZsNsCnvGpai 
    225 ADJPRP/NpCaGp 
    226 ADJPRP/NpCd 
    227 ADJPRP/NpCgl 
    228 ADJPRP/NpCi 
    229 ADJPRP/NpCnavGaifn 
    230 ADJPRP/NpCnvGp 
    231 ADJPRP/NsCaGi 
    232 ADJPRP/NsCaGpa 
    233 ADJPRP/NsCaiGf 
    234 ADJPRP/NsCavGf 
    235 ADJPRP/NsCdGpain 
    236 ADJPRP/NsCgdlGf 
    237 ADJPRP/NsCgGpain 
    238 ADJPRP/NsCilGpain 
    239 ADJPRP/NsCnavGn 
    240 ADJPRP/NsCnvGpai 
     1ADJ/CaDcGapNs 
     2ADJ/CaDcGiNs 
     3ADJ/CaDcGpNp 
     4ADJ/CaDpGapNs 
     5ADJ/CaDpGiNs 
     6ADJ/CaDpGpNp 
     7ADJ/CaDsGapNs 
     8ADJ/CaDsGiNs 
     9ADJ/CaDsGpNp 
     10ADJ/CaiDcGfNs 
     11ADJ/CaiDpGfNs 
     12ADJ/CaiDsGfNs 
     13ADJ/CanvDcGafinNp 
     14ADJ/CanvDcGnNs 
     15ADJ/CanvDpGafinNp 
     16ADJ/CanvDpGfNs 
     17ADJ/CanvDpGnNs 
     18ADJ/CanvDsGafinNp 
     19ADJ/CanvDsGnNs 
     20ADJ/CavDcGfNs 
     21ADJ/CavDsGfNs 
     22ADJ/CdDcGainpNs 
     23ADJ/CdDcNp 
     24ADJ/CdDpGainpNs 
     25ADJ/CdDpNp 
     26ADJ/CdDsGainpNs 
     27ADJ/CdDsNp 
     28ADJ/CdglDcGfNs 
     29ADJ/CdglDpGfNs 
     30ADJ/CdglDsGfNs 
     31ADJ/CgDcGainpNs 
     32ADJ/CgDpGainpNs 
     33ADJ/CgDsGainpNs 
     34ADJ/CglDcNp 
     35ADJ/CglDpNp 
     36ADJ/CglDsNp 
     37ADJ/CiDcNp 
     38ADJ/CiDpNp 
     39ADJ/CiDsNp 
     40ADJ/CilDcGainpNs 
     41ADJ/CilDpGainpNs 
     42ADJ/CilDsGainpNs 
     43ADJ/CnvDcGaipNs 
     44ADJ/CnvDcGpNp 
     45ADJ/CnvDpGaipNs 
     46ADJ/CnvDpGpNp 
     47ADJ/CnvDsGaipNs 
     48ADJ/CnvDsGpNp 
     49ADJNUM/CaGapNs 
     50ADJNUM/CaGiNs 
     51ADJNUM/CaGpNp 
     52ADJNUM/CaiGfNs 
     53ADJNUM/CanvGafinNp 
     54ADJNUM/CanvGnNs 
     55ADJNUM/CdGainpNs 
     56ADJNUM/CdglGfNs 
     57ADJNUM/CdNp 
     58ADJNUM/CgGainpNs 
     59ADJNUM/CglNp 
     60ADJNUM/CilGainpNs 
     61ADJNUM/CiNp 
     62ADJNUM/CnvGaipNs 
     63ADJNUM/CnvGfNs 
     64ADJNUM/CnvGpNp 
     65ADJPAP/CaGapNs 
     66ADJPAP/CaGiNs 
     67ADJPAP/CaGpNp 
     68ADJPAP/CaiGfNs 
     69ADJPAP/CanvGafinNp 
     70ADJPAP/CanvGnNs 
     71ADJPAP/CdGainpNs 
     72ADJPAP/CdglGfNs 
     73ADJPAP/CdNp 
     74ADJPAP/CgGainpNs 
     75ADJPAP/CglNp 
     76ADJPAP/CilGainpNs 
     77ADJPAP/CiNp 
     78ADJPAP/CnvGaipNs 
     79ADJPAP/CnvGfNs 
     80ADJPAP/CnvGpNp 
     81ADJPP/CaGapNs 
     82ADJPP/CaGiNs 
     83ADJPP/CaGpNp 
     84ADJPP/CaiGfNs 
     85ADJPP/CanvGafinNp 
     86ADJPP/CanvGnNs 
     87ADJPP/CdGainpNs 
     88ADJPP/CdglGfNs 
     89ADJPP/CdNp 
     90ADJPP/CgGainpNs 
     91ADJPP/CglNp 
     92ADJPP/CilGainpNs 
     93ADJPP/CiNp 
     94ADJPP/CnvGaipNs 
     95ADJPP/CnvGfNs 
     96ADJPP/CnvGpNp 
     97ADJPRO/CaGapNs 
     98ADJPRO/CaGiNs 
     99ADJPRO/CaGpNp 
     100ADJPRO/CaiGfNs 
     101ADJPRO/CanvGafinNp 
     102ADJPRO/CanvGnNs 
     103ADJPRO/CdGainpNs 
     104ADJPRO/CdglGfNs 
     105ADJPRO/CdNp 
     106ADJPRO/CgGainpNs 
     107ADJPRO/CglNp 
     108ADJPRO/CilGainpNs 
     109ADJPRO/CiNp 
     110ADJPRO/CnvGaipNs 
     111ADJPRO/CnvGfNs 
     112ADJPRO/CnvGpNp 
     113ADJPRP/CaGapNs 
     114ADJPRP/CaGiNs 
     115ADJPRP/CaGpNp 
     116ADJPRP/CaiGfNs 
     117ADJPRP/CanvGafinNp 
     118ADJPRP/CanvGnNs 
     119ADJPRP/CdGainpNs 
     120ADJPRP/CdglGfNs 
     121ADJPRP/CdNp 
     122ADJPRP/CgGainpNs 
     123ADJPRP/CglNp 
     124ADJPRP/CilGainpNs 
     125ADJPRP/CiNp 
     126ADJPRP/CnvGaipNs 
     127ADJPRP/CnvGfNs 
     128ADJPRP/CnvGpNp 
    241129ADVANP 
     130ADVANP/C 
    242131ADV/Dc 
    243132ADV/Dp 
    … …  
    245134ADVNUM 
    246135ADVPRO 
    247 ADVPRO/Zd 
    248 ADVPRO/Zi 
    249 ADVPRO/Zn 
    250 ADVPRO/Zq 
    251 ADVPRO/Zqr 
    252 ADVPRO/Zr 
     136ADVPRO/C 
    253137ADVPRP 
     138ADVPRP/C 
    254139APP 
     140BYC/GafinMcNpP1Vp 
     141BYC/GafinMcNpP2Vp 
     142BYC/GafinMcNpP3Vp 
     143BYC/GafinMdNpP1TaVp 
     144BYC/GafinMdNpP2TaVp 
     145BYC/GafinMdNpP3TaVp 
     146BYC/GaipMcNsP1Vp 
     147BYC/GaipMcNsP2Vp 
     148BYC/GaipMcNsP3Vp 
     149BYC/GaipMdNsP1TaVp 
     150BYC/GaipMdNsP2TaVp 
     151BYC/GaipMdNsP3TaVp 
     152BYC/GfMcNsP1Vp 
     153BYC/GfMcNsP2Vp 
     154BYC/GfMcNsP3Vp 
     155BYC/GfMdNsP1TaVp 
     156BYC/GfMdNsP2TaVp 
     157BYC/GfMdNsP3TaVp 
     158BYC/GnMcNsP3Vp 
     159BYC/GnMdNsP3TaVp 
     160BYC/GpMcNpP1Vp 
     161BYC/GpMcNpP2Vp 
     162BYC/GpMcNpP3Vp 
     163BYC/GpMdNpP1TaVp 
     164BYC/GpMdNpP2TaVp 
     165BYC/GpMdNpP3TaVp 
     166BYC/MdNpP1TfrVp 
     167BYC/MdNpP2TfrVp 
     168BYC/MdNpP3TfrVp 
     169BYC/MdNsP1TfrVp 
     170BYC/MdNsP2TfrVp 
     171BYC/MdNsP3TfrVp 
     172BYC/MiNpP1Vp 
     173BYC/MiNpP2Vp 
     174BYC/MiNsP2Vp 
    255175BYC/Vb 
    256 BYC/VpMcNpP1Gaifn 
    257 BYC/VpMcNpP1Gp 
    258 BYC/VpMcNpP2Gaifn 
    259 BYC/VpMcNpP2Gp 
    260 BYC/VpMcNpP3Gaifn 
    261 BYC/VpMcNpP3Gp 
    262 BYC/VpMcNsP1Gf 
    263 BYC/VpMcNsP1Gpai 
    264 BYC/VpMcNsP2Gf 
    265 BYC/VpMcNsP2Gpai 
    266 BYC/VpMcNsP3Gf 
    267 BYC/VpMcNsP3Gn 
    268 BYC/VpMcNsP3Gpai 
    269 BYC/VpMdTaNpP1Gaifn 
    270 BYC/VpMdTaNpP1Gp 
    271 BYC/VpMdTaNpP2Gaifn 
    272 BYC/VpMdTaNpP2Gp 
    273 BYC/VpMdTaNpP3Gaifn 
    274 BYC/VpMdTaNpP3Gp 
    275 BYC/VpMdTaNsP1Gf 
    276 BYC/VpMdTaNsP1Gpai 
    277 BYC/VpMdTaNsP2Gf 
    278 BYC/VpMdTaNsP2Gpai 
    279 BYC/VpMdTaNsP3Gf 
    280 BYC/VpMdTaNsP3Gn 
    281 BYC/VpMdTaNsP3Gpai 
    282 BYC/VpMdTrfNpP1 
    283 BYC/VpMdTrfNpP2 
    284 BYC/VpMdTrfNpP3 
    285 BYC/VpMdTrfNsP1 
    286 BYC/VpMdTrfNsP2 
    287 BYC/VpMdTrfNsP3 
    288 BYC/VpMiNpP1 
    289 BYC/VpMiNpP2 
    290 BYC/VpMiNsP2 
    291176CONJ 
    292177EXCL 
    293 N/GaNpCa 
    294 N/GaNpCd 
    295 N/GaNpCg 
    296 N/GaNpCi 
    297 N/GaNpCl 
    298 N/GaNpCn 
    299 N/GaNpCv 
    300 N/GaNsCa 
    301 N/GaNsCd 
    302 N/GaNsCg 
    303 N/GaNsCi 
    304 N/GaNsCl 
    305 N/GaNsCn 
    306 N/GaNsCv 
    307 N/GfNpCa 
    308 N/GfNpCd 
    309 N/GfNpCg 
    310 N/GfNpCi 
    311 N/GfNpCl 
    312 N/GfNpCn 
    313 N/GfNpCv 
    314 N/GfNsCa 
    315 N/GfNsCd 
    316 N/GfNsCg 
    317 N/GfNsCi 
    318 N/GfNsCl 
    319 N/GfNsCn 
    320 N/GfNsCv 
    321 N/GiNpCa 
    322 N/GiNpCd 
    323 N/GiNpCg 
    324 N/GiNpCi 
    325 N/GiNpCl 
    326 N/GiNpCn 
    327 N/GiNpCv 
    328 N/GiNsCa 
    329 N/GiNsCd 
    330 N/GiNsCg 
    331 N/GiNsCi 
    332 N/GiNsCl 
    333 N/GiNsCn 
    334 N/GiNsCv 
    335 N/GnNpCa 
    336 N/GnNpCd 
    337 N/GnNpCg 
    338 N/GnNpCi 
    339 N/GnNpCl 
    340 N/GnNpCn 
    341 N/GnNpCv 
    342 N/GnNsCa 
    343 N/GnNsCd 
    344 N/GnNsCg 
    345 N/GnNsCi 
    346 N/GnNsCl 
    347 N/GnNsCn 
    348 N/GnNsCv 
    349 N/G?NpCa 
    350 N/G*NpCa 
    351 N/G?NpCd 
    352 N/G*NpCd 
    353 N/G?NpCg 
    354 N/G*NpCg 
    355 N/G?NpCi 
    356 N/G*NpCi 
    357 N/G?NpCl 
    358 N/G*NpCl 
    359 N/G?NpCn 
    360 N/G*NpCn 
    361 N/G?NpCv 
    362 N/G*NpCv 
    363 N/G?NsCa 
    364 N/G?NsCd 
    365 N/G?NsCg 
    366 N/G?NsCi 
    367 N/G?NsCl 
    368 N/G?NsCn 
    369 N/G?NsCv 
    370 N/GpNpCa 
    371 N/GpNpCd 
    372 N/GpNpCg 
    373 N/GpNpCi 
    374 N/GpNpCl 
    375 N/GpNpCn 
    376 N/GpNpCv 
    377 N/GpNsCa 
    378 N/GpNsCd 
    379 N/GpNsCg 
    380 N/GpNsCi 
    381 N/GpNsCl 
    382 N/GpNsCn 
    383 N/GpNsCv 
    384 NPRO/ZdGnNsCa 
    385 NPRO/ZdGnNsCd 
    386 NPRO/ZdGnNsCg 
    387 NPRO/ZdGnNsCi 
    388 NPRO/ZdGnNsCl 
    389 NPRO/ZdGnNsCn 
    390 NPRO/ZgGnNsCa 
    391 NPRO/ZgGnNsCd 
    392 NPRO/ZgGnNsCg 
    393 NPRO/ZgGnNsCi 
    394 NPRO/ZgGnNsCl 
    395 NPRO/ZgGnNsCn 
    396 NPRO/ZgGpNpCa 
    397 NPRO/ZgGpNpCd 
    398 NPRO/ZgGpNpCg 
    399 NPRO/ZgGpNpCi 
    400 NPRO/ZgGpNpCl 
    401 NPRO/ZgGpNpCn 
    402 NPRO/ZiGnNsCa 
    403 NPRO/ZiGnNsCd 
    404 NPRO/ZiGnNsCg 
    405 NPRO/ZiGnNsCi 
    406 NPRO/ZiGnNsCl 
    407 NPRO/ZiGnNsCn 
    408 NPRO/ZiGpNsCa 
    409 NPRO/ZiGpNsCd 
    410 NPRO/ZiGpNsCg 
    411 NPRO/ZiGpNsCi 
    412 NPRO/ZiGpNsCl 
    413 NPRO/ZiGpNsCn 
    414 NPRO/ZnGnNsCa 
    415 NPRO/ZnGnNsCd 
    416 NPRO/ZnGnNsCg 
    417 NPRO/ZnGnNsCi 
    418 NPRO/ZnGnNsCl 
    419 NPRO/ZnGnNsCn 
    420 NPRO/ZnGpNsCa 
    421 NPRO/ZnGpNsCd 
    422 NPRO/ZnGpNsCg 
    423 NPRO/ZnGpNsCi 
    424 NPRO/ZnGpNsCl 
    425 NPRO/ZnGpNsCn 
    426 NPRO/ZpGaifnNpCa 
    427 NPRO/ZpGaifnNpCd 
    428 NPRO/ZpGaifnNpCg 
    429 NPRO/ZpGaifnNpCi 
    430 NPRO/ZpGaifnNpCl 
    431 NPRO/ZpGaifnNpCn 
    432 NPRO/ZpGfNsCa 
    433 NPRO/ZpGfNsCd 
    434 NPRO/ZpGfNsCg 
    435 NPRO/ZpGfNsCi 
    436 NPRO/ZpGfNsCl 
    437 NPRO/ZpGfNsCn 
    438 NPRO/ZpGnNsCa 
    439 NPRO/ZpGnNsCd 
    440 NPRO/ZpGnNsCg 
    441 NPRO/ZpGnNsCi 
    442 NPRO/ZpGnNsCl 
    443 NPRO/ZpGnNsCn 
    444 NPRO/ZpG*NpCa 
    445 NPRO/ZpG*NpCd 
    446 NPRO/ZpG*NpCg 
    447 NPRO/ZpG*NpCi 
    448 NPRO/ZpG*NpCl 
    449 NPRO/ZpG*NpCn 
    450 NPRO/ZpG*NsCa 
    451 NPRO/ZpG*NsCd 
    452 NPRO/ZpG*NsCg 
    453 NPRO/ZpG*NsCi 
    454 NPRO/ZpG*NsCl 
    455 NPRO/ZpG*NsCn 
    456 NPRO/ZpGpaiNsCa 
    457 NPRO/ZpGpaiNsCd 
    458 NPRO/ZpGpaiNsCg 
    459 NPRO/ZpGpaiNsCi 
    460 NPRO/ZpGpaiNsCl 
    461 NPRO/ZpGpaiNsCn 
    462 NPRO/ZpGpNpCa 
    463 NPRO/ZpGpNpCd 
    464 NPRO/ZpGpNpCg 
    465 NPRO/ZpGpNpCi 
    466 NPRO/ZpGpNpCl 
    467 NPRO/ZpGpNpCn 
    468 NPRO/ZqGnNsCa 
    469 NPRO/ZqGnNsCd 
    470 NPRO/ZqGnNsCg 
    471 NPRO/ZqGnNsCi 
    472 NPRO/ZqGnNsCl 
    473 NPRO/ZqGnNsCn 
    474 NPRO/ZqGpNsCa 
    475 NPRO/ZqGpNsCd 
    476 NPRO/ZqGpNsCg 
    477 NPRO/ZqGpNsCi 
    478 NPRO/ZqGpNsCl 
    479 NPRO/ZqGpNsCn 
    480 NPRO/ZqrGnNsCa 
    481 NPRO/ZqrGnNsCd 
    482 NPRO/ZqrGnNsCg 
    483 NPRO/ZqrGnNsCi 
    484 NPRO/ZqrGnNsCl 
    485 NPRO/ZqrGnNsCn 
    486 NPRO/ZqrGpNsCa 
    487 NPRO/ZqrGpNsCd 
    488 NPRO/ZqrGpNsCg 
    489 NPRO/ZqrGpNsCi 
    490 NPRO/ZqrGpNsCl 
    491 NPRO/ZqrGpNsCn 
    492 NPRO/ZxG*N*Ca 
    493 NPRO/ZxG*N*Cd 
    494 NPRO/ZxG*N*Cg 
    495 NPRO/ZxG*N*Ci 
    496 NPRO/ZxG*N*Cl 
     178N/Ca 
     179N/CaGaNp 
     180N/CaGaNs 
     181N/CaGfNp 
     182N/CaGfNs 
     183N/CaGiNp 
     184N/CaGiNs 
     185N/CaGnNp 
     186N/CaGnNs 
     187N/CaG?Np 
     188N/CaG?Ns 
     189N/CaGpNp 
     190N/CaGpNs 
     191N/CaNp 
     192N/Cd 
     193N/CdGaNp 
     194N/CdGaNs 
     195N/CdGfNp 
     196N/CdGfNs 
     197N/CdGiNp 
     198N/CdGiNs 
     199N/CdGnNp 
     200N/CdGnNs 
     201N/CdG?Np 
     202N/CdG?Ns 
     203N/CdGpNp 
     204N/CdGpNs 
     205N/CdNp 
     206N/Cg 
     207N/CgGaNp 
     208N/CgGaNs 
     209N/CgGfNp 
     210N/CgGfNs 
     211N/CgGiNp 
     212N/CgGiNs 
     213N/CgGnNp 
     214N/CgGnNs 
     215N/CgG?Np 
     216N/CgG?Ns 
     217N/CgGpNp 
     218N/CgGpNs 
     219N/CgNp 
     220N/Ci 
     221N/CiGaNp 
     222N/CiGaNs 
     223N/CiGfNp 
     224N/CiGfNs 
     225N/CiGiNp 
     226N/CiGiNs 
     227N/CiGnNp 
     228N/CiGnNs 
     229N/CiG?Np 
     230N/CiG?Ns 
     231N/CiGpNp 
     232N/CiGpNs 
     233N/CiNp 
     234N/Cl 
     235N/ClGaNp 
     236N/ClGaNs 
     237N/ClGfNp 
     238N/ClGfNs 
     239N/ClGiNp 
     240N/ClGiNs 
     241N/ClGnNp 
     242N/ClGnNs 
     243N/ClG?Np 
     244N/ClG?Ns 
     245N/ClGpNp 
     246N/ClGpNs 
     247N/ClNp 
     248N/Cn 
     249N/CnGaNp 
     250N/CnGaNs 
     251N/CnGfNp 
     252N/CnGfNs 
     253N/CnGiNp 
     254N/CnGiNs 
     255N/CnGnNp 
     256N/CnGnNs 
     257N/CnG?Np 
     258N/CnG?Ns 
     259N/CnGpNp 
     260N/CnGpNs 
     261N/CnNp 
     262N/CvGaNp 
     263N/CvGaNs 
     264N/CvGfNp 
     265N/CvGfNs 
     266N/CvGiNp 
     267N/CvGiNs 
     268N/CvGnNp 
     269N/CvGnNs 
     270N/CvG?Np 
     271N/CvG?Ns 
     272N/CvGpNp 
     273N/CvGpNs 
     274N/CvNp 
     275NPRO/Ca 
     276NPRO/CaGafinNp 
     277NPRO/CaGaipNs 
     278NPRO/CaGfNs 
     279NPRO/CaGnNs 
     280NPRO/CaGpNp 
     281NPRO/CaGpNs 
     282NPRO/CaNp 
     283NPRO/CaNs 
     284NPRO/Cd 
     285NPRO/CdGafinNp 
     286NPRO/CdGaipNs 
     287NPRO/CdGfNs 
     288NPRO/CdGnNs 
     289NPRO/CdGpNp 
     290NPRO/CdGpNs 
     291NPRO/CdNp 
     292NPRO/CdNs 
     293NPRO/Cg 
     294NPRO/CgGafinNp 
     295NPRO/CgGaipNs 
     296NPRO/CgGfNs 
     297NPRO/CgGnNs 
     298NPRO/CgGpNp 
     299NPRO/CgGpNs 
     300NPRO/CgNp 
     301NPRO/CgNs 
     302NPRO/Ci 
     303NPRO/CiGafinNp 
     304NPRO/CiGaipNs 
     305NPRO/CiGfNs 
     306NPRO/CiGnNs 
     307NPRO/CiGpNp 
     308NPRO/CiGpNs 
     309NPRO/CiNp 
     310NPRO/CiNs 
     311NPRO/Cl 
     312NPRO/ClGafinNp 
     313NPRO/ClGaipNs 
     314NPRO/ClGfNs 
     315NPRO/ClGnNs 
     316NPRO/ClGpNp 
     317NPRO/ClGpNs 
     318NPRO/ClNp 
     319NPRO/ClNs 
     320NPRO/CnGafinNp 
     321NPRO/CnGaipNs 
     322NPRO/CnGfNs 
     323NPRO/CnGnNs 
     324NPRO/CnGpNp 
     325NPRO/CnGpNs 
     326NPRO/CnNp 
     327NPRO/CnNs 
    497328NUMCOL/Ca 
    498329NUMCOL/Cd 
    … …  
    502333NUMCOL/Cn 
    503334NUMCRD/Ca 
    504 NUMCRD/CaGaifn 
     335NUMCRD/CaGafin 
    505336NUMCRD/CaGain 
    506337NUMCRD/CaGf 
    … …  
    509340NUMCRD/Cg 
    510341NUMCRD/Ci 
     342NUMCRD/CiGainp 
    511343NUMCRD/CiGf 
    512 NUMCRD/CiGpain 
    513344NUMCRD/Cl 
    514345NUMCRD/Cn 
    515 NUMCRD/CnGaifn 
     346NUMCRD/CnGafin 
    516347NUMCRD/CnGain 
    517348NUMCRD/CnGf 
    518349NUMCRD/CnGp 
    519 NUMCRD/ZiCaGaifn 
    520 NUMCRD/ZiCaGain 
    521 NUMCRD/ZiCaGf 
    522 NUMCRD/ZiCaGp 
    523 NUMCRD/ZiCd 
    524 NUMCRD/ZiCg 
    525 NUMCRD/ZiCi 
    526 NUMCRD/ZiCiGf 
    527 NUMCRD/ZiCiGpain 
    528 NUMCRD/ZiCl 
    529 NUMCRD/ZiCnGaifn 
    530 NUMCRD/ZiCnGain 
    531 NUMCRD/ZiCnGf 
    532 NUMCRD/ZiCnGp 
    533 NUMCRD/ZqiCaGaifn 
    534 NUMCRD/ZqiCaGp 
    535 NUMCRD/ZqiCd 
    536 NUMCRD/ZqiCg 
    537 NUMCRD/ZqiCi 
    538 NUMCRD/ZqiCl 
    539 NUMCRD/ZqiCnGaifn 
    540 NUMCRD/ZqiCnGp 
    541 NUMORD/NpCaGp 
    542 NUMORD/NpCd 
    543 NUMORD/NpCgl 
    544 NUMORD/NpCi 
    545 NUMORD/NpCnavGaifn 
    546 NUMORD/NpCnvGp 
    547 NUMORD/NsCaGi 
    548 NUMORD/NsCaGpa 
    549 NUMORD/NsCaiGf 
    550 NUMORD/NsCavGf 
    551 NUMORD/NsCdGpain 
    552 NUMORD/NsCgdlGf 
    553 NUMORD/NsCgGpain 
    554 NUMORD/NsCilGpain 
    555 NUMORD/NsCnavGn 
    556 NUMORD/NsCnvGpai 
     350NUMORD/CaGapNs 
     351NUMORD/CaGiNs 
     352NUMORD/CaGpNp 
     353NUMORD/CaiGfNs 
     354NUMORD/CanvGafinNp 
     355NUMORD/CanvGnNs 
     356NUMORD/CdGainpNs 
     357NUMORD/CdglGfNs 
     358NUMORD/CdNp 
     359NUMORD/CgGainpNs 
     360NUMORD/CglNp 
     361NUMORD/CilGainpNs 
     362NUMORD/CiNp 
     363NUMORD/CnvGaipNs 
     364NUMORD/CnvGfNs 
     365NUMORD/CnvGpNp 
    557366NUMPAR 
    558367NUMPAR/Dc 
    559368NUMPAR/Dp 
    560369NUMPAR/Ds 
     370NUMPAR/GainpNs 
     371NUMPAR/GfNs 
    561372NUMPAR/Ns 
    562 NUMPAR/NsGf 
    563 NUMPAR/NsGpain 
    564373NV/Ca 
    565374NV/Cd 
    … …  
    572381PART 
    573382P/Ca 
     383P/Cag 
     384P/Cagi 
    574385P/Cai 
    575386P/Cal 
    576387P/Cd 
     388P/Cdg 
    577389P/Cg 
    578 P/Cga 
    579 P/Cgai 
    580 P/Cgd 
    581390P/Cgi 
    582 P/Ci 
    583391P/Cl 
    584 PPRO/Zp 
     392PPRO/C 
     393V/AiGafinMcNpP1Vp 
     394V/AiGafinMcNpP2Vp 
     395V/AiGafinMcNpP3Vp 
     396V/AiGafinMdNpP1TaVp 
     397V/AiGafinMdNpP2TaVp 
     398V/AiGafinMdNpP3TaVp 
     399V/AiGaipMcNsP1Vp 
     400V/AiGaipMcNsP2Vp 
     401V/AiGaipMcNsP3Vp 
     402V/AiGaipMdNsP1TaVp 
     403V/AiGaipMdNsP2TaVp 
     404V/AiGaipMdNsP3TaVp 
     405V/AiGfMcNsP1Vp 
     406V/AiGfMcNsP2Vp 
     407V/AiGfMcNsP3Vp 
     408V/AiGfMdNsP1TaVp 
     409V/AiGfMdNsP2TaVp 
     410V/AiGfMdNsP3TaVp 
     411V/AiGnMcNsP3Vp 
     412V/AiGnMdNsP3TaVp 
     413V/AiGpMcNpP1Vp 
     414V/AiGpMcNpP2Vp 
     415V/AiGpMcNpP3Vp 
     416V/AiGpMdNpP1TaVp 
     417V/AiGpMdNpP2TaVp 
     418V/AiGpMdNpP3TaVp 
     419V/AiMdNpP1TfrVp 
     420V/AiMdNpP2TfrVp 
     421V/AiMdNpP3TfrVp 
     422V/AiMdNsP1TfrVp 
     423V/AiMdNsP2TfrVp 
     424V/AiMdNsP3TfrVp 
     425V/AiMiNpP1Vp 
     426V/AiMiNpP2Vp 
     427V/AiMiNsP2Vp 
     428V/AiTaVi 
    585429V/AiVb 
    586 V/AiViTa 
    587 V/AiVpMcNpP1Gaifn 
    588 V/AiVpMcNpP1Gp 
    589 V/AiVpMcNpP2Gaifn 
    590 V/AiVpMcNpP2Gp 
    591 V/AiVpMcNpP3Gaifn 
    592 V/AiVpMcNpP3Gp 
    593 V/AiVpMcNsP1Gf 
    594 V/AiVpMcNsP1Gpai 
    595 V/AiVpMcNsP2Gf 
    596 V/AiVpMcNsP2Gpai 
    597 V/AiVpMcNsP3Gf 
    598 V/AiVpMcNsP3Gn 
    599 V/AiVpMcNsP3Gpai 
    600 V/AiVpMdTaNpP1Gaifn 
    601 V/AiVpMdTaNpP1Gp 
    602 V/AiVpMdTaNpP2Gaifn 
    603 V/AiVpMdTaNpP2Gp 
    604 V/AiVpMdTaNpP3Gaifn 
    605 V/AiVpMdTaNpP3Gp 
    606 V/AiVpMdTaNsP1Gf 
    607 V/AiVpMdTaNsP1Gpai 
    608 V/AiVpMdTaNsP2Gf 
    609 V/AiVpMdTaNsP2Gpai 
    610 V/AiVpMdTaNsP3Gf 
    611 V/AiVpMdTaNsP3Gn 
    612 V/AiVpMdTaNsP3Gpai 
    613 V/AiVpMdTrfNpP1 
    614 V/AiVpMdTrfNpP2 
    615 V/AiVpMdTrfNpP3 
    616 V/AiVpMdTrfNsP1 
    617 V/AiVpMdTrfNsP2 
    618 V/AiVpMdTrfNsP3 
    619 V/AiVpMiNpP1 
    620 V/AiVpMiNpP2 
    621 V/AiVpMiNsP2 
     430V/ApGafinMcNpP1Vp 
     431V/ApGafinMcNpP2Vp 
     432V/ApGafinMcNpP3Vp 
     433V/ApGafinMdNpP1TaVp 
     434V/ApGafinMdNpP2TaVp 
     435V/ApGafinMdNpP3TaVp 
     436V/ApGaipMcNsP1Vp 
     437V/ApGaipMcNsP2Vp 
     438V/ApGaipMcNsP3Vp 
     439V/ApGaipMdNsP1TaVp 
     440V/ApGaipMdNsP2TaVp 
     441V/ApGaipMdNsP3TaVp 
     442V/ApGfMcNsP1Vp 
     443V/ApGfMcNsP2Vp 
     444V/ApGfMcNsP3Vp 
     445V/ApGfMdNsP1TaVp 
     446V/ApGfMdNsP2TaVp 
     447V/ApGfMdNsP3TaVp 
     448V/ApGnMcNsP3Vp 
     449V/ApGnMdNsP3TaVp 
     450V/ApGpMcNpP1Vp 
     451V/ApGpMcNpP2Vp 
     452V/ApGpMcNpP3Vp 
     453V/ApGpMdNpP1TaVp 
     454V/ApGpMdNpP2TaVp 
     455V/ApGpMdNpP3TaVp 
     456V/ApMdNpP1TfrVp 
     457V/ApMdNpP2TfrVp 
     458V/ApMdNpP3TfrVp 
     459V/ApMdNsP1TfrVp 
     460V/ApMdNsP2TfrVp 
     461V/ApMdNsP3TfrVp 
     462V/ApMiNpP1Vp 
     463V/ApMiNpP2Vp 
     464V/ApMiNsP2Vp 
     465V/ApTaVi 
    622466V/ApVb 
    623 V/ApViTa 
    624 V/ApVpMcNpP1Gaifn 
    625 V/ApVpMcNpP1Gp 
    626 V/ApVpMcNpP2Gaifn 
    627 V/ApVpMcNpP2Gp 
    628 V/ApVpMcNpP3Gaifn 
    629 V/ApVpMcNpP3Gp 
    630 V/ApVpMcNsP1Gf 
    631 V/ApVpMcNsP1Gpai 
    632 V/ApVpMcNsP2Gf 
    633 V/ApVpMcNsP2Gpai 
    634 V/ApVpMcNsP3Gf 
    635 V/ApVpMcNsP3Gn 
    636 V/ApVpMcNsP3Gpai 
    637 V/ApVpMdTaNpP1Gaifn 
    638 V/ApVpMdTaNpP1Gp 
    639 V/ApVpMdTaNpP2Gaifn 
    640 V/ApVpMdTaNpP2Gp 
    641 V/ApVpMdTaNpP3Gaifn 
    642 V/ApVpMdTaNpP3Gp 
    643 V/ApVpMdTaNsP1Gf 
    644 V/ApVpMdTaNsP1Gpai 
    645 V/ApVpMdTaNsP2Gf 
    646 V/ApVpMdTaNsP2Gpai 
    647 V/ApVpMdTaNsP3Gf 
    648 V/ApVpMdTaNsP3Gn 
    649 V/ApVpMdTaNsP3Gpai 
    650 V/ApVpMdTrfNpP1 
    651 V/ApVpMdTrfNpP2 
    652 V/ApVpMdTrfNpP3 
    653 V/ApVpMdTrfNsP1 
    654 V/ApVpMdTrfNsP2 
    655 V/ApVpMdTrfNsP3 
    656 V/ApVpMiNpP1 
    657 V/ApVpMiNpP2 
    658 V/ApVpMiNsP2 
     467V/GafinMcNpP1Vp 
     468V/GafinMcNpP2Vp 
     469V/GafinMcNpP3Vp 
     470V/GafinMdNpP1TaVp 
     471V/GafinMdNpP2TaVp 
     472V/GafinMdNpP3TaVp 
     473V/GaipMcNsP1Vp 
     474V/GaipMcNsP2Vp 
     475V/GaipMcNsP3Vp 
     476V/GaipMdNsP1TaVp 
     477V/GaipMdNsP2TaVp 
     478V/GaipMdNsP3TaVp 
     479V/GfMcNsP1Vp 
     480V/GfMcNsP2Vp 
     481V/GfMcNsP3Vp 
     482V/GfMdNsP1TaVp 
     483V/GfMdNsP2TaVp 
     484V/GfMdNsP3TaVp 
     485V/GiMdNpP1TfrVp 
     486V/GiMdNpP2TfrVp 
     487V/GiMdNpP3TfrVp 
     488V/GiMdNsP1TfrVp 
     489V/GiMdNsP2TfrVp 
     490V/GiMdNsP3TfrVp 
     491V/GiMiNpP1Vp 
     492V/GiMiNpP2Vp 
     493V/GiMiNsP2Vp 
     494V/GiTaVi 
    659495V/GiVb 
    660 V/GiViTa 
    661 V/GiVpMcNpP1Gaifn 
    662 V/GiVpMcNpP1Gp 
    663 V/GiVpMcNpP2Gaifn 
    664 V/GiVpMcNpP2Gp 
    665 V/GiVpMcNpP3Gaifn 
    666 V/GiVpMcNpP3Gp 
    667 V/GiVpMcNsP1Gf 
    668 V/GiVpMcNsP1Gpai 
    669 V/GiVpMcNsP2Gf 
    670 V/GiVpMcNsP2Gpai 
    671 V/GiVpMcNsP3Gf 
    672 V/GiVpMcNsP3Gn 
    673 V/GiVpMcNsP3Gpai 
    674 V/GiVpMdTaNpP1Gaifn 
    675 V/GiVpMdTaNpP1Gp 
    676 V/GiVpMdTaNpP2Gaifn 
    677 V/GiVpMdTaNpP2Gp 
    678 V/GiVpMdTaNpP3Gaifn 
    679 V/GiVpMdTaNpP3Gp 
    680 V/GiVpMdTaNsP1Gf 
    681 V/GiVpMdTaNsP1Gpai 
    682 V/GiVpMdTaNsP2Gf 
    683 V/GiVpMdTaNsP2Gpai 
    684 V/GiVpMdTaNsP3Gf 
    685 V/GiVpMdTaNsP3Gn 
    686 V/GiVpMdTaNsP3Gpai 
    687 V/GiVpMdTrfNpP1 
    688 V/GiVpMdTrfNpP2 
    689 V/GiVpMdTrfNpP3 
    690 V/GiVpMdTrfNsP1 
    691 V/GiVpMdTrfNsP2 
    692 V/GiVpMdTrfNsP3 
    693 V/GiVpMiNpP1 
    694 V/GiVpMiNpP2 
    695 V/GiVpMiNsP2 
     496V/GnMcNsP3Vp 
     497V/GnMdNsP3TaVp 
     498V/GpMcNpP1Vp 
     499V/GpMcNpP2Vp 
     500V/GpMcNpP3Vp 
     501V/GpMdNpP1TaVp 
     502V/GpMdNpP2TaVp 
     503V/GpMdNpP3TaVp 
    696504VNI 

  • src/compdic_utf8/Makefile

    r5f4d9c3 re7de6cc  
    11include ../../config.mak 
    22 
    3 all: compiledic 
     3all: compdic 
    44 
    5 .PHONY: compiledic 
     5.PHONY: compdic 
    66compiledic: 
    77 
    … …  
    99install: 
    1010ifdef BIN_DIR 
    11         install -m 0755 compiledic $(BIN_DIR) 
     11        install -m 0755 compdic $(BIN_DIR) 
    1212        install -m 0755 text2fst.py $(BIN_DIR) 
    1313        install -m 0755 symbols.py $(BIN_DIR) 
    … …  
    1717uninstall: 
    1818ifdef BIN_DIR 
    19         rm $(BIN_DIR)/compiledic 
     19        rm $(BIN_DIR)/compdic 
    2020        rm $(BIN_DIR)/text2fst.py 
    2121        rm $(BIN_DIR)/symbols.py 

  • src/dgp/Makefile

    r5f4d9c3 re7de6cc  
     1 
    12include ../../config.mak 
     3 
    24 
    35SHELL = /bin/sh 
    … …  
    68CMDLINE_FILE='"../dgp/cmdline.h"' 
    79 
     10 
    811#vpath %.o  . 
    912 
    10 ifeq ($(BUILD_STATIC), yes) 
    11         LDFLAGS += -static 
    12 endif 
     13CXXFLAGS = -g -static 
    1314 
    14 CXXFLAGS += -O2 
    15  
    16 sources = main.cc grammar.cc symbol.cc mgraph.cc sgraph.cc dgp0.cc cmdline.cc \ 
     15sources = main.cc grammar.cc symbol.cc mgraph.cc sgraph.cc dgp1.cc cmdline.cc \ 
    1716          $(COMMON_PATH)/common.cc global.cc 
    1817 
    … …  
    2322 
    2423${bin}: ${objs} 
    25         $(CXX) $(CXXFLAGS) -D _CMDLINE_FILE=$(CMDLINE_FILE) -o $@ ${objs} $(LDFLAGS) 
     24        ${CXX} ${CXXFLAGS} -D _CMDLINE_FILE=$(CMDLINE_FILE) -o $@ ${objs} 
    2625 
    2726include $(sources:.cc=.d) 
    2827 
    2928%.o: %.cc 
    30         $(CXX) -D _CMDLINE_FILE=$(CMDLINE_FILE) -c ${CXXFLAGS} -o $@ $< 
     29        ${CXX} -D _CMDLINE_FILE=$(CMDLINE_FILE) -c ${CXXFLAGS} -o $@ $< 
    3130 
    3231%.d: %.cc 
    … …  
    3534        rm -f $@.$$$$ 
    3635 
    37 # stare: 
    38 # cmdline.cc cmdline.h : cmdline.ggo 
    39 #       gengetopt --c-extension=cc -i cmdline.ggo 
    40 # nowe 
     36 
    4137cmdline.cc cmdline.h: cmdline.ggo 
    42         $(GENGETOPT) -i cmdline.ggo  --c-extension=cc --conf-parser 
     38        gengetopt -i cmdline.ggo  --c-extension=cc --conf-parser 
    4339 
    4440cmdline.ggo: cmdline_dgp.ggo ../common/cmdline_common.ggo 
    4541        cat cmdline_dgp.ggo ../common/cmdline_common.ggo > cmdline.ggo 
    46 # endnowe 
    4742 
    4843 
     44 
     45.PHONY: clean 
    4946clean: 
    50         rm ${bin} ${objs} cmdline.cc cmdline.h 
    51         rm -rf *.d 
     47        rm -f ${bin} ${objs} cmdline.* 
     48        rm -f *.d 
    5249 
     50.PHONY: prof 
    5351prof: dgp 
    5452        gprof dgp ~/tmp/dgp-pl/gmon.out > dgp.prof 
     53 
    5554 
    5655.PHONY: install 
    … …  
    5857ifdef BIN_DIR 
    5958        install -m 0755 dgp $(BIN_DIR) 
    60         install -m 0755 dgc $(BIN_DIR) 
    61         install -m 0755 canonize $(BIN_DIR) 
    62         install -m 0755 tre $(BIN_DIR) 
    6359endif 
    6460 
    … …  
    6763ifdef BIN_DIR 
    6864        rm $(BIN_DIR)/dgp 
    69         rm $(BIN_DIR)/dgc 
    70         rm $(BIN_DIR)/canonize 
    71         rm $(BIN_DIR)/tre 
    7265endif 

  • src/dgp/const.hh

    r5f4d9c3 re7de6cc  
    33 
    44#define MAXTYPES 32 
     5#define MAXCATS 4096 
    56#define MAXFLAGS 64 
    6 #define MAXNODES 1024 
     7#define MAXPROPS 16 
     8#define MAXNODES 2048 
    79#define MAXCONSTRS 32 
    8 #define MAXLINE 256 
     10#define MAXLINE 512 
    911#define MAXFORMLEN 64 
    1012#define MAXDESCRLEN 80 

  • src/dgp/dgp0.cc

    r5f4d9c3 re7de6cc  
    66extern SGraph sgraph; 
    77 
    8 SNode* snodes; 
    9  
    108extern bool debug; 
    119 
    … …  
    1614void set_initial_constraints(int node) 
    1715{ 
    18   snodes[node].prop.forbidden.reset(); 
    19   snodes[node].prop.required=grammar.obl[snodes[node].mnode->cat]; 
     16  sgraph[node].prop.forbidden.reset(); 
     17  sgraph[node].prop.required=grammar.is_obl(mgraph[sgraph[node].mnode].cat); 
    2018} 
    2119 
    … …  
    2321bool changing_constraints(int head, Role role) 
    2422{ 
    25   return grammar.sgl[role] || snodes[head].prop.required[role]; 
     23  return grammar.is_sgl(role) || sgraph[head].prop.required[role]; 
    2624} 
    2725 
    2826void apply_constraints(int head, Role role) 
    2927{ 
    30   if(grammar.sgl[role]) snodes[head].prop.forbidden.set(role); 
    31   snodes[head].prop.required.reset(role); 
     28  if(grammar.is_sgl(role)) sgraph[head].prop.forbidden.set(role); 
     29  sgraph[head].prop.required.reset(role); 
    3230} 
    3331 
    … …  
    3533{ 
    3634  NodeProp ret=headprop; 
    37   if(grammar.sgl[role]) ret.forbidden.set(role); 
     35  if(grammar.is_sgl(role)) ret.forbidden.set(role); 
    3836  ret.required.reset(role); 
    3937  return ret; 
    … …  
    4442  NodeProp ret=headprop; 
    4543 
    46   if(grammar.sgl[role]) ret.forbidden.set(role); 
     44  if(grammar.is_sgl(role)) ret.forbidden.set(role); 
    4745  ret.required.reset(role); 
    4846  return ret; 
    … …  
    5250{ 
    5351  for(vector<int>::iterator ps=mnode.snodes.begin(); ps!=mnode.snodes.end(); ++ps) 
    54     if(snodes[*ps].prop==p && snodes[*ps].LH==newheadLH && snodes[*ps].LV==newheadLV) 
     52    if(sgraph[*ps].prop==p && sgraph[*ps].LH==newheadLH && sgraph[*ps].LV==newheadLV) 
    5553      return *ps; 
    5654  return -1; 
    … …  
    5957void connect_left(list<int>::iterator h, list<int>::iterator d, Role r) 
    6058{ 
    61   NodeProp &oldheadprop = snodes[*h].prop; 
    62   NodeProp newheadprop; 
    63   bitset<MAXNODES> newheadLV; 
    64   bitset<MAXNODES> newheadLH; 
    65   bitset<MAXNODES> newheadLD; 
    66    
    67   newheadprop=compute_prop_left(oldheadprop,r); 
     59  NodeProp &oldheadprop = sgraph[*h].prop; 
     60  NodeProp newheadprop  = compute_prop_left(oldheadprop,r); 
    6861   
    6962  int newheadind; 
    … …  
    7265  else 
    7366  { 
    74     newheadLH = snodes[*h].LH; 
    75     newheadLV = snodes[*d].LV; 
    76     newheadLD = snodes[*h].LD; 
    77  
    78     newheadind = get_node(*(snodes[*h].mnode), newheadprop, newheadLH, newheadLV); 
     67    bitset<MAXNODES> newheadLH = sgraph[*h].LH; 
     68    bitset<MAXNODES> newheadLV = sgraph[*d].LV; 
     69    bitset<MAXNODES> newheadLD = sgraph[*h].LD; 
     70 
     71    newheadind = get_node(mgraph[sgraph[*h].mnode], newheadprop, newheadLH, newheadLV); 
    7972    if( newheadind < 0 ) 
    8073    { 
    … …  
    8275      list<int>::iterator nextit=h; ++nextit; 
    8376      nodelist.insert(nextit,newheadind); 
    84       snodes[newheadind].LH=newheadLH; 
    85       snodes[newheadind].in_LH=true; 
    86       snodes[newheadind].LV.reset(); 
    87       snodes[newheadind].LD = newheadLD; 
     77      sgraph[newheadind].LH=newheadLH; 
     78      sgraph[newheadind].LD = newheadLD; 
     79      sgraph[newheadind].in_LH=true; 
     80      sgraph[newheadind].LV.reset(); 
    8881       
    8982      if(debug) sgraph.print_node_debug(stderr," C ",newheadind); 
    9083    } 
    9184    else 
    92       snodes[newheadind].LD |= newheadLD; // TYLKO DLA LD 
     85      sgraph[newheadind].LD |= newheadLD; // TYLKO DLA LD 
    9386  } 
    9487 
    95   snodes[newheadind].deps.push_back(Arc(*d,r,*h)); 
    96    
    97   if(snodes[*d].saturated()) snodes[newheadind].LV |= snodes[*d].LV; 
    98   snodes[newheadind].LD.set(*d); 
    99   if(snodes[*d].saturated()) snodes[newheadind].LD |= snodes[*d].LD; 
    100    
    101   if(debug) 
    102     sgraph.print_arc(stderr,*d,newheadind,r,0), sgraph.print_node_debug(stderr," U ",newheadind); 
    103 } 
    104  
     88  sgraph[newheadind].deps.push_back(Arc(*d,r,*h)); 
     89   
     90  if(sgraph[*d].saturated()) sgraph[newheadind].LV |= sgraph[*d].LV; 
     91 
     92  sgraph[newheadind].LD.set(*d); 
     93  if(sgraph[*d].saturated()) sgraph[newheadind].LD |= sgraph[*d].LD; 
     94   
     95  if(debug) sgraph.print_arc(stderr,*d,newheadind,r,0), sgraph.print_node_debug(stderr," U ",newheadind); 
     96} 
    10597 
    10698void connect_right(list<int>::iterator h, list<int>::iterator d, Role r) 
    10799{ 
    108   NodeProp &oldheadprop = snodes[*h].prop; 
    109   NodeProp newheadprop; 
    110   bitset<MAXNODES> newheadLV; 
    111   bitset<MAXNODES> newheadLH; 
    112   bitset<MAXNODES> newheadLD; 
     100  NodeProp &oldheadprop = sgraph[*h].prop; 
     101  NodeProp newheadprop = compute_prop_right(oldheadprop,r); 
    113102  int newheadind; 
    114103   
    115   newheadprop = compute_prop_right(oldheadprop,r); 
    116104  if(oldheadprop==newheadprop) 
    117105    newheadind = *h; 
    118106  else 
    119107  { 
    120     newheadLH = snodes[*h].LH; 
    121     newheadLV = snodes[*h].LV; 
    122     newheadLD = snodes[*h].LD; 
    123  
    124     newheadind = get_node(*(snodes[*h].mnode), newheadprop, newheadLH, newheadLV); 
     108    bitset<MAXNODES> newheadLH = sgraph[*h].LH; 
     109    bitset<MAXNODES> newheadLV = sgraph[*h].LV; 
     110    bitset<MAXNODES> newheadLD = sgraph[*h].LD; 
     111 
     112    newheadind = get_node(mgraph[sgraph[*h].mnode], newheadprop, newheadLH, newheadLV); 
    125113    if( newheadind < 0 ) 
    126114    { 
    127115      newheadind = sgraph.clone(*h,newheadprop); 
    128       snodes[newheadind].LH=newheadLH; 
    129       snodes[newheadind].in_LH=false; 
    130       snodes[newheadind].LV=newheadLV; 
    131       snodes[newheadind].LD=newheadLD; 
    132116      list<int>::iterator nextit=h; ++nextit; 
    133117      nodelist.insert(nextit,newheadind); 
     118      sgraph[newheadind].LH=newheadLH; 
     119      sgraph[newheadind].LD=newheadLD; 
     120      sgraph[newheadind].in_LH=false; 
     121      sgraph[newheadind].LV=newheadLV; 
    134122       
    135123      if(debug) sgraph.print_node_debug(stderr," C ",newheadind); 
    136124    } 
    137125    else 
    138       snodes[newheadind].LD |= newheadLD; // TYLKO DLA LD 
     126      sgraph[newheadind].LD |= newheadLD; // TYLKO DLA LD 
    139127  } 
    140128   
    141   snodes[*d].heads.push_back(Arc(newheadind,r,*h)); 
    142  
    143   snodes[*d].LH.set(newheadind); 
    144  
    145   if(snodes[newheadind].saturated()) snodes[*d].LH |= snodes[newheadind].LH; 
    146  
    147   if(debug) 
    148     sgraph.print_arc(stderr,newheadind,*d,r,1), sgraph.print_node_debug(stderr," U ",*d); 
     129  sgraph[*d].heads.push_back(Arc(newheadind,r,*h)); 
     130 
     131  sgraph[*d].LH.set(newheadind); 
     132 
     133  if(sgraph[newheadind].saturated()) sgraph[*d].LH |= sgraph[newheadind].LH; 
     134 
     135  if(debug) sgraph.print_arc(stderr,newheadind,*d,r,1), sgraph.print_node_debug(stderr," U ",*d); 
    149136   
    150137} 
    … …  
    156143    if(sgraph.visible(*i,*j) && sgraph.saturated(*i)) 
    157144    { 
    158       Roles& ji_roles = grammar.connect[snodes[*j].mnode->cat][snodes[*i].mnode->cat]; 
     145      Roles& ji_roles = grammar.connectable( mgraph[sgraph[*j].mnode].cat, mgraph[sgraph[*i].mnode].cat ); 
    159146      for(RolesIter r=ji_roles.begin(); r!=ji_roles.end();++r) 
    160         if(grammar.check_constr(snodes[*j].prop,snodes[*i].prop,0,*r)) 
     147        if(grammar.check_constr(sgraph[*j].prop,sgraph[*i].prop,0,*r)) 
    161148          connect_left(j,i,*r); 
    162149    } 
    … …  
    169156    if(sgraph.visible(*i,*j)) 
    170157    { 
    171       Roles& ij_roles = grammar.connect[snodes[*i].mnode->cat][snodes[*j].mnode->cat]; 
     158      Roles& ij_roles = grammar.connectable( mgraph[sgraph[*i].mnode].cat, mgraph[sgraph[*j].mnode].cat ); 
    172159      for(RolesIter r=ij_roles.begin(); r!=ij_roles.end();++r) 
    173         if(grammar.check_constr(snodes[*i].prop,snodes[*j].prop,1,*r)) 
     160        if(grammar.check_constr(sgraph[*i].prop,sgraph[*j].prop,1,*r)) 
    174161          connect_right(i,j,*r); 
    175162    } 
    … …  
    182169  for(++i; i!=nodelist.end(); ++i) 
    183170    { 
    184       for(vector<Arc>::iterator da=sgraph.nodes[*i].deps.begin()--; da!=sgraph.nodes[*i].deps.end(); ++da) 
    185         sgraph.nodes[da->dst].heads.push_back(Arc(*i,da->role,da->anc)); 
    186       for(vector<Arc>::iterator ha=sgraph.nodes[*i].heads.begin(); ha!=sgraph.nodes[*i].heads.end(); ++ha) 
    187         sgraph.nodes[ha->dst].deps.push_back(Arc(*i,ha->role,ha->anc)); 
     171      for(vector<Arc>::iterator da=sgraph[*i].deps.begin()--; da!=sgraph[*i].deps.end(); ++da) 
     172        sgraph[da->dst].heads.push_back(Arc(*i,da->role,da->anc)); 
     173      for(vector<Arc>::iterator ha=sgraph[*i].heads.begin(); ha!=sgraph[*i].heads.end(); ++ha) 
     174        sgraph[ha->dst].deps.push_back(Arc(*i,ha->role,ha->anc)); 
    188175    } 
    189176} 
    … …  
    192179void dgp0() 
    193180{ 
    194   snodes=sgraph.nodes; 
    195181 
    196182  nodelist.clear(); 
    … …  
    198184  processed=nodelist.begin(); 
    199185 
    200   for(int m=0; m<mgraph.n ; ++m) 
     186  for(int m=0; m<mgraph.size() ; ++m) 
    201187  { 
    202     int basenode = sgraph.add_base_snode(mgraph.nodes+m); // ma zwracaæ SNode* 
     188    int basenode = sgraph.add_base_snode(m); // ma zwracaæ SNode* 
     189 
    203190    set_initial_constraints(basenode); 
    204191    nodelist.push_back(basenode); 
    … …  
    213200      processed=cursor; 
    214201    } 
     202 
    215203  } 
    216204  reverse_links(); 

  • src/dgp/grammar.cc

    r5f4d9c3 re7de6cc  
    11 
    2 #include <stdio.h> 
     2#include <cstdio> 
    33 
    44#include "grammar.hh" 
    55 
    6 bool (*constraint[MAXCONSTRS])(int head, int dep); 
    7  
    8  
    9 int chk_type(const char* s, int lineno) // SIDE EFECTS! 
    10 { 
    11   if(Role::index(s)>0) return 1; 
    12  
    13   fprintf(stderr,"%8d: Invalid type '%s'. Line ignored.\n",lineno,s); 
    14   return 0; 
    15 } 
    16  
    17 int chk_cat(const char* s, int lineno) 
    18 { 
    19   if(Cat::index(s)>0) return 1; 
    20  
    21   fprintf(stderr,"%8d: Invalid category '%s'. Line ignored.\n",lineno,s); 
    22   return 0; 
    23 } 
     6//bool (*constraint[MAXCONSTRS])(int head, int dep); 
     7 
     8//==================================================================================================== 
     9//inline !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
     10bool chk_type(const char* s) { return Role::index(s)>0; } // PRZENIEŠÆ DO Role 
     11//---------------------------------------------------------------------------------------------------- 
     12//inline !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
     13bool chk_long(const char* s) { return LongRel::index(s)>0; } // jw 
     14//---------------------------------------------------------------------------------------------------- 
     15//inline !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
     16bool chk_cat(const char* s) { return Cat::index(s)>0; } //jw 
     17//---------------------------------------------------------------------------------------------------- 
     18//inline !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
     19bool chk_flag(const char* s) { return Flag::index(s)>0; } //jw 
     20//==================================================================================================== 
     21 
     22void grammar_error(int lineno, string s="Grammar error.") 
     23{ 
     24  fprintf(stderr,"%8d: %s Line ignored.\n",lineno,s.c_str()); 
     25} 
     26 
     27//==================================================================================================== 
    2428 
    2529void Grammar::add_category(const char* s) 
    2630{ 
    2731  Cat::add(s); 
    28   if(Cat::count()>cats_sz) 
     32 
     33  if(connect.size() <= Cat::count()) 
    2934  { 
    30     cats_sz += 16; 
    31     connect.resize(cats_sz); 
    32     for(int i=0; i<cats_sz; ++i) 
    33       connect[i].resize(cats_sz); 
    34     obl.resize(cats_sz); 
     35    connect.resize(Cat::count()+RESIZE_DELTA); 
     36    for(int i=0; i<connect.size(); ++i) 
     37      if(connect[i].size() <= Cat::count()) connect[i].resize(Cat::count()+RESIZE_DELTA); 
    3538  } 
     39  if(connect1.size() <= Cat::count()) 
     40  { 
     41    connect1.resize(Cat::count()+RESIZE_DELTA); 
     42    for(int i=0; i<=connect1.size(); ++i) 
     43      if(connect1[i].size() <= Cat::count()) connect1[i].resize(Cat::count()+RESIZE_DELTA); 
     44  } 
     45 
     46  if(longrel.size() <= Cat::count()) 
     47  { 
     48    longrel.resize(Cat::count()+RESIZE_DELTA); 
     49    for(int i=0; i<longrel.size(); ++i) 
     50      if(longrel[i].size() <= Cat::count()) longrel[i].resize(Cat::count()+RESIZE_DELTA); 
     51  } 
     52 
     53  if(uptrigger.size() <= Cat::count()) 
     54    uptrigger.resize(Cat::count()+RESIZE_DELTA); 
     55  if(dntrigger.size() <= Cat::count()) 
     56    dntrigger.resize(Cat::count()+RESIZE_DELTA); 
     57   
     58  if(obl.size() <= Cat::count()) obl.resize(Cat::count()+RESIZE_DELTA); 
     59  if(set.size() <= Cat::count()) set.resize(Cat::count()+RESIZE_DELTA); 
    3660} 
    3761 
    … …  
    3963{   
    4064  Role::add(s); 
    41   if(Role::count()>types_sz) 
    42   { 
    43     types_sz += 16; 
    44     lt.resize(types_sz); 
    45     gt.resize(types_sz); 
    46   } 
    47 } 
    48  
    49 void Grammar::add_flag(const char* s) 
    50 {   
    51   Flag::add(s); 
    52   if(Flag::count()>flags_sz) 
    53   { 
    54     flags_sz += 16; 
    55     pass.resize(flags_sz); 
    56   } 
    57 } 
    58  
     65 
     66  if(lt.size() <= Role::count()) lt.resize(Role::count()+RESIZE_DELTA); 
     67  if(gt.size() <= Role::count()) gt.resize(Role::count()+RESIZE_DELTA); 
     68  if(pass.size() <= Role::count()) pass.resize(Role::count()+RESIZE_DELTA); 
     69  if(include.size() <= Role::count()) include.resize(Role::count()+RESIZE_DELTA); 
     70  if(exclude.size() <= Role::count()) exclude.resize(Role::count()+RESIZE_DELTA); 
     71  for(int i=0; i<uptrigger.size(); i++) 
     72    if(uptrigger[i].size() <= Role::count()) uptrigger[i].resize(Role::count()+RESIZE_DELTA); 
     73  for(int i=0; i<dntrigger.size(); i++) 
     74    if(dntrigger[i].size() <= Role::count()) dntrigger[i].resize(Role::count()+RESIZE_DELTA); 
     75} 
     76 
     77//==================================================================================================== 
     78 
     79bool Grammar::contains_boubble(const list<Boubble*> boubble_list, Boubble* bp) const 
     80{ 
     81  for(list<Boubble*>::const_iterator bi = boubble_list.begin(); bi != boubble_list.end(); bi++ ) 
     82    if(**bi == *bp) return true; 
     83  return false; 
     84} 
     85 
     86//---------------------------------------------------------------------------------------------------- 
     87 
     88void Grammar::add_triggers(Cat src, Cat dest, LongRel l) 
     89{ 
     90  for(list<Boubble*>::const_iterator b=boubbles.begin(); b!=boubbles.end(); b++) 
     91    if((*b)->rel() == l) 
     92      { 
     93        list<Boubble*>& boubble_list = ((*b)->dir()==UP) ? uptrigger[src][(*b)->next()] : dntrigger[src][(*b)->next()] ; 
     94        if(!contains_boubble(boubble_list,*b)) 
     95          boubble_list.push_back(*b); 
     96      } 
     97} 
     98 
     99//==================================================================================================== 
    59100 
    60101void Grammar::set_lt(Role s, Role t) 
    … …  
    85126 
    86127 
     128void Grammar::compute_triggers() 
     129{ 
     130  //init uptrigger array 
     131  uptrigger.resize(Cat::count()); 
     132  for(int i=0; i<uptrigger.size(); i++) 
     133    uptrigger[i].resize(Role::count()); 
     134  //init dntrigger array 
     135  dntrigger.resize(Cat::count()); 
     136  for(int i=0; i<dntrigger.size(); i++) 
     137    dntrigger[i].resize(Role::count()); 
     138 
     139  // for(int c=0; c<Cat::count(); c++) 
     140  //   for(int r=0; r<Role::count(); r++) 
     141  //     for(list<Boubble>::const_iterator b=boubbles.begin(); b!=boubbles.end; b++) 
     142  //    if(b->dir()==UP && ) 
     143} 
     144 
     145//==================================================================================================== 
     146 
     147list<Boubble*> Grammar::trigger_boubbles(Cat c, Role r, Dir d) 
     148{ 
     149  list<Boubble*> boubble_list = (d == UP) ? uptrigger[c][r] : dntrigger[c][r]; 
     150  list<Boubble*> ret; 
     151  for(list<Boubble*>::iterator b = boubble_list.begin(); b != boubble_list.end(); ++b) 
     152    ret.push_back((*b)->step(r,d)); 
     153  return ret;   
     154} 
     155 
     156//==================================================================================================== 
     157 
     158Flag parse_flags(const char* s, const char* v) 
     159{ 
     160  char buf[16][17]; 
     161  int n=sscanf(s,"%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]%[A-Z]%[+-]", 
     162               buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7],buf[8],buf[9],buf[10],buf[11],buf[12],buf[13],buf[14],buf[15],buf[16]); 
     163  for(int i=2; i<=n; i+=2) 
     164    if(strcmp(buf[i-1],v)==0) 
     165      return Flag(buf[i-2]); 
     166  return Flag("NULL"); 
     167} 
     168 
     169 
     170PropSet parse_props(const char* s) 
     171{ 
     172  PropSet ret; 
     173  char buf[8][17]; 
     174  int n=sscanf(s,"&%[A-Z]&%[A-Z]&%[A-Z]&%[A-Z]&%[A-Z]&%[A-Z]&%[A-Z]&%[A-Z]",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]); 
     175  for(int i=1; i<=n; i++) 
     176    ret.set(Prop(buf[i-1])); 
     177  return ret;  
     178   
     179} 
     180 
     181 
    87182bool Grammar::read(FILE* f) 
    88183{ 
     184 
     185  //>>> TU? 
     186 
     187  Prop::add("INIT"); 
     188  Prop::add("FIN"); 
     189 
     190  //<<< TU? 
     191 
     192 
    89193  int lineno=0; 
    90194  char line[MAXLINE]; // line has the structure: key [arg1 [arg2 [arg3]]] 
    … …  
    93197  char arg2[MAXLINE]; 
    94198  char arg3[MAXLINE]; 
     199  char arg4[MAXLINE]; 
    95200 
    96201  while(fgets(line,MAXLINE,f)) 
    97   { 
    98     lineno++; 
    99     int fields=sscanf(line,"%s %s %s %s",key,arg1,arg2,arg3); 
    100  
    101     if(fields<1 || key[0]=='#') continue; // skip empty lines and comments 
    102  
    103     if     (strcmp(key,"CAT")==0 && fields>=2) 
    104202    { 
    105       add_category(arg1); 
     203      lineno++; 
     204      int fields=sscanf(line,"%s %s %s %s %s",key,arg1,arg2,arg3,arg4); 
     205       
     206       if(fields<1 || key[0]=='#') continue; // skip empty lines and comments 
     207 
     208      if(fields>1 && arg1[0] == '#') fields=1; 
     209      if(fields>2 && arg2[0] == '#') fields=2; 
     210      if(fields>3 && arg3[0] == '#') fields=3; 
     211      if(fields>4 && arg4[0] == '#') fields=4; 
     212       
     213      if     (strcmp(key,"CAT")==0 && fields==2) 
     214        { 
     215          add_category(arg1); 
     216        } 
     217      else if(strcmp(key,"ROLE")==0 && fields==2) 
     218        { 
     219          add_type(arg1); 
     220        } 
     221      else if(strcmp(key,"SGL")==0 && fields==2) 
     222        {   
     223          if(chk_type(arg1)) 
     224            set_sgl(arg1); 
     225          else 
     226            grammar_error(lineno); 
     227        } 
     228      else if(strcmp(key,"LEFT")==0 && fields==2) 
     229        {  
     230          if(chk_type(arg1)) 
     231            set_left(arg1); 
     232          else 
     233            grammar_error(lineno); 
     234        } 
     235      else if(strcmp(key,"RIGHT")==0 && fields==2) 
     236        { 
     237          if(chk_type(arg1)) 
     238            set_right(arg1); 
     239          else 
     240            grammar_error(lineno); 
     241        } 
     242      else if(strcmp(key,"INITR")==0 && fields==2) 
     243        { 
     244          if(chk_type(arg1)) 
     245            set_init(arg1); 
     246          else 
     247            grammar_error(lineno); 
     248        } 
     249      else if(strcmp(key,"FINR")==0 && fields==2) 
     250        { 
     251          if(chk_type(arg1)) 
     252            set_fin(arg1); 
     253          else 
     254            grammar_error(lineno); 
     255        } 
     256      else if(strcmp(key,"INITF")==0 && fields==2) 
     257        { 
     258          if(chk_flag(arg1)) 
     259            set_initf(arg1); 
     260          else 
     261            grammar_error(lineno); 
     262        } 
     263      else if(strcmp(key,"FINF")==0 && fields==2) 
     264        { 
     265          if(chk_flag(arg1)) 
     266            set_finf(arg1); 
     267          else 
     268            grammar_error(lineno); 
     269        } 
     270      else if(strcmp(key,"REQ")==0 && fields==3) 
     271        { 
     272          if( chk_cat(arg1) && chk_type(arg2) ) 
     273            set_obl(arg1,arg2); 
     274          else 
     275            grammar_error(lineno); 
     276        } 
     277      else if(strcmp(key,"CONSTRE")==0 && fields==3) 
     278        { 
     279          if( chk_type(arg1) && chk_type(arg2) ) 
     280            set_exclude(arg1,arg2); 
     281          else 
     282            grammar_error(lineno); 
     283        } 
     284      else if(strcmp(key,"CONSTRI")==0 && fields==3) 
     285        { 
     286          if( chk_type(arg1) && chk_type(arg2) ) 
     287            set_include(arg1,arg2); 
     288          else 
     289            grammar_error(lineno); 
     290        } 
     291      else if(strcmp(key,"LONG")==0 &&  fields ==3) 
     292        { 
     293            add_long(arg1,arg2); 
     294        } 
     295      else if(strcmp(key,"LINK")==0 && fields==4) 
     296        {  
     297          char cat1[MAXLINE],flags1[MAXLINE],cat2[MAXLINE],flags2[MAXLINE],type[MAXLINE],props[MAXLINE]; 
     298 
     299          if(sscanf(arg1,"%[^;];%s",cat1,flags1)==1) *flags1='\0';  
     300          if(sscanf(arg2,"%[^;];%s",cat2,flags2)==1) *flags2='\0';  
     301          if(sscanf(arg3,"%[^&]%s",type,props)==1) *props='\0'; 
     302           
     303          //      printf("line=%s\n\tcat1=%s flags1=%s cat2=%s flags2=%s type=%s props=%s\n",line,cat1,flags1,cat2,flags2,type,props); 
     304 
     305          if( chk_cat(cat1) && chk_cat(cat2) && chk_type(type) ) 
     306            set_connect(cat1,parse_flags(flags1,"+"),parse_flags(flags1,"-"),cat2,parse_flags(flags2,"+"),parse_flags(flags2,"-"),type,parse_props(props)); 
     307          else if( chk_cat(cat1) && chk_cat(cat2) && chk_long(type) ) 
     308            { 
     309              set_longrel(cat1,cat2,type); 
     310              add_triggers(cat1,cat2,type); 
     311            } 
     312          else 
     313              grammar_error(lineno); 
     314        } 
     315      // else if(strcmp(key,"LINK")==0 && fields==5) 
     316      //        {  
     317      //          if( chk_cat(arg1) && chk_cat(arg2) && chk_type(arg4) ) 
     318      //            set_connect(arg1,arg2,arg3,arg4); 
     319      //          else 
     320      //              grammar_error(lineno); 
     321      //        } 
     322      // FLAG DECLARATION 
     323      else if(strcmp(key,"FLAG")==0 && fields==2) 
     324        {  
     325          add_flag(arg1); 
     326        } 
     327      else if(strcmp(key,"SET")==0 && fields==3) 
     328        { 
     329          if( chk_cat(arg1) && chk_flag(arg2) ) 
     330            set_set(arg1,arg2); 
     331          else 
     332            grammar_error(lineno); 
     333        } 
     334      else if(strcmp(key,"PASS")==0 && fields==3) 
     335        { 
     336          if( chk_type(arg1) && chk_flag(arg2) ) 
     337            set_pass(arg1,arg2); 
     338          else 
     339            grammar_error(lineno); 
     340        } 
     341       
     342      else fprintf(stderr,"Statement not recognized in line %d. Ignored.\n", lineno); 
    106343    } 
    107     else if(strcmp(key,"ROLE")==0 && fields>=2) 
    108     { 
    109       add_type(arg1); 
    110     } 
    111     else if(strcmp(key,"SGL")==0 && fields>=2) 
    112     {   
    113       if(chk_type(arg1,lineno)) 
    114         set_sgl(arg1); 
    115     } 
    116     else if(strcmp(key,"LEFT")==0 && fields>=2) 
    117     {  
    118       if(chk_type(arg1,lineno)) 
    119         set_left(arg1); 
    120     } 
    121     else if(strcmp(key,"RIGHT")==0 && fields>=2) 
    122     { 
    123       if(chk_type(arg1,lineno)) 
    124         set_right(arg1); 
    125     } 
    126     else if(strcmp(key,"REQ")==0 && fields>=3) 
    127     { 
    128       if(chk_cat(arg1,lineno) + chk_type(arg2,lineno) == 2) 
    129         set_obl(arg1,arg2); 
    130     } 
    131     else if(strcmp(key,"LINK")==0 && fields>=4) 
    132     {  
    133       if(chk_cat(arg1,lineno) + chk_cat(arg2,lineno) + chk_type(arg3,lineno) == 3)     
    134         set_connect(arg1,arg2,arg3); 
    135     } 
    136     // FLAG DECLARATION 
    137     else if(strcmp(key,"FLAG")==0 && fields>=2) 
    138     {  
    139       add_flag(arg1); 
    140     } 
    141  
    142     else fprintf(stderr,"Invalid line %d. Ignored.\n", lineno); 
    143   } 
    144  
    145 //   compute_gt(); 
    146  
     344   
     345  //   compute_gt(); 
     346   
    147347  return true; 
    148348   
    149349} 
     350 
     351 
     352void Grammar::write(ostream& os) 
     353{ 
     354  for(Cat i=1; i<Cat::count(); ++i) 
     355    os << "CAT\t" << i.str() << endl; 
     356 
     357  for(Role i=1; i<Role::count(); ++i) 
     358    os << "ROLE\t" << i.str() << endl; 
     359 
     360  for(Role i=1; i<Role::count(); ++i) 
     361    if(sgl.test(i)) 
     362      os << "SGL\t" << i.str() << endl; 
     363   
     364  for(Role i=1; i<Role::count(); ++i) 
     365    if(left.test(i)) 
     366      os << "LEFT\t" << i.str() << endl; 
     367 
     368  for(Role i=1; i<Role::count(); ++i) 
     369    if(right.test(i)) 
     370      os << "RIGHT\t" << i.str() << endl; 
     371 
     372  for(Cat c=1; c<Cat::count(); ++c) 
     373    for(Role r=1; r<Role::count(); ++r) 
     374      if(obl[c].test(r)) 
     375        os << "REQ\t" << c.str() << "\t" << r.str() << endl; 
     376   
     377  for(Cat c=1; c<Cat::count(); ++c) 
     378    for(Cat d=1; d<Cat::count(); ++d) 
     379      for(Links::const_iterator l = connect1[c][d].begin(); l != connect1[c][d].end(); l++) 
     380        { 
     381          os << "LINK\t" << c.str(); 
     382          if(l->hflagplus||l->hflagminus) 
     383            { 
     384              os << ";"; 
     385              if(l->hflagplus) os << (l->hflagplus).str() << "+"; 
     386              if(l->hflagminus) os << (l->hflagminus).str() << "-";  
     387            } 
     388          os << "\t" << d.str(); 
     389          if(l->dflagplus||l->dflagminus) 
     390            { 
     391              os << ";"; 
     392              if(l->dflagplus) os << (l->dflagplus).str() << "+"; 
     393              if(l->dflagminus) os << (l->dflagminus).str() << "-";  
     394            } 
     395          os << "\t" << (l->role).str(); 
     396          for(Prop p=0; p<Prop::count(); ++p) 
     397            if(l->props[p]) 
     398              os << "&" << p.str(); 
     399          os << endl; 
     400        } 
     401 
     402  for(LongRel i=1; i<LongRel::count(); ++i) 
     403    os << "LONG\t" << i.str() << endl; 
     404 
     405  for(list<Boubble*>::const_iterator b = boubbles.begin(); b != boubbles.end(); b++) 
     406    os << "BOUBBLE\t" << **b << endl; 
     407 
     408  for(Cat c=1; c<Cat::count(); ++c) 
     409    for(Cat d=1; d<Cat::count(); ++d) 
     410      for(LongRel l=1; l<LongRel::count(); ++l) 
     411        if(longrel[c][d].count(l)) 
     412          os << "LLINK\t" << c.str() << "\t" << d.str() << "\t" << l.str() << endl; 
     413 
     414  for(Cat c=1; c<Cat::count(); ++c) 
     415    for(Flag f=1; f<Flag::count(); ++f) 
     416      if(set[c].test(f)) 
     417        os << "SET\t" << c.str() << "\t" << f.str() << endl; 
     418 
     419  for(Role r=1; r<Role::count(); ++r) 
     420    for(Flag f=1; f<Flag::count(); ++f) 
     421      if(pass[r].test(f)) 
     422        os << "PASS\t" << r.str() << "\t" << f.str() << endl; 
     423   
     424  for(Role r=1; r<Role::count(); ++r) 
     425    for(Role t=1; t<Role::count(); ++t) 
     426      if(include[r].test(t)) 
     427        os << "CONSTRI\t" << r.str() << "\t" << t.str() << endl; 
     428   
     429  for(Role r=1; r<Role::count(); ++r) 
     430    for(Role t=1; t<Role::count(); ++t) 
     431      if(exclude[r].test(t)) 
     432        os << "CONSTRE\t" << r.str() << "\t" << t.str() << endl; 
     433   
     434  for(Cat c=1; c<Cat::count(); ++c) 
     435    for(Role r=1; r<Role::count(); ++r) 
     436      for(list<Boubble*>::const_iterator b=uptrigger[c][r].begin(); b!=uptrigger[c][r].end(); b++) 
     437        os << "TRIGGER-UP\t" << c.str() << "\t" << r.str() << "\t" << (*b)->rel().str() << endl; 
     438 
     439  for(Cat c=1; c<Cat::count(); ++c) 
     440    for(Role r=1; r<Role::count(); ++r) 
     441      for(list<Boubble*>::const_iterator b=dntrigger[c][r].begin(); b!=dntrigger[c][r].end(); b++) 
     442        os << "TRIGGER-DN\t" << c.str() << "\t" << r.str() << "\t" << (*b)->rel().str() << endl; 
     443 
     444  for(Flag i=1; i<Flag::count(); ++i) 
     445    os << "FLAG\t" << i.str() << endl; 
     446} 
     447 
     448 
     449 
     450 
     451 
     452 
     453 
     454 
     455 
     456//================================= OLD 
    150457 
    151458void Grammar::write(FILE* f) 
    … …  
    155462 
    156463  for(Role i=1; i<Role::count(); ++i) 
    157     fprintf(f,"ROLE\t%s\n",i.str()); 
     464    fprintf(f,"ROLE\t%s (%d)(%d)\n",i.str(),Role::index(i.str()),chk_type(i.str())); 
    158465 
    159466  for(Role i=1; i<Role::count(); ++i) 
    … …  
    176483          fprintf(f,"LINK\t%s\t%s\t%s\n",c.str(),d.str(),t.str()); 
    177484 
     485  for(LongRel i=1; i<LongRel::count(); ++i) 
     486    fprintf(f,"LONG\t%s\n",i.str()); 
     487 
     488  for(Cat c=1; c<Cat::count(); ++c) 
     489    for(Cat d=1; d<Cat::count(); ++d) 
     490      for(LongRel l=1; l<LongRel::count(); ++l) 
     491        if(longrel[c][d].count(l)) 
     492          fprintf(f,"LLINK\t%s\t%s\t%s\n",c.str(),d.str(),l.str()); 
     493 
     494  for(Cat c=1; c<Cat::count(); ++c) 
     495    for(Role r=1; r<Role::count(); ++r) 
     496      for(list<Boubble*>::const_iterator b=uptrigger[c][r].begin(); b!=uptrigger[c][r].end(); b++) 
     497        fprintf(f,"#TRIGGER\t%s\t%s\t%s\n",c.str(),r.str(),(*b)->rel().str()); 
     498 
     499  for(Cat c=1; c<Cat::count(); ++c) 
     500    for(Role r=1; r<Role::count(); ++r) 
     501      for(list<Boubble*>::const_iterator b=dntrigger[c][r].begin(); b!=dntrigger[c][r].end(); b++) 
     502        fprintf(f,"#TRIGGER\t%s\t%s\t%s\n",c.str(),r.str(),(*b)->rel().str()); 
     503 
    178504  for(Flag i=1; i<Flag::count(); ++i) 
    179505    fprintf(f,"FLAG\t%s\n",i.str()); 
    180506} 
    181  

  • src/dgp/grammar.hh

    r5f4d9c3 re7de6cc  
    1010#include "thesymbols.hh" 
    1111#include "sgraph.hh" 
    12  
    13  
    14 class Link 
    15 { 
     12#include "boubble.hh" 
     13 
     14using namespace std; 
     15 
     16//enum PROP { INIT=0, FIN=1 }; 
     17//typedef bitset<16> PropSet; 
     18 
     19const PropSet EmptyPropSet = PropSet(); 
     20 
     21const FlagSet EmptyFlagSet = FlagSet(); 
     22 
     23//==================================================================================================== 
     24// class Link 
     25//==================================================================================================== 
     26 
     27struct Link 
     28{ 
     29  Link(Role r, Flag dfplus="NULL", Flag dfminus="NULL") : role(r), dflagplus(dfplus), dflagminus(dfminus) { } 
     30  Link(Role r, PropSet ps=EmptyPropSet, Flag hfp="NULL", Flag hfm="NULL", Flag dfp="NULL", Flag dfm="NULL") 
     31    : role(r), props(ps), hflagplus(hfp), hflagminus(hfm), dflagplus(dfp), dflagminus(dfm) { } 
     32  //Link(Role r) : role(r), dflagplus("NULL") { } 
     33 
    1634  Role role; 
    17   FlagSet hflags; 
    18   FlagSet dflags; 
     35  Flag hflagplus; 
     36  Flag hflagminus; 
     37  Flag dflagplus; 
     38  Flag dflagminus; 
     39  PropSet props; 
     40 
     41  bool operator<(const Link& l) const  
     42  { 
     43    if(role < l.role) return true; 
     44    if(hflagplus < l.hflagplus) return true; 
     45    if(hflagminus < l.hflagminus) return true; 
     46    if(dflagplus < l.dflagplus) return true; 
     47    if(dflagminus < l.dflagminus) return true; 
     48    if(props.to_ulong() < l.props.to_ulong()) return true; 
     49    return false; 
     50  } 
     51 
    1952}; 
    2053 
     54typedef set<Link> Links; 
     55 
     56//==================================================================================================== 
     57// class Grammar 
     58//==================================================================================================== 
    2159 
    2260class Grammar 
    … …  
    2563 public: 
    2664 
    27   //  enum CONSTR { SGL, OBL, LEFT, RIGHT, INIT, NONINIT, FIN, NONFIN }; 
    28  
    29   Grammar() : types_sz(0), cats_sz(0), flags_sz(0) {} ; 
     65  static const int RESIZE_DELTA=16; 
     66 
     67  Grammar() {} ; 
     68 
     69  Roles&  connectable(Cat h, Cat d); 
     70  Roles   connectable(Cat h, Cat d, FlagSet f, FlagSet df); 
     71 
     72  list<const Link*> connectable2(Cat h, Cat d, FlagSet hfs, FlagSet dfs); 
     73 
     74  bool    check_constr(NodeProp& hprop, NodeProp& dprop, int dir, Role role); 
     75  bool    check_constr2(NodeProp& hprop, NodeProp& dprop, int dir, const Link& link); 
     76 
     77  bool    check_longrel(Cat hcat, Cat dcat, LongRel rel); 
     78  bool    is_sgl(Role r); 
     79  RoleSet is_obl(Cat c); 
     80  
     81  RoleSet& constr_include(Role r) { return include[r]; }; 
     82  RoleSet& constr_exclude(Role r) { return exclude[r]; }; 
    3083   
    31   int types_sz; 
    32   int cats_sz; 
    33   int flags_sz; 
    34  
    35   vector< vector< Roles > >    connect; 
     84  FlagSet initial_flags(Cat c) { return set[c]; } 
     85  FlagSet pass_flags(Role r)   { return pass[r]; } 
     86 
     87  list<Boubble*>    trigger_boubbles(Cat c, Role r, Dir d); 
     88 
     89  bool    read(FILE* f); 
     90  void    write(ostream& os); 
     91  void    write(FILE* f); 
     92 
     93private: 
     94 
    3695  RoleSet                      sgl; 
    37   vector< RoleSet >            obl; 
     96  vector< RoleSet >            obl;      //[Cat] 
    3897  RoleSet                      left; 
    3998  RoleSet                      right; 
    40   vector< RoleSet >            lt; 
    41   vector< RoleSet >            gt; 
    42  
    43  
    44   //  vector< vector< vector< 
    45   vector< FlagSet >            set; 
    46   vector< FlagSet >            pass; 
    47  
    48   bool read(FILE* f); 
    49   void write(FILE* f); 
     99  RoleSet                      init; 
     100  RoleSet                      fin; 
     101  FlagSet                      initf; 
     102  FlagSet                      finf; 
     103 
     104  vector< RoleSet >            lt;       //[Role] 
     105  vector< RoleSet >            gt;       //[Role] 
     106 
     107  vector< FlagSet >            set;      //[Cat] 
     108  //  vector< FlagSet >            rset;     //[Role] 
     109  vector< FlagSet >            pass;     //[Role] 
     110 
     111  vector< vector< Roles > >    connect;  //[Cat][Cat] 
     112 
     113  vector< vector< Links > >    connect1; //[Cat][Cat] 
     114 
     115  vector< RoleSet >            include;  //[Role] 
     116  vector< RoleSet >            exclude;  //[Role] 
     117 
     118  vector< vector< LongRels > > longrel;  //[Cat][Cat] 
     119 
     120  list< Boubble* >              boubbles; 
     121   
     122  vector< vector< list<Boubble*> > >   uptrigger;//[Cat][Role] 
     123  vector< vector< list<Boubble*> > >   dntrigger;//[Cat][Role] 
    50124 
    51125  void add_category(const char* s); 
    52126  void add_type(const char* s); 
    53   void add_flag(const char* s); 
    54  
    55   void set_sgl(Role r)           { sgl.set(r); } 
    56   void set_obl(Cat c, Role r)    { obl[c].set(r); } 
    57   void set_left(Role r)          { left.set(r); } 
    58   void set_right(Role r)         { right.set(r); } 
    59   void set_order(Role r, Role s) { lt[s].set(r); } 
    60   void set_connect(Cat c, Cat d, Role r)   { connect[c][d].insert(r); } 
     127  void add_flag(const char* s)                   { Flag::add(s); } 
     128  void add_long(const char* l, const char* p)    { LongRel::add(l); boubbles.push_back( new Boubble(p,l) ); } 
     129  void add_triggers(Cat h, Cat d, LongRel l); 
     130 
     131  void set_sgl(Role r)                     { sgl.set(r); } 
     132  void set_obl(Cat c, Role r)              { obl[c].set(r); } 
     133  void set_left(Role r)                    { left.set(r); } 
     134  void set_right(Role r)                   { right.set(r); } 
     135  void set_init(Role r)                    { init.set(r); } 
     136  void set_fin(Role r)                     { fin.set(r); } 
     137  void set_initf(Flag f)                   { initf.set(f); } 
     138  void set_finf(Flag f)                    { finf.set(f); } 
     139  void set_order(Role r, Role s)           { lt[s].set(r); } 
     140 
     141  //  void set_connect(Cat c, Cat d, Role r)   { connect[c][d].insert(r); } 
     142  //  void set_connect(Cat c, Cat d, Flag f, Role r)   { connect1[c][d].insert(Link(r,f)); } 
     143 
     144  void set_connect(Cat h, Flag hfp, Flag hfm, Cat d, Flag dfp, Flag dfm, Role r, PropSet ps )   { connect1[h][d].insert(Link(r,ps,hfp,hfm,dfp,dfm)); } 
     145 
     146  void set_include(Role r, Role s)         { include[r].set(s); } 
     147  void set_exclude(Role r, Role s)         { exclude[r].set(s); } 
     148  void set_longrel(Cat c, Cat d, LongRel l){ longrel[c][d].insert(l); } 
     149  void set_set(Cat c, Flag f)              { set[c].set(f); } 
     150  void set_pass(Role r, Flag f)            { pass[r].set(f); } 
    61151  void set_lt(Role r, Role s); 
    62152  void compute_gt(); 
    63  
    64  
    65   bool check_constr(NodeProp& hprop, NodeProp& dprop, int dir, Role role); 
     153  void compute_triggers(); 
     154  bool contains_boubble(const list<Boubble*> boubble_list, Boubble* bp) const; 
    66155 
    67156}; 
    68157 
    69 inline bool Grammar::check_constr(NodeProp& hprop, NodeProp& dprop, int dir, Role role) 
     158//---------------------------------------------------------------------------------------------------- 
     159 
     160inline 
     161Roles&  Grammar::connectable(Cat h, Cat d) 
     162{ 
     163  return connect[h][d]; 
     164} 
     165 
     166//---------------------------------------------------------------------------------------------------- 
     167 
     168inline 
     169Roles Grammar::connectable(Cat h, Cat d, FlagSet hfs, FlagSet dfs)  // ZBYT WOLNE!!!!!!!!!!!!!!!!!!!!!!!!!! (-> Roles&) 
     170{ 
     171  Roles ret; 
     172  for(Links::const_iterator l = connect1[h][d].begin(); l != connect1[h][d].end(); l++) 
     173    if( (l->hflagplus==0 || hfs[l->hflagplus]) && (l->hflagminus==0 || !hfs[l->hflagminus]) ) 
     174      if( (l->dflagplus==0 || dfs[l->dflagplus]) && (l->dflagminus==0 || !dfs[l->dflagminus]) ) 
     175        ret.insert(l->role); 
     176  return ret; 
     177} 
     178 
     179//---------------------------------------------------------------------------------------------------- 
     180 
     181inline 
     182list<const Link*> Grammar::connectable2(Cat h, Cat d, FlagSet hfs, FlagSet dfs)  // ZBYT WOLNE!!!!!!!!!!!!!!!!!!!!!!!!!! (-> Roles&) 
     183{ 
     184  list<const Link*> ret; 
     185  for(Links::const_iterator l = connect1[h][d].begin(); l != connect1[h][d].end(); l++) 
     186    if( (l->hflagplus==0 || hfs[l->hflagplus]) && (l->hflagminus==0 || !hfs[l->hflagminus]) ) 
     187      if( (l->dflagplus==0 || dfs[l->dflagplus]) && (l->dflagminus==0 || !dfs[l->dflagminus]) ) 
     188        ret.push_back(&(*l)); 
     189  return ret; 
     190} 
     191 
     192//---------------------------------------------------------------------------------------------------- 
     193 
     194inline 
     195bool Grammar::check_constr(NodeProp& hprop, NodeProp& dprop, int dir, Role role)    // dir: 0-left 1-right 
    70196{ 
    71197  return  
    72198    !hprop.forbidden[role] && 
    73     ( !right[role] || dir==1 ) && 
    74     ( !left[role] || dir==0 ) 
     199    ( dir==1 || !right[role] ) && 
     200    ( dir==0 || !left[role]  ) && 
     201    ( dir==1 || (hprop.attached&init).none() ) && 
     202    ( dir==0 || (hprop.attached&fin).none() ) 
    75203    ; 
    76204} 
    77205 
     206//---------------------------------------------------------------------------------------------------- 
     207 
     208inline 
     209bool Grammar::check_constr2(NodeProp& hprop, NodeProp& dprop, int dir, const Link& link)    // dir: 0-left 1-right 
     210{ 
     211  return  
     212    !hprop.forbidden[link.role] && 
     213    ( dir==1 || !right[link.role] ) && 
     214    ( dir==0 || !left[link.role]  ) && 
     215    ( dir!=0 || !hprop.init_attached ) && 
     216    ( dir!=1 || !hprop.fin_attached ) 
     217    ; 
     218} 
     219 
     220//---------------------------------------------------------------------------------------------------- 
     221 
     222inline 
     223bool Grammar::check_longrel(Cat hcat, Cat dcat, LongRel rel) 
     224{ 
     225  return longrel[hcat][dcat].find(rel) != longrel[hcat][dcat].end(); 
     226} 
     227 
     228//---------------------------------------------------------------------------------------------------- 
     229 
     230inline bool Grammar::is_sgl(Role r) 
     231{ 
     232  return sgl[r]; 
     233} 
     234 
     235//---------------------------------------------------------------------------------------------------- 
     236 
     237inline RoleSet Grammar::is_obl(Cat c) 
     238{ 
     239  return obl[c]; 
     240} 
     241 
     242//==================================================================================================== 
    78243 
    79244#endif 

  • src/dgp/main.cc

    r5f4d9c3 re7de6cc  
    1111#include "sgraph.hh" 
    1212#include "grammar.hh" 
    13 #include "dgp0.hh" 
     13#include "dgp1.hh" 
    1414#include "../common/common.h" 
    1515#include "cmdline.h" 
    … …  
    2525Grammar grammar; 
    2626MGraph mgraph; 
    27 SGraph sgraph; 
     27SGraph sgraph(mgraph); 
    2828 
    2929FILE* grammarf; 
    … …  
    6565  fclose(grammarf); 
    6666 
     67 
     68 
     69  // grammar.write(cout); 
     70  // exit(0); 
     71 
     72 
     73 
    6774  mgraph.clear(); 
    6875  sgraph.clear(); 
    … …  
    8390    if(strcmp(segtype,"EOS")==0) 
    8491    { 
    85       dgp0(); // parametry!!! MGraph, SGraph, Grammar 
     92      dgp1(); // parametry!!! MGraph, SGraph, Grammar 
    8693      output(); 
    8794       
    … …  
    105112    if(seg_mnode[si]>=0) 
    106113    { 
    107       MNode& m=mgraph.nodes[seg_mnode[si]]; 
     114      MNode& m=mgraph[seg_mnode[si]]; 
    108115      for(vector<int>::iterator s=m.snodes.begin(); s!=m.snodes.end(); ++s) 
    109116      { 

  • src/dgp/mgraph.cc

    r5f4d9c3 re7de6cc  
    44#include "const.hh" 
    55 
    6 #include <stdio.h> 
     6#include <cstdio> 
    77 
    88int MGraph::add_node(char* seg) 
    99{ 
    10   nodes[n].clear(); 
     10  MNode newnode; 
     11  newnode.clear(); 
    1112   
    12   char field1[80], field3[80], descr[256], gph[256]; 
     13  char field1[80], field3[80], field4[256], descr[256], gph[256]; 
    1314  char* cat; 
    1415   
    1516  getfield(seg,"1",field1); 
    16   nodes[n].pos=atoi(field1); 
     17  newnode.pos=atoi(field1); 
    1718 
    1819  getfield(seg,"3",field3); 
     20 
     21  getfield(seg,"4",field4); 
     22  strcpy(newnode.form,field4); 
     23 
    1924  if(!getfield(seg,"lem",descr)) strcpy(descr,"?,?"); 
    2025 
    … …  
    2328  if(*cat) ++cat; 
    2429   
    25 //  Cat::add(cat); 
    2630  if(Cat::index(cat)>0) 
    27     nodes[n].cat=cat; 
     31    newnode.cat=cat; 
    2832  else 
    29     nodes[n].cat="NULL"; 
     33    newnode.cat="NULL"; 
    3034   
    31   nodes[n].pred.clear(); 
     35  newnode.pred.clear(); 
    3236   
    3337  char* tok; 
    … …  
    4145 
    4246  char* ids=strtok(gph,":"); 
    43   if(n!=atoi(ids)){fprintf(stderr,"Invalid node id in line ?. Program aborted.\n"); exit(1); } 
     47  if(size() != atoi(ids)) {fprintf(stderr,"Invalid node id in line ?. Program aborted.\n"); exit(1); } 
    4448   
    4549  char *preds; 
    … …  
    4751  { 
    4852    previd=atoi(preds); 
    49     nodes[n].pred.push_back(&nodes[previd]); 
     53    newnode.pred.push_back(previd); 
    5054  } 
    5155 
    52   return n++; 
     56  nodes.push_back(newnode); 
     57  return nodes.size()-1; 
    5358} 
    5459 

  • src/dgp/mgraph.hh

    r5f4d9c3 re7de6cc  
    88#include "../common/common.h" 
    99 
     10 
     11using namespace std; 
     12 
    1013class MNode 
    1114{ 
    1215public: 
    1316 
    14   char           type[MAXFORMLEN]; 
     17  int            pos; 
     18  char           form[256]; 
    1519  Cat            cat; 
    16   int            pos; 
    17   vector<MNode*> pred; 
     20  vector<int>    pred; 
    1821  vector<int>    snodes; 
    1922 
    2023  void           clear() { snodes.clear(); }; 
    2124}; 
    22  
     25  
    2326class MGraph 
    2427{ 
    25  public: 
     28public: 
    2629 
    27   MNode nodes[MAXNODES]; 
    28   int   n; 
     30  void clear() { nodes.clear(); } 
     31  int size() { return nodes.size(); } 
     32  int add_node(char* seg); 
     33  MNode& operator[](int i) { return nodes[i]; } 
    2934 
    30   void clear() { n=0; }; 
    31   int add_node(char* seg); 
     35private: 
     36 
     37  vector<MNode> nodes; 
     38 
    3239}; 
    3340 

  • src/dgp/sgraph.cc

    r5f4d9c3 re7de6cc  
    11#include "global.hh" 
    22#include "sgraph.hh" 
    3 #include "mgraph.hh" 
    43#include "grammar.hh" 
    54#include "const.hh" 
    6 #include <stdio.h> 
     5#include <cstdio> 
     6#include <sstream> 
    77 
     8extern MGraph mgraph; 
    89 
    9 int SGraph::add_base_snode(MNode* mn) 
     10//==================================================================================================== 
     11 
     12int SGraph::add_base_snode(int mnodeind) 
    1013{ 
    11   int nodeind=n; 
    12   SNode &node=nodes[n]; 
     14  SNode& newnode =  makenewnode();  
    1315 
    14   node.clear(); 
     16  newnode.mnode=mnodeind; 
    1517 
    16   node.mnode=mn; 
    17  
    18   for(vector<MNode*>::iterator pm=node.mnode->pred.begin(); pm!=node.mnode->pred.end(); ++pm) 
    19     for(vector<int>::iterator ps=(*pm)->snodes.begin(); ps!=(*pm)->snodes.end(); ++ps) 
     18  for(vector<int>::iterator pm=mgraph[newnode.mnode].pred.begin(); pm!=mgraph[newnode.mnode].pred.end(); ++pm) 
     19    for(vector<int>::iterator ps=mgraph[*pm].snodes.begin(); ps!=mgraph[*pm].snodes.end(); ++ps) 
    2020      if(nodes[*ps].in_LH) 
    2121      { 
    22         node.LV.set(*ps); 
    23         if(nodes[*ps].saturated()) node.LV |= nodes[*ps].LH; 
     22        newnode.LV.set(*ps); 
     23        if(nodes[*ps].saturated()) newnode.LV |= nodes[*ps].LH; 
    2424      } 
    2525 
    26   mn->snodes.push_back(nodeind); 
    27   ++n; 
     26  mgraph[newnode.mnode].snodes.push_back(lastnodeind()); 
    2827 
    29   node.in_LH=true; 
     28  newnode.in_LH=true; 
    3029 
    31   return nodeind; 
     30  return lastnodeind(); 
    3231} 
    3332 
     33//==================================================================================================== 
    3434 
    3535void SGraph::update_left(int headind, int depind) 
    … …  
    3737  SNode &head=nodes[headind], &dep=nodes[depind]; 
    3838 
    39   if(dep.saturated()) head.LV |= dep.LV, head.LD |= dep.LD; 
     39  if(dep.saturated())  head.LV |= dep.LV, head.LD |= dep.LD; 
    4040} 
    4141 
    … …  
    4646 
    4747  dep.LH.set(headind); 
    48   if(head.saturated()) 
    49     dep.LH |= head.LH; 
    50 } 
     48  if(head.saturated())  dep.LH |= head.LH; 
     49}  
    5150 
     51//==================================================================================================== 
    5252 
    5353int SGraph::clone(int ancind, NodeProp newprop) 
    5454{ 
    55   int newind = n++; 
    56   SNode &newnode=nodes[newind]; 
     55  SNode &newnode=makenewnode(); 
    5756  SNode &ancnode = nodes[ancind]; 
    5857 
    59   newnode.clear(); 
     58 
     59 
    6060  newnode.prop=newprop; 
    6161  newnode.mnode=ancnode.mnode; 
    62   newnode.mnode->snodes.push_back(newind); 
    63   return newind; 
     62  mgraph[newnode.mnode].snodes.push_back(lastnodeind()); 
     63 
     64  return lastnodeind(); 
    6465} 
    6566 
    66  
    67 //------------------------------------------------------------------------- 
    68 //------------------------------------------------------------------------- 
    69  
     67//==================================================================================================== 
    7068 
    7169int SGraph::print_node(FILE* f, int n, unsigned int info) 
    7270{ 
    73   char buf[1000]; 
    74   sprint_node(buf,n,info); 
     71  char buf[50000]; 
     72  sprint_node(buf,n,-1,info); 
    7573  fputs(buf,f); 
    7674} 
    7775 
    78 int SGraph::sprint_node(char* buf, int nodeind, unsigned int info) 
     76//---------------------------------------------------------------------------------------------------- 
     77 
     78int SGraph::print_node_debug(FILE* f, const char* pref, int n, int anc) 
     79{ 
     80  char buf[50000]; 
     81  sprint_node_debug(buf,pref,n,anc); 
     82  fputs(buf,f); 
     83} 
     84 
     85//---------------------------------------------------------------------------------------------------- 
     86 
     87void SGraph::print_arc(FILE* f, int head, int dep, Role role, int dir) // 0 - left, 1 - right 
     88{ 
     89  if(dir==0) 
     90    fprintf(f,"#A  %s:%d <-- %d\n", role.str(), dep, head); 
     91  else 
     92    fprintf(f,"#A  %s:%d --> %d\n", role.str(), head, dep); 
     93} 
     94 
     95//==================================================================================================== 
     96 
     97int SGraph::sprint_node(char* buf, int nodeind, int anc, unsigned int info) 
    7998{ 
    8099  char* buf0=buf; 
    81   char descr[256]; 
    82   char nodeinfo[16]; 
    83100 
    84101  SNode &node=nodes[nodeind]; 
    85102 
    86103  buf+=sprintf(buf," dgp:%d",nodeind); 
     104  if(anc>=0) buf+=sprintf(buf,"(%d)",anc); 
    87105  buf+=sprintf(buf, saturated(nodeind) ? ";s" : ";u"); 
    88106 
     107  if (info&HEADS || info&DEPS) 
     108    buf+=sprintf(buf,";"); 
     109 
    89110  bool cont=false; 
     111 
    90112  if (info&HEADS) 
    91   { 
    92     buf+=sprintf(buf,";"); 
    93113    for(vector<Arc>::iterator h=node.heads.begin(); h!=node.heads.end(); ++h) 
    94114    { 
    95115      if(cont) buf+=sprintf(buf,","); else cont=true; 
    96       buf+=sprintf(buf,"++%s-%d/%d",h->role.str(),h->dst,h->anc); 
     116      buf+=sprintf(buf,"++%s-%d(%d~%d)",h->role.str(),h->dst,h->headanc,h->depanc); 
    97117    } 
    98   } 
    99    
     118 
    100119  if (info&DEPS) 
    101   { 
    102     buf+=sprintf(buf,";"); 
    103120    for(vector<Arc>::iterator d=node.deps.begin(); d!=node.deps.end(); ++d) 
    104121    { 
    105122      //      if(! nodes[d->dst].saturated()) continue; // NIE DRUKUJ NIENASYCONYCH PODRZEDNIKOW 
    106123      if(cont) buf+=sprintf(buf,","); else cont=true; 
    107       buf+=sprintf(buf,"--%s-%d/%d",d->role.str(),d->dst,d->anc); 
     124      buf+=sprintf(buf,"--%s-%d(%d~%d)",d->role.str(),d->dst,d->headanc,d->depanc); 
    108125    } 
    109   } 
    110126   
    111127  if (info&SETS) 
    … …  
    113129    int ord=0; 
    114130    buf+=sprintf(buf,";{"); 
    115     for(vector<MNode*>::iterator pm=node.mnode->pred.begin(); pm!=node.mnode->pred.end(); ++pm) 
    116       for(vector<int>::iterator ps=(*pm)->snodes.begin(); ps!=(*pm)->snodes.end(); ++ps) 
     131    for(vector<int>::iterator pm=mgraph[node.mnode].pred.begin(); pm!=mgraph[node.mnode].pred.end(); ++pm) 
     132      for(vector<int>::iterator ps=mgraph[*pm].snodes.begin(); ps!=mgraph[*pm].snodes.end(); ++ps) 
    117133        buf+=sprintf(buf, ord++ ? ",%d" : "%d", *ps); 
    118134    buf+=sprintf(buf,"};{"); 
    119     ord=0;for(int j=0; j<=n; ++j) if(node.LV[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
     135    ord=0;for(int j=0; j<size(); ++j) if(node.LV[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
    120136    buf+=sprintf(buf,"};{"); 
    121     ord=0;for(int j=0; j<=n; ++j) if(node.LH[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
     137    ord=0;for(int j=0; j<size(); ++j) if(node.LH[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
    122138    buf+=sprintf(buf,"};{"); 
    123     ord=0;for(int j=0; j<=n; ++j) if(node.LD[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
     139    ord=0;for(int j=0; j<size(); ++j) if(node.LD[j]) buf+=sprintf(buf, ord++ ? ",%d" : "%d", j); 
    124140    buf+=sprintf(buf,"}"); 
    125141  } 
    … …  
    133149    for(Role i=1; i<=Role::count(); ++i) 
    134150      if(node.prop.required[i]) buf+=sprintf(buf,"%s&%s",(cont++)?",":"",i.str()); 
     151    for(Role i=1; i<=Role::count(); ++i) 
     152      if(node.prop.attached[i]) buf+=sprintf(buf,"%s+%s",(cont++)?",":"",i.str()); 
     153    for(Flag i=1; i<=Flag::count(); ++i) 
     154      if(node.prop.flags [i]) buf+=sprintf(buf,"%s<%s>",(cont++)?",":"",i.str()); 
     155    if(node.prop.init_attached) 
     156      buf+=sprintf(buf,"<init>"); 
     157    if(node.prop.fin_attached) 
     158      buf+=sprintf(buf,"<fin>"); 
     159 
     160    stringstream oss; 
     161    for(list<Boubble*>::iterator b = node.prop.boubbles.begin(); b != node.prop.boubbles.end(); b++) 
     162      oss << (cont++ ? "," : "") << **b; 
     163    buf+=sprintf(buf,oss.str().c_str()); 
    135164  } 
    136165   
    … …  
    141170 
    142171 
    143 int SGraph::sprint_node_debug(char* buf, const char* pref, int n) 
     172int SGraph::sprint_node_debug(char* buf, const char* pref, int n, int anc) 
    144173{ 
    145174  char *buf0 = buf; 
    146175  buf+=sprintf(buf,"#%s",pref); 
    147   buf+=sprint_node(buf,n,HEADS|DEPS|SETS|CONSTRAINTS); 
     176 
     177  buf+=sprintf(buf,"%-16s",form(n)); 
     178 
     179  buf+=sprint_node(buf,n,anc,HEADS|DEPS|SETS|CONSTRAINTS); 
    148180  buf+=sprintf(buf,"\n"); 
    149181  return buf-buf0; 
    150182} 
    151183 
    152 int SGraph::print_node_debug(FILE* f, const char* pref, int n) 
    153 { 
    154   char buf[1000]; 
    155   sprint_node_debug(buf,pref,n); 
    156   fputs(buf,f); 
    157 } 
    158  
    159 void SGraph::print_arc(FILE* f, int left, int right, Role role, int dir) // 0 - left, 1 - right 
    160 { 
    161   fprintf(f,"#   %s:%s.%02d %s %s.%02d\n", 
    162           role.str(),nodes[left].mnode->type,left, 
    163           dir ? "-->" : "<--", 
    164           nodes[right].mnode->type,right); 
    165 } 

  • src/dgp/sgraph.hh

    r5f4d9c3 re7de6cc  
    99 
    1010#include "const.hh" 
     11#include "mgraph.hh" 
    1112#include "thesymbols.hh" 
    12  
    13  
    14 class MNode; 
    15  
    16  
     13#include "boubble.hh" 
     14 
     15 
     16using namespace std; 
     17 
     18//==================================================================================================== 
     19// CLASS Arc 
     20//==================================================================================================== 
    1721struct Arc 
    1822{ 
    1923  int dst; 
    2024  Role role; 
    21   int anc; 
     25  int headanc; 
     26  int depanc; 
    2227  
    23   Arc(int d, Role r, int a) : dst(d), role(r), anc(a) {}; 
    24  }; 
    25  
     28  Arc(int d, Role r, int ha, int da) : dst(d), role(r), headanc(ha), depanc(da) {}; 
     29}; 
     30 
     31//==================================================================================================== 
     32// CLASS NodeProp 
     33//==================================================================================================== 
    2634 
    2735struct NodeProp 
    2836{ 
    29   bitset<MAXTYPES> required; 
    30   bitset<MAXTYPES> forbidden; 
    31  
    32   bool operator==(const NodeProp& p) 
    33   { return required==p.required && forbidden==p.forbidden; } 
    34  
    35   void clear() 
    36   { required.reset(), forbidden.reset(); } 
    37  
    38 }; 
    39  
     37  NodeProp(); 
     38  NodeProp(const NodeProp& p); 
     39  ~NodeProp(); 
     40 
     41  bool operator==(const NodeProp& p); 
     42  NodeProp& operator=(const NodeProp& p); 
     43 
     44  void clear_boubbles(); 
     45  void merge_boubbles(list<Boubble*> new_boubbles); 
     46 
     47  void copy(const NodeProp& p); 
     48  void clear(); 
     49 
     50  RoleSet required; 
     51  RoleSet forbidden; 
     52  RoleSet attached; 
     53 
     54  bool init_attached; 
     55  bool fin_attached; 
     56   
     57  FlagSet flags; 
     58 
     59  list<Boubble*>   boubbles; 
     60}; 
     61 
     62//---------------------------------------------------------------------------------------------------- 
     63 
     64inline 
     65bool NodeProp::operator==(const NodeProp& p) 
     66{ 
     67  if(required != p.required) return false; 
     68  if(forbidden != p.forbidden) return false; 
     69  if(attached != p.attached) return false; 
     70  if(flags != p.flags) return false; 
     71  if(init_attached != p.init_attached) return false; 
     72  if(fin_attached != p.fin_attached) return false; 
     73   
     74  list<Boubble*>::const_iterator b1 = p.boubbles.begin(); 
     75  for(list<Boubble*>::const_iterator b = boubbles.begin(); b != boubbles.end(); b++) 
     76    { 
     77      if(b1 == p.boubbles.end()) 
     78        return false; 
     79      if(!(**b == **b1)) 
     80        return false; 
     81    } 
     82  if(b1 != p.boubbles.end()) 
     83    return false; 
     84   
     85  return true; 
     86} 
     87 
     88//---------------------------------------------------------------------------------------------------- 
     89 
     90inline 
     91void NodeProp::clear_boubbles() 
     92{ 
     93  for(list<Boubble*>::iterator b = boubbles.begin(); b!=boubbles.end(); b++) 
     94    delete *b; 
     95  boubbles.clear(); 
     96} 
     97 
     98//---------------------------------------------------------------------------------------------------- 
     99 
     100inline 
     101void NodeProp::merge_boubbles(list<Boubble*> new_boubbles) 
     102{ 
     103  boubbles.merge(new_boubbles); 
     104} 
     105 
     106//---------------------------------------------------------------------------------------------------- 
     107 
     108inline 
     109void NodeProp::copy(const NodeProp& p) 
     110{ 
     111  required=p.required; 
     112  forbidden=p.forbidden; 
     113  attached=p.attached; 
     114  flags=p.flags; 
     115  init_attached=p.init_attached; 
     116  fin_attached=p.fin_attached; 
     117  for(list<Boubble*>::const_iterator b = p.boubbles.begin(); b!=p.boubbles.end(); b++) 
     118    boubbles.push_back(new Boubble(**b)); 
     119} 
     120 
     121//---------------------------------------------------------------------------------------------------- 
     122 
     123inline 
     124NodeProp::~NodeProp() 
     125{ 
     126  clear_boubbles(); 
     127} 
     128//---------------------------------------------------------------------------------------------------- 
     129 
     130inline 
     131NodeProp::NodeProp() 
     132{ 
     133  clear(); 
     134} 
     135 
     136//---------------------------------------------------------------------------------------------------- 
     137 
     138inline 
     139NodeProp::NodeProp(const NodeProp& p) 
     140{ 
     141  copy(p); 
     142} 
     143 
     144//---------------------------------------------------------------------------------------------------- 
     145 
     146inline 
     147NodeProp& NodeProp::operator=(const NodeProp& p) 
     148{ 
     149  clear(); 
     150  copy(p); 
     151  return *this; 
     152} 
     153 
     154//---------------------------------------------------------------------------------------------------- 
     155 
     156inline 
     157void NodeProp::clear() 
     158{ 
     159  required.reset(); 
     160  forbidden.reset(); 
     161  attached.reset(); 
     162  init_attached=false; 
     163  fin_attached=false; 
     164  clear_boubbles(); 
     165} 
     166 
     167//==================================================================================================== 
     168// CLASS SNode 
     169//==================================================================================================== 
    40170 
    41171struct SNode 
    42172{ 
    43173   
    44   MNode* mnode; 
     174  int mnode; 
    45175 
    46176  NodeProp prop; 
    … …  
    54184  vector<Arc> deps; 
    55185 
    56   void clear()      { prop.clear(), LV.reset(), LD.reset(), LH.reset(), heads.clear(), deps.clear(); } 
    57   bool saturated()  { return prop.required.none(); } 
    58 }; 
    59  
    60  
     186  void clear(); 
     187  bool saturated(); 
     188}; 
     189 
     190//---------------------------------------------------------------------------------------------------- 
     191inline 
     192void SNode::clear() 
     193{ prop.clear(), LV.reset(), LD.reset(), LH.reset(), heads.clear(), deps.clear(); } 
     194//---------------------------------------------------------------------------------------------------- 
     195inline 
     196bool SNode::saturated() 
     197{ return prop.required.none(); } 
     198 
     199//==================================================================================================== 
     200// SGraph CLASS 
     201//==================================================================================================== 
    61202 
    62203class SGraph 
    … …  
    64205public: 
    65206 
    66   SNode nodes[MAXNODES]; 
    67   int n; // number of nodes 
    68  
    69   enum Output { HEADS=1, DEPS=2, SETS=4, CONSTRAINTS=8 }; 
    70  
    71   SGraph() : n(0) {} 
    72  
    73   void clear() { n=0; } 
    74   
    75   int add_base_snode(MNode* mn); 
    76   int clone(int ancind, NodeProp newprop); 
     207  enum Output { HEADS=1, DEPS=2, SETS=4, CONSTRAINTS=8, BOUBBLES=16 }; 
     208 
     209  SGraph(MGraph& mg) : mgraph(mg)               { clear(); } 
     210 
     211  SNode& operator[](const int i)                { return nodes[i]; } 
     212 
     213  void clear()                                  { nodes.clear(); } 
     214  int  add_base_snode(int mnodeind); 
     215  int  clone(int ancind, NodeProp newprop); 
    77216  void update_left(int headind, int depind); 
    78217  void update_right(int headind, int depind); 
    79  
    80218  bool visible(int left, int right); 
    81219  bool saturated(int node); 
    82220 
    83   //-------------------------------------------------------------------- 
    84  
    85   void read(FILE* f); 
    86   void write(FILE* f, list<int> nodelist, unsigned int info); 
    87  
    88   int sprint_node(char* buf, int n, unsigned int info); 
     221  Cat  cat(int i) const { return mgraph[nodes[i].mnode].cat; }     
     222  char* form(int i) const { return mgraph[nodes[i].mnode].form; } 
     223 
    89224  int print_node(FILE* f, int n, unsigned int info); 
    90   int sprint_node_debug(char* buf, const char* pref, int n); 
    91   int print_node_debug(FILE* f, const char* pref, int n); 
     225  int print_node_debug(FILE* f, const char* pref, int n, int anc); 
    92226 
    93227  void print_arc(FILE* f, int left, int right, Role role, int dir); // 0 - left, 1 - right 
    94228 
    95 }; 
    96  
     229  //private: 
     230 
     231  int size()              {return nodes.size(); } 
     232 
     233private: 
     234 
     235  MGraph& mgraph; 
     236   
     237  vector<SNode> nodes; 
     238 
     239  int lastnodeind()       { return nodes.size()-1; } 
     240  SNode& makenewnode()    { nodes.push_back(SNode()); nodes.back().clear(); return nodes.back(); } 
     241 
     242  int sprint_node(char* buf, int n, int anc, unsigned int info); 
     243  int sprint_node_debug(char* buf, const char* pref, int n, int anc); 
     244}; 
     245 
     246//---------------------------------------------------------------------------------------------------- 
    97247 
    98248inline bool SGraph::visible(int left, int right) 
    … …  
    101251} 
    102252 
     253//---------------------------------------------------------------------------------------------------- 
     254 
    103255inline bool SGraph::saturated(int node) 
    104256{ 
    … …  
    106258} 
    107259 
     260//---------------------------------------------------------------------------------------------------- 
     261 
    108262#endif 

  • src/dgp/symbol.hh

    r5f4d9c3 re7de6cc  
    33 
    44#include <ext/hash_map> 
    5 //#include <ext/hash_fun.h> 
    65#include <string> 
    7 #include <string.h> 
     6#include <cstring> 
    87#include <fstream> 
    98#include <vector> 
    … …  
    5857/// Symbol class template.  
    5958/** The template argument determines the symbol space. 
    60     Each space is created with symbol "NULL" with indexed 0 already in. 
     59    Each space is created with symbol "NULL" with index 0 already in. 
    6160*/ 
    6261 
    … …  
    104103 
    105104  Symbol(const char * s) : val(defs[s]) {}; 
    106    
     105 
     106  Symbol(string s) : val(defs[(char*)s]) {}; 
     107 
     108 
     109  bool empty() const { return val==0; } 
     110 
    107111  /// Symbol to char* conversion. If symbol is invalid, NULL is returned. 
    108112  const char* str() const { return (val>=0 && val<count())?defs[val]:NULL; }; 
    … …  
    113117      s=0; while(++s) ... 
    114118   */ 
     119 
    115120  (operator int)() const { return val; }; 
    116121 

  • src/dgp/thesymbols.hh

    r5f4d9c3 re7de6cc  
    99#include <bitset> 
    1010 
    11 typedef Symbol<1> Cat; 
     11using namespace std; 
    1212 
    13 typedef Symbol<2> Role; 
    14 typedef list<Role> RoleList; 
    15 typedef list<Role>::iterator RoleListIter; 
    16 typedef bitset<MAXTYPES> RoleSet; 
    17 typedef set<Role> Roles; 
    18 typedef Roles::iterator RolesIter; 
     13typedef Symbol<1>              Cat; 
     14typedef bitset<MAXCATS>        CatSet; 
    1915 
    20 typedef Symbol<3> Constr; 
    21 typedef list<Constr> ConstrList; 
     16typedef Symbol<2>              Role; 
     17typedef list<Role>             RoleList; 
     18typedef list<Role>::iterator   RoleListIter; 
     19typedef bitset<MAXTYPES>       RoleSet; 
     20typedef set<Role>              Roles; 
     21typedef Roles::iterator        RolesIter; 
     22 
     23typedef Symbol<3>              Constr; 
     24typedef list<Constr>           ConstrList; 
    2225typedef list<Constr>::iterator ConstrListIter; 
    2326 
    24 typedef Symbol<4> Rel; 
     27typedef Symbol<4>              LongRel; 
     28typedef set<LongRel>           LongRels; 
    2529 
    26 typedef Symbol<5> Flag; 
    27 typedef bitset<MAXFLAGS> FlagSet; 
     30typedef Symbol<5>              Flag; 
     31typedef bitset<MAXFLAGS>       FlagSet; 
     32 
     33typedef Symbol<6>              Prop; 
     34typedef bitset<MAXPROPS>       PropSet; 
    2835 
    2936#endif 

  • src/gph/gph

    r5f4d9c3 re7de6cc  
    1414 
    1515 
    16 my $systemconfigfile='/usr/local/etc/utt/gph.conf'; 
     16my $systemconfigfile='/etc/utt/gph.conf'; 
    1717my $userconfigfile=home()."/.utt/gph.conf"; 
    1818 
Note: See TracChangeset for help on using the changeset viewer.