[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
[1230]
[1231]
[1232]
[1233]
[1234]
[1235]
[1236]
[1237]
[1238]
[1239]
[1240]
[1241]
[1242]
[1243]
[1244]
[1245]
[1246]
[1247]
[1248]
[1249]
[1250]
[1251]
[1252]
[1253]
[1254]
[1255]
[1256]
[1257]
[1258]
[1259]
[1260]
[1261]
[1262]
[1263]
[1264]
[1265]
[1266]
[1267]
[1268]
[1269]
[1270]
[1271]
[1272]
[1273]
[1274]
[1275]
[1276]
[1277]
[1278]
[1279]
[1280]
[1281]
[1282]
[1283]
[1284]
[1285]
[1286]
[1287]
[1288]
[1289]
[1290]
[1291]
[1292]
[1293]
[1294]
[1295]
[1296]
[1297]
[1298]
[1299]
[1300]
[1301]
[1302]
[1303]
[1304]
[1305]
[1306]
[1307]
[1308]
[1309]
[1310]
[1311]
[1312]
[1313]
[1314]
[1315]
[1316]
[1317]
[1318]
[1319]
[1320]
[1321]
[1322]
[1323]
[1324]
[1325]
[1326]
[1327]
[1328]
[1329]
[1330]
[1331]
[1332]
[1333]
[1334]
[1335]
[1336]
[1337]
[1338]
[1339]
[1340]
[1341]
[1342]
[1343]
[1344]
[1345]
[1346]
[1347]
[1348]
[1349]
[1350]
[1351]
[1352]
[1353]
[1354]
[1355]
[1356]
[1357]
[1358]
[1359]
[1360]
[1361]
[1362]
[1363]
[1364]
[1365]
[1366]
[1367]
[1368]
[1369]
[1370]
[1371]
[1372]
[1373]
[1374]
[1375]
[1376]
[1377]
[1378]
[1379]
[1380]
[1381]
[1382]
[1383]
[1384]
[1385]
[1386]
[1387]
[1388]
[1389]
[1390]
[1391]
[1392]
[1393]
[1394]
[1395]
[1396]
[1397]
[1398]
[1399]
[1400]
[1401]
[1402]
[1403]
[1404]
[1405]
[1406]
[1407]
[1408]
[1409]
[1410]
[1411]
[1412]
[1413]
[1414]
[1415]
[1416]
[1417]
[1418]
[1419]
[1420]
[1421]
[1422]
[1423]
[1424]
[1425]
[1426]
[1427]
[1428]
[1429]
[1430]
[1431]
[1432]
[1433]
[1434]
[1435]
[1436]
[1437]
[1438]
[1439]
[1440]
[1441]
[1442]
[1443]
[1444]
[1445]
[1446]
[1447]
[1448]
[1449]
[1450]
[1451]
[1452]
[1453]
[1454]
[1455]
[1456]
[1457]
[1458]
[1459]
[1460]
[1461]
[1462]
[1463]
[1464]
[1465]
[1466]
[1467]
[1468]
[1469]
[1470]
[1471]
[1472]
[1473]
[1474]
[1475]
[1476]
[1477]
[1478]
[1479]
[1480]
[1481]
[1482]
[1483]
[1484]
[1485]
[1486]
[1487]
[1488]
[1489]
[1490]
[1491]
[1492]
[1493]
[1494]
[1495]
[1496]
[1497]
[1498]
[1499]
[1500]
[1501]
[1502]
[1503]
[1504]
[1505]
[1506]
[1507]
[1508]
[1509]
[1510]
[1511]
[1512]
[1513]
[1514]
[1515]
[1516]
[1517]
[1518]
[1519]
[1520]
[1521]
[1522]
[1523]
[1524]
[1525]
[1526]
[1527]
[1528]
[1529]
[1530]
[1531]
[1532]
[1533]
[1534]
[1535]
[1536]
[1537]
[1538]
[1539]
[1540]
[1541]
[1542]
[1543]
[1544]
[1545]
[1546]
[1547]
[1548]
[1549]
[1550]
[1551]
[1552]
[1553]
[1554]
[1555]
[1556]
[1557]
[1558]
[1559]
[1560]
[1561]
[1562]
[1563]
[1564]
[1565]
[1566]
[1567]
[1568]
[1569]
[1570]
[1571]
[1572]
[1573]
[1574]
[1575]
[1576]
[1577]
[1578]
[1579]
[1580]
[1581]
[1582]
[1583]
[1584]
[1585]
[1586]
[1587]
[1588]
[1589]
[1590]
[1591]
[1592]
[1593]
[1594]
[1595]
[1596]
[1597]
[1598]
[1599]
[1600]
[1601]
[1602]
[1603]
[1604]
[1605]
[1606]
[1607]
[1608]
[1609]
[1610]
[1611]
[1612]
[1613]
[1614]
[1615]
[1616]
[1617]
[1618]
[1619]
[1620]
[1621]
[1622]
[1623]
[1624]
[1625]
[1626]
[1627]
[1628]
[1629]
[1630]
[1631]
[1632]
[1633]
[1634]
[1635]
[1636]
[1637]
[1638]
[1639]
[1640]
[1641]
[1642]
[1643]
[1644]
[1645]
[1646]
[1647]
[1648]
[1649]
[1650]
[1651]
[1652]
[1653]
[1654]
[1655]
[1656]
[1657]
[1658]
[1659]
[1660]
[1661]
[1662]
[1663]
[1664]
[1665]
[1666]
[1667]
[1668]
[1669]
[1670]
[1671]
[1672]
[1673]
[1674]
[1675]
[1676]
[1677]
[1678]
[1679]
[1680]
[1681]
[1682]
[1683]
[1684]
[1685]
[1686]
[1687]
[1688]
[1689]
[1690]
[1691]
[1692]
[1693]
[1694]
[1695]
[1696]
[1697]
[1698]
[1699]
[1700]
[1701]
[1702]
[1703]
[1704]
[1705]
[1706]
[1707]
[1708]
[1709]
[1710]
[1711]
[1712]
[1713]
[1714]
[1715]
[1716]
[1717]
[1718]
[1719]
[1720]
[1721]
[1722]
[1723]
[1724]
[1725]
[1726]
[1727]
[1728]
[1729]
[1730]
[1731]
[1732]
[1733]
[1734]
[1735]
[1736]
[1737]
[1738]
[1739]
[1740]
[1741]
[1742]
[1743]
[1744]
[1745]
[1746]
[1747]
[1748]
[1749]
[1750]
[1751]
[1752]
[1753]
[1754]
[1755]
[1756]
[1757]
[1758]
[1759]
[1760]
[1761]
[1762]
[1763]
[1764]
[1765]
[1766]
[1767]
[1768]
[1769]
[1770]
[1771]
[1772]
[1773]
[1774]
[1775]
[1776]
[1777]
[1778]
[1779]
[1780]
[1781]
[1782]
[1783]
[1784]
[1785]
[1786]
[1787]
[1788]
[1789]
[1790]
[1791]
[1792]
[1793]
[1794]
[1795]
[1796]
[1797]
[1798]
[1799]
[1800]
[1801]
[1802]
[1803]
[1804]
[1805]
[1806]
[1807]
[1808]
[1809]
[1810]
[1811]
[1812]
[1813]
[1814]
[1815]
[1816]
[1817]
[1818]
[1819]
[1820]
[1821]
[1822]
[1823]
[1824]
[1825]
[1826]
[1827]
[1828]
[1829]
[1830]
[1831]
[1832]
[1833]
[1834]
[1835]
[1836]
[1837]
[1838]
[1839]
[1840]
[1841]
[1842]
[1843]
[1844]
[1845]
[1846]
[1847]
[1848]
[1849]
[1850]
[1851]
[1852]
[1853]
[1854]
[1855]
[1856]
[1857]
[1858]
[1859]
[1860]
[1861]
[1862]
[1863]
[1864]
[1865]
[1866]
[1867]
[1868]
[1869]
[1870]
[1871]
[1872]
[1873]
[1874]
[1875]
[1876]
[1877]
[1878]
[1879]
[1880]
[1881]
[1882]
[1883]
[1884]
[1885]
[1886]
[1887]
[1888]
[1889]
[1890]
[1891]
[1892]
[1893]
[1894]
[1895]
[1896]
[1897]
[1898]
[1899]
[1900]
[1901]
[1902]
[1903]
[1904]
[1905]
[1906]
[1907]
[1908]
[1909]
[1910]
[1911]
[1912]
[1913]
[1914]
[1915]
[1916]
[1917]
[1918]
[1919]
[1920]
[1921]
[1922]
[1923]
[1924]
[1925]
[1926]
[1927]
[1928]
[1929]
[1930]
[1931]
[1932]
[1933]
[1934]
[1935]
[1936]
[1937]
[1938]
[1939]
[1940]
[1941]
[1942]
[1943]
[1944]
[1945]
[1946]
[1947]
[1948]
[1949]
[1950]
[1951]
[1952]
[1953]
[1954]
[1955]
[1956]
[1957]
[1958]
[1959]
[1960]
[1961]
[1962]
[1963]
[1964]
[1965]
[1966]
[1967]
[1968]
[1969]
[1970]
[1971]
[1972]
[1973]
[1974]
[1975]
[1976]
[1977]
[1978]
[1979]
[1980]
[1981]
[1982]
[1983]
[1984]
[1985]
[1986]
[1987]
[1988]
[1989]
[1990]
[1991]
[1992]
[1993]
[1994]
[1995]
[1996]
[1997]
[1998]
[1999]
[2000]
[2001]
[2002]
[2003]
[2004]
[2005]
[2006]
[2007]
[2008]
[2009]
[2010]
[2011]
[2012]
[2013]
[2014]
[2015]
[2016]
[2017]
[2018]
[2019]
[2020]
[2021]
[2022]
[2023]
[2024]
[2025]
[2026]
[2027]
[2028]
[2029]
[2030]
[2031]
[2032]
[2033]
[2034]
[2035]
[2036]
[2037]
[2038]
[2039]
[2040]
[2041]
[2042]
[2043]
[2044]
[2045]
[2046]
[2047]
[2048]
[2049]
[2050]
[2051]
[2052]
[2053]
[2054]
[2055]
[2056]
[2057]
[2058]
[2059]
[2060]
[2061]
[2062]
[2063]
[2064]
[2065]
[2066]
[2067]
[2068]
[2069]
[2070]
[2071]
[2072]
[2073]
[2074]
[2075]
[2076]
[2077]
[2078]
[2079]
[2080]
[2081]
[2082]
[2083]
[2084]
[2085]
[2086]
[2087]
[2088]
[2089]
[2090]
[2091]
[2092]
[2093]
[2094]
[2095]
[2096]
[2097]
[2098]
[2099]
[2100]
[2101]
[2102]
[2103]
[2104]
[2105]
[2106]
[2107]
[2108]
[2109]
[2110]
[2111]
[2112]
[2113]
[2114]
[2115]
[2116]
[2117]
[2118]
[2119]
[2120]
[2121]
[2122]
[2123]
[2124]
[2125]
[2126]
[2127]
[2128]
[2129]
[2130]
[2131]
[2132]
[2133]
[2134]
[2135]
[2136]
[2137]
[2138]
[2139]
[2140]
[2141]
[2142]
[2143]
[2144]
[2145]
[2146]
[2147]
[2148]
[2149]
[2150]
[2151]
[2152]
[2153]
[2154]
[2155]
[2156]
[2157]
[2158]
[2159]
[2160]
[2161]
[2162]
[2163]
[2164]
[2165]
[2166]
[2167]
[2168]
[2169]
[2170]
[2171]
[2172]
[2173]
[2174]
[2175]
[2176]
[2177]
[2178]
[2179]
[2180]
[2181]
[2182]
[2183]
[2184]
[2185]
[2186]
[2187]
[2188]
[2189]
[2190]
[2191]
[2192]
[2193]
[2194]
[2195]
[2196]
[2197]
[2198]
[2199]
[2200]
[2201]
[2202]
[2203]
[2204]
[2205]
[2206]
[2207]
[2208]
[2209]
[2210]
[2211]
[2212]
[2213]
[2214]
[2215]
[2216]
[2217]
[2218]
[2219]
[2220]
[2221]
[2222]
[2223]
[2224]
[2225]
[2226]
[2227]
[2228]
[2229]
[2230]
[2231]
[2232]
[2233]
[2234]
[2235]
[2236]
[2237]
[2238]
[2239]
[2240]
[2241]
[2242]
[2243]
[2244]
[2245]
[2246]
[2247]
[2248]
[2249]
[2250]
[2251]
[2252]
[2253]
[2254]
[2255]
[2256]
[2257]
[2258]
[2259]
[2260]
[2261]
[2262]
[2263]
[2264]
[2265]
[2266]
[2267]
[2268]
[2269]
[2270]
[2271]
[2272]
[2273]
[2274]
[2275]
[2276]
[2277]
[2278]
[2279]
[2280]
[2281]
[2282]
[2283]
[2284]
[2285]
[2286]
[2287]
[2288]
[2289]
[2290]
[2291]
[2292]
[2293]
[2294]
[2295]
[2296]
[2297]
[2298]
[2299]
[2300]
[2301]
[2302]
[2303]
[2304]
[2305]
[2306]
[2307]
[2308]
[2309]
[2310]
[2311]
[2312]
[2313]
[2314]
[2315]
[2316]
[2317]
[2318]
[2319]
[2320]
[2321]
[2322]
[2323]
[2324]
[2325]
[2326]
[2327]
[2328]
[2329]
[2330]
[2331]
[2332]
[2333]
[2334]
[2335]
[2336]
[2337]
[2338]
[2339]
[2340]
[2341]
[2342]
[2343]
[2344]
[2345]
[2346]
[2347]
[2348]
[2349]
[2350]
[2351]
[2352]
[2353]
[2354]
[2355]
[2356]
[2357]
[2358]
[2359]
[2360]
[2361]
[2362]
[2363]
[2364]
[2365]
[2366]
[2367]
[2368]
[2369]
[2370]
[2371]
[2372]
[2373]
[2374]
[2375]
[2376]
[2377]
[2378]
[2379]
/*****************************************************************************/
/*
MapOds.c
Functions supporting mapping of URL-style specifications to VMS file system
specifications and back.
Can process ODS-2, ODS-5 (EFS), SRI (MultiNet NFS), PATHWORKS (v4/5) and
Advanced Server (PATHWORKS V6) / Samba encodings.
VERSION HISTORY
---------------
26-SEP-2020 MGD bugfix; MapOdsAdsVmsToUrl() "if (!SAME2(cptr,':['))"
14-OCT-2018 MGD bugfix; MapOdsUrlToOds5Vms() semicolon only after period
22-JUN-2016 MGD bugfix; MapOdsUrlToOds5Vms() URLs will not contain
'^'-escaped sequences so just '^'-escape them
18-JUL-2013 MGD bugfix; MapOds5VmsToUrl() et.al. allow for ".]["
05-SEP-2013 MGD bugfix; identify MFD using "000000]" and "000000."
28-DEC-2010 MGD MapOdsUrlTo..() consecutive '/' into a single a la Unix
29-APR-2010 MGD bugfix; MapOdsUrlToOds5Vms() MapOdsElementsToVms()
include '|' and '%' as ODS-5 escaped characters
20-JAN-2009 MGD bugfix; MapOdsUrlToOds5Vms and MapOds5VmsToUrl()
encode the quotation character
30-APR-2005 MGD bugfix; DECnet access string may contain a space
17-MAR-2005 MGD MapOdsElementsToVms() avoid accidentally creating a
DECnet ("::") file specification when generating device
10-DEC-2004 MGD bugfix; MapOdsVmsToUnix() empty if empty
07-NOV-2004 MGD MapOdsVmsToUnix() to support script=SYNTAX=unix
07-OCT-2004 MGD unbundled from MAPURL.C
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#undef __VMS_VER
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* VMS related header files */
#include <devdef.h>
#include <dvidef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application header file */
#include "wasd.h"
#define WASD_MODULE "MAPODS"
/**********/
/* macros */
/**********/
#define MAPURL_RMS_SUBSTITUTION_DEFAULT '$'
#define WATCH_MODULE_DETAIL (WATCH_MODULE(WATCH_MOD_MAPURL) && \
WATCH_MODULE(WATCH_MOD__DETAIL))
/********************/
/* external storage */
/********************/
extern int EfnWait;
extern unsigned long SysPrvMask[];
extern char *FaoUrlEncodeTable[];
extern int ToLowerCase[],
ToUpperCase[];
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
Convert a URL-style specification into a RMS-style specification, example:
"/disk/dir1/dir2/file.txt" into "disk:[dir1.dir2]file.txt".
Can process ODS-2, ODS-5 (EFS), SRI (MultiNet NFS), PATHWORKS (v4/5) and
Advanced Server (PATHWORKS V6) / Samba encodings.
Returns the length of the VMS specification.
*/
int MapOdsUrlToVms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
char RmsSubChar,
BOOL MapEllipsis,
int PathOds
)
{
int len;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToVms() !UL !UL !&B !UL !&Z",
PathOds, RmsSubChar, MapEllipsis, SizeOfVmsPtr, PathPtr);
switch (PathOds)
{
case 0 :
case MAPURL_PATH_ODS_2 :
len = MapOdsUrlToOds2Vms (PathPtr, VmsPtr, SizeOfVmsPtr,
MapEllipsis, RmsSubChar);
break;
#ifdef ODS_EXTENDED
case MAPURL_PATH_ODS_5 :
len = MapOdsUrlToOds5Vms (PathPtr, VmsPtr, SizeOfVmsPtr, MapEllipsis);
break;
#endif /* ODS_EXTENDED */
case MAPURL_PATH_ODS_ADS :
case MAPURL_PATH_ODS_SMB :
len = MapOdsUrlToAdsVms (PathPtr, VmsPtr, SizeOfVmsPtr, MapEllipsis);
break;
case MAPURL_PATH_ODS_PWK :
len = MapOdsUrlToPwkVms (PathPtr, VmsPtr, SizeOfVmsPtr, MapEllipsis);
break;
case MAPURL_PATH_ODS_SRI :
len = MapOdsUrlToSriVms (PathPtr, VmsPtr, SizeOfVmsPtr, MapEllipsis);
break;
default :
memcpy (VmsPtr, "SANITY:[CHECK]MapOdsUrlToVms", len=30);
}
/* ensure it's not mistaken for an error message! */
if (!VmsPtr[0]) VmsPtr[1] = '\0';
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
/*****************************************************************************/
/*
Convert a URL-style specification into an ODS-2 RMS-style specification,
example: "/disk/dir1/dir2/file.txt" into "disk:[dir1.dir2]file.txt".
Forbidden characters (non-alphanumberic and non-"$_-") are converted to the
'RmsSubChar' (by default a dollar symbol). Where a specification has multiple
".", all but the final one of the file component is also converted to a
'RmsSubChar'.
Returns the length of the VMS specification.
*/
int MapOdsUrlToOds2Vms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis,
char RmsSubChar
)
{
BOOL DECnet;
int ecnt, len;
char *cptr, *eptr, *pptr, *sptr, *zptr,
*FinalPeriodPtr;
char PathComponents [ODS_MAX_FILE_NAME_LENGTH];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToOds2Vms() !&B !UL !&Z !UL",
MapEllipsis, RmsSubChar, PathPtr, SizeOfVmsPtr);
pptr = PathPtr;
if (!pptr || !*pptr || SAME2(pptr,'/\0'))
{
SET2(VmsPtr,'\0\0');
return (0);
}
DECnet = false;
ecnt = 0;
FinalPeriodPtr = NULL;
zptr = (sptr = PathComponents) + sizeof(PathComponents);
/* each '/' component becomes a null-terminated string */
while (*pptr && sptr < zptr)
{
while (*pptr == '/') pptr++;
eptr = sptr;
while (*pptr && *pptr != '/' && sptr < zptr)
{
if (isalnum (*pptr) ||
*pptr == '$' || *pptr == '_' || *pptr == '-' ||
*pptr == '*' || *pptr == '%' || *pptr == ';')
{
/* ODS-2 legal character (or wildcard) */
*sptr++ = TOUP(*pptr++);
continue;
}
if (SAME3(pptr,'...'))
{
/* ellipsis wildcard */
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
continue;
}
if (!ecnt)
{
/* DECnet only valid in first component */
if (*pptr == '\"' || *pptr == '=')
{
/* DECnet access string (allow otherwise forbidden chars) */
DECnet = true;
if (SAME2(pptr,'\"~') ||
SAME2(pptr,'\"$'))
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
continue;
}
if (SAME2(pptr,'::'))
{
/* DECnet (with or without access string) */
DECnet = true;
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
continue;
}
if (DECnet && *pptr == ' ')
{
*sptr++ = *pptr++;
continue;
}
}
/* any other character substitute a question mark */
if (*pptr == '.') FinalPeriodPtr = sptr;
if (sptr < zptr) *sptr++ = '?';
pptr++;
}
if (sptr < zptr) *sptr++ = '\0';
ecnt++;
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!UL !&Z\n", ecnt, eptr);
}
if (sptr >= zptr)
{
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(VmsPtr,'\0\0');
return (0);
}
*sptr = '\0';
if (FinalPeriodPtr) *FinalPeriodPtr = '.';
/* convert these null-terminated elements into a VMS file specification */
len = MapOdsElementsToVms (PathComponents, ecnt, VmsPtr, SizeOfVmsPtr,
MapEllipsis);
/* convert the non-RMS characters into the RMS substitution character */
if (!RmsSubChar) RmsSubChar = MAPURL_RMS_SUBSTITUTION_DEFAULT;
for (cptr = VmsPtr; *cptr; cptr++)
{
if (*cptr != '?') continue;
*cptr = RmsSubChar;
}
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
/*****************************************************************************/
/*
Convert a URL-style specification into an ODS-5 RMS-style specification,
example: "/disk/dir1/dir2/file.tar.gz" into "disk:[dir1.dir2]file^.tar.gz".
For ODS-5 paths forbidden characters are ^ (character or hexadecimal) escaped
and the case not altered. Refer to the EFS sections of the RMS documentaion.
Returns the length of the VMS specification.
There is an ambiguous specification that cannot be resolved algorithmically.
The file specifications TESTING.TXT and TESTING^.TXT will both be presented to
the client as TESTING.TXT but stored in the file system as TESTING.TXT; and
TESTING^.TXT.; This function always assumes that TESTING^.TXT.; do not exist.
*/
#ifdef ODS_EXTENDED
int MapOdsUrlToOds5Vms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis
)
{
static char HexDigits [] = "0123456789ABCDEF";
BOOL DECnet;
int ecnt, len;
char *cptr, *eptr, *pptr, *sptr, *zptr,
*FinalPeriodPtr,
*FinalSemiColonPtr,
*FinalSlashPtr;
char PathComponents [ODS_MAX_FILE_NAME_LENGTH];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToOds5Vms() !&B !&Z !UL",
MapEllipsis, PathPtr, SizeOfVmsPtr);
pptr = PathPtr;
if (!pptr || !*pptr || SAME2(pptr,'/\0'))
{
SET2(VmsPtr,'\0\0');
return (0);
}
DECnet = false;
ecnt = 0;
FinalPeriodPtr = FinalSemiColonPtr = FinalSlashPtr = NULL;
zptr = (sptr = PathComponents) + sizeof(PathComponents);
/* each '/' component becomes a null-terminated string */
while (*pptr && sptr < zptr)
{
while (*pptr == '/') pptr++;
eptr = sptr;
while (*pptr && *pptr != '/' && sptr < zptr)
{
switch (*pptr)
{
case '!' : case '#' : case '&' : case '\'' :
case '(' : case ')' : case '+' : case '\"' :
case '@' : case '{' : case '}' : case ',' :
case ';' : case '[' : case ']' : case '=' :
case '`' : case '|' : case '%' : case '^' :
if (*pptr == ';') FinalSemiColonPtr = sptr;
*sptr++ = '^';
if (sptr < zptr) *sptr++ = *pptr++;
break;
case ' ' :
*sptr++ = '^';
if (sptr < zptr) *sptr++ = '_';
pptr++;
break;
case '.' :
if (SAME3(pptr,'...'))
{
/* ellipsis wildcard */
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
}
else
{
FinalPeriodPtr = sptr;
*sptr++ = '^';
if (sptr < zptr) *sptr++ = *pptr++;
}
break;
default :
if (*pptr == 0x07f ||
*pptr == 0x0a0 ||
*pptr == 0x0ff ||
(*pptr >= 0x80 && *pptr <= 0x9f))
{
if (sptr+3 < zptr)
{
*sptr++ = '^';
*sptr++ = HexDigits[(*pptr & 0xf0) >> 4];
*sptr++ = HexDigits[*pptr++ & 0x0f];
}
else
sptr = zptr;
}
else
*sptr++ = *pptr++;
}
if (!ecnt)
{
/* DECnet only valid in first component */
if (*pptr == '\"' || *pptr == '=')
{
/* DECnet access string (allow otherwise forbidden chars) */
DECnet = true;
if (SAME2(pptr,'\"~') ||
SAME2(pptr,'\"$'))
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
continue;
}
if (SAME2(pptr,'::'))
{
/* DECnet (with or without access string) */
DECnet = true;
*sptr++ = *pptr++;
if (sptr < zptr) *sptr++ = *pptr++;
continue;
}
if (DECnet && *pptr == ' ')
{
*sptr++ = *pptr++;
continue;
}
}
/* any other character substitute a question mark */
}
if (*pptr == '/') FinalSlashPtr = sptr;
if (sptr < zptr) *sptr++ = '\0';
ecnt++;
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!UL !&Z\n", ecnt, eptr);
}
if (sptr >= zptr)
{
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(VmsPtr,'\0\0');
return (0);
}
*sptr = '\0';
if (FinalSemiColonPtr &&
(FinalSemiColonPtr > FinalSlashPtr || !FinalSlashPtr) &&
(FinalSemiColonPtr > FinalPeriodPtr || !FinalPeriodPtr) &&
sptr < zptr)
{
/* a final semicolon delimitting the version must not be escaped */
cptr = (sptr = FinalSemiColonPtr) + 1;
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
}
if (FinalPeriodPtr &&
(FinalPeriodPtr > FinalSlashPtr || !FinalSlashPtr) &&
sptr < zptr)
{
/* a final period delimitting the type must not be escaped */
cptr = (sptr = FinalPeriodPtr) + 1;
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
}
len = MapOdsElementsToVms (PathComponents, ecnt, VmsPtr, SizeOfVmsPtr,
MapEllipsis);
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
#endif /* ODS_EXTENDED */
/*****************************************************************************/
/*
Convert a URL-style specification into a RMS-style specification, example:
"/disk/dir1/dir2/file.tar.gz" into "disk:[dir1.dir2]file__27tar.gz" - with
Advanced Server / Samba character conversion. If a character is not RMS legal
(excluding the dollar which is the escape) then encode it as a
double-underscore-escaped hexadecimal number.
Something like this ...
1) If an ODS-2 forbidden character replace with '__xx' (i.e. two underscores
plus the hex representation of the character).
2) Successive underscores have the first encoded as '__xx'.
3) If the final period occurs within the first 39 characters then it's not
encoded, it becomes the ODS-2 period. If it occurs after character 39 then
it's left encoded and a (required ODS-2 but name-extraneous) period is inserted
at character 40.
4) Case change is indicated with a leading '__$' (begins as lower).
Seems cumbersome, less versatile and less space-conservative than SRI!!
For the life of me, why didn't they use SRI encoding?
Returns the length of the VMS specification.
*/
int MapOdsUrlToAdsVms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis
)
{
static char HexDigits [] = "0123456789ABCDEF";
BOOL inDevice,
loCase;
int ecnt, len;
char *cptr, *eptr, *pptr, *sptr, *zptr,
*FinalPeriodPtr,
*FinalSlashPtr;
char PathComponents [ODS_MAX_FILE_NAME_LENGTH];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToAdsVms() !&B !UL !&Z",
MapEllipsis, SizeOfVmsPtr, PathPtr);
pptr = PathPtr;
if (!pptr || !*pptr || SAME2(pptr,'/\0'))
{
SET2(VmsPtr,'\0\0');
return (0);
}
/* any 'device' will not have any encoded characters in it's name */
for (cptr = pptr; *cptr == '/'; cptr++);
while (*cptr && *cptr != '/') cptr++;
if (*cptr) inDevice = true; else inDevice = false;
FinalPeriodPtr = FinalSlashPtr = NULL;
ecnt = 0;
/* leave an extra char elbow room for inserting a period - see below */
zptr = (sptr = PathComponents) + sizeof(PathComponents)-1;
eptr = sptr;
/* each component becomes a null-terminated string in a character array */
while (*pptr && sptr < zptr)
{
while (*pptr == '/') pptr++;
FinalPeriodPtr = NULL;
loCase = true;
eptr = sptr;
while (*pptr && *pptr != '/' && sptr < zptr)
{
if (isalnum (*pptr) || *pptr == '-' || *pptr == '$' ||
*pptr == '*' || *pptr == '%' || inDevice)
{
if (loCase && isupper(*pptr))
{
loCase = false;
*sptr++ = '_';
if (sptr < zptr) *sptr++ = '_';
if (sptr < zptr) *sptr++ = '$';
if (sptr < zptr) *sptr++ = TOUP(*pptr++);
continue;
}
if (!loCase && islower(*pptr))
{
loCase = true;
*sptr++ = '_';
if (sptr < zptr) *sptr++ = '_';
if (sptr < zptr) *sptr++ = '$';
if (sptr < zptr) *sptr++ = TOUP(*pptr++);
continue;
}
*sptr++ = TOUP(*pptr++);
continue;
}
if (*pptr == '_' && !SAME2(pptr,'__'))
{
/* single underscore */
*sptr++ = *pptr++;
continue;
}
if (*pptr == '.') FinalPeriodPtr = sptr;
*sptr++ = '_';
if (sptr < zptr) *sptr++ = '_';
if (sptr < zptr) *sptr++ = HexDigits[(*pptr & 0xf0) >> 4];
if (sptr < zptr) *sptr++ = HexDigits[*pptr & 0x0f];
pptr++;
}
if (sptr < zptr) *sptr++ = '\0';
ecnt++;
inDevice = false;
if (*pptr == '/') FinalSlashPtr = sptr;
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!UL !&Z\n", ecnt, eptr);
}
if (sptr >= zptr)
{
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(VmsPtr,'\0\0');
return (0);
}
*sptr = '\0';
if (FinalPeriodPtr && FinalPeriodPtr <= eptr + 39)
{
/* less than required ODS-2 period, replace with 'real' period */
sptr = FinalPeriodPtr;
*sptr++ = '.';
cptr = sptr + 3;
while (*cptr) *sptr++ = *cptr++;
*sptr = '\0';
}
else
if (sptr > eptr + 39)
{
/* greater than required ODS-2 period, insert an ODS-2 period */
cptr = sptr++;
while (cptr > eptr+39) *sptr-- = *cptr--;
*sptr = *cptr;
*cptr = '.';
while (*sptr) sptr++;
}
len = MapOdsElementsToVms (PathComponents, ecnt, VmsPtr, SizeOfVmsPtr,
MapEllipsis);
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
/*****************************************************************************/
/*
Convert a URL-style specification into a RMS-style specification, example:
"/disk/dir1/dir2/file.tar.gz" into "disk:[dir1.dir2]file$27tar.gz" - with
PATHWORKS v4/5 character conversion. This is much simpler than SRI. If a
character is not RMS legal (excluding the dollar which is the escape) then
encode it as a dollar-escaped hexadecimal number.
Returns the length of the VMS specification.
*/
int MapOdsUrlToPwkVms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis
)
{
static char HexDigits [] = "0123456789ABCDEF";
BOOL inDevice;
int ecnt, len;
char *cptr, *eptr, *pptr, *sptr, *zptr,
*FinalPeriodPtr,
*FinalSlashPtr;
char PathComponents [ODS_MAX_FILE_NAME_LENGTH];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToPwkVms() !&B !UL !&Z",
MapEllipsis, SizeOfVmsPtr, PathPtr);
pptr = PathPtr;
if (!pptr || !*pptr || SAME2(pptr,'/\0'))
{
SET2(VmsPtr,'\0\0');
return (0);
}
/* any 'device' will not have any encoded characters in it's name */
for (cptr = pptr; *cptr == '/'; cptr++);
while (*cptr && *cptr != '/') cptr++;
if (*cptr) inDevice = true; else inDevice = false;
FinalPeriodPtr = FinalSlashPtr = NULL;
ecnt = 0;
zptr = (sptr = PathComponents) + sizeof(PathComponents);
/* each component becomes a null-terminated string in a character array */
while (*pptr && sptr < zptr)
{
while (*pptr == '/') pptr++;
eptr = sptr;
while (*pptr && *pptr != '/' && sptr < zptr)
{
if (isalnum (*pptr) || *pptr == '-' || *pptr == '_' ||
*pptr == '*' || *pptr == '%' || inDevice)
{
*sptr++ = *pptr++;
continue;
}
if (*pptr == '.') FinalPeriodPtr = sptr;
*sptr++ = '$';
if (sptr < zptr) *sptr++ = HexDigits[(*pptr & 0xf0) >> 4];
if (sptr < zptr) *sptr++ = HexDigits[*pptr & 0x0f];
pptr++;
}
if (sptr < zptr) *sptr++ = '\0';
ecnt++;
inDevice = false;
if (*pptr == '/') FinalSlashPtr = sptr;
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!UL !&Z\n", ecnt, eptr);
}
if (sptr >= zptr)
{
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(VmsPtr,'\0\0');
return (0);
}
*sptr = '\0';
/* turn the final period back into one */
if (FinalPeriodPtr)
{
sptr = FinalPeriodPtr;
*sptr++ = '.';
for (cptr = sptr + 2; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
}
len = MapOdsElementsToVms (PathComponents, ecnt, VmsPtr, SizeOfVmsPtr,
MapEllipsis);
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
/*****************************************************************************/
/*
Convert a URL-style specification into a RMS-style specification, example:
"/disk/dir1/dir2/file.tar.gz" into "disk:[dir1.dir2]file.tar$27gz" - with SRI
character conversion. The SRI scheme is quite complex. Refer to online
documentation associated with Process Software's MultiNet NFS server.
Alphabetic '$' case flags reset on a per-path-component basis.
Returns the length of the VMS specification.
*/
int MapOdsUrlToSriVms
(
char *PathPtr,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis
)
{
/* directory wildcard concessions; '%' should be "$5E" and '*' be "$5J" */
static char *SriConvTable [] = {
"$6A", "$4A", "$4B", "$4C", "$4D", "$4E", "$4F", "$4G", /* 0x07 */
"$4H", "$4I", "$4J", "$4K", "$4L", "$4M", "$4N", "$4O", /* 0x0f */
"$4P", "$4Q", "$4R", "$4S", "$4T", "$4U", "$4V", "$4W", /* 0x17 */
"$4X", "$4Y", "$4Z", "$6B", "$6C", "$6D", "$6E", "$6F", /* 0x1f */
"$7A", "$5A", "$5B", "$5C", "$$", NULL, "$5F", "$5G", /* 0x27 */
"$5H", "$5I", NULL, "$5K", "$5L", NULL, "$5N", "$5O", /* 0x2f */
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x37 */
NULL, NULL, "$5Z", "$7B", "$7C", "$7D", "$7E", "$7F", /* 0x3f */
"$8A", NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x47 */
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x4f */
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x57 */
NULL, NULL, NULL, "$8B", "$8C", "$8D", "$8E", NULL, /* 0x5f */
"$9A", NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x67 */
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x6f */
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 0x77 */
NULL, NULL, NULL, "$9B", "$9C", "$9D", "$9E", "$9F", /* 0x7f */
"$200", "$201", "$202", "$203", "$204", "$205", "$206", "$207", /* 0x87 */
"$210", "$211", "$212", "$213", "$214", "$215", "$216", "$217", /* 0x8f */
"$220", "$221", "$222", "$223", "$224", "$225", "$226", "$227", /* 0x97 */
"$230", "$231", "$232", "$233", "$234", "$235", "$236", "$237", /* 0x9f */
"$240", "$241", "$242", "$243", "$244", "$245", "$246", "$247", /* 0xa7 */
"$250", "$251", "$252", "$253", "$254", "$255", "$256", "$257", /* 0xaf */
"$260", "$261", "$262", "$263", "$264", "$265", "$266", "$267", /* 0xb7 */
"$270", "$271", "$272", "$273", "$274", "$275", "$276", "$277", /* 0xbf */
"$300", "$301", "$302", "$303", "$304", "$305", "$306", "$307", /* 0xc7 */
"$310", "$311", "$312", "$313", "$314", "$315", "$316", "$317", /* 0xcf */
"$320", "$321", "$322", "$323", "$324", "$325", "$326", "$327", /* 0xd7 */
"$330", "$331", "$332", "$333", "$334", "$335", "$336", "$337", /* 0xdf */
"$340", "$341", "$342", "$343", "$344", "$345", "$346", "$347", /* 0xe7 */
"$350", "$351", "$352", "$353", "$354", "$355", "$356", "$357", /* 0xef */
"$360", "$361", "$362", "$363", "$364", "$365", "$366", "$367", /* 0xf7 */
"$370", "$371", "$372", "$373", "$374", "$375", "$376", "$377", /* 0xff */
};
BOOL inDevice,
loCase,
typeHit;
int ecnt, len, pcnt;
char *cptr, *eptr, *pptr, *sptr, *zptr,
*FinalSlashPtr;
char PathComponents [ODS_MAX_FILE_NAME_LENGTH];
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsUrlToSriVms() !&B !UL !&Z",
MapEllipsis, SizeOfVmsPtr, PathPtr);
pptr = PathPtr;
if (!pptr || !*pptr || SAME2(pptr,'/\0'))
{
SET2(VmsPtr,'\0\0');
return (0);
}
/* any 'device' will not have any encoded characters in it's name */
for (cptr = pptr; *cptr == '/'; cptr++);
while (*cptr && *cptr != '/') cptr++;
if (*cptr) inDevice = true; else inDevice = false;
ecnt = pcnt = 0;
FinalSlashPtr = NULL;
typeHit = false;
zptr = (sptr = PathComponents) + sizeof(PathComponents);
/* each component becomes a null-terminated string in a character array */
while (*pptr && sptr < zptr)
{
while (*pptr == '/') pptr++;
loCase = true;
eptr = sptr;
while (*pptr && *pptr != '/' && sptr < zptr)
{
if (*pptr == '.' && !typeHit)
{
/* is it the final period in the specification? */
for (cptr = pptr; *cptr && *cptr != '/'; cptr++);
if (!*cptr)
{
/* yes! */
for (cptr = pptr; *cptr && *cptr != '.'; cptr++);
if (*cptr)
{
typeHit = true;
loCase = true;
}
}
}
if (!SriConvTable[*(unsigned char*)pptr] || inDevice)
{
/* unencoded alpha-numeric (or other legal) character */
if (loCase && isupper(*pptr))
{
loCase = false;
*sptr++ = '$';
if (sptr < zptr) *sptr++ = TOUP(*pptr++);
continue;
}
if (!loCase && islower(*pptr))
{
loCase = true;
*sptr++ = '$';
if (sptr < zptr) *sptr++ = TOUP(*pptr++);
continue;
}
*sptr++ = TOUP(*pptr++);
continue;
}
/* dollar-encoded character */
cptr = SriConvTable[*(unsigned char*)pptr];
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
pptr++;
}
if (sptr < zptr) *sptr++ = '\0';
ecnt++;
inDevice = false;
if (*pptr == '/') FinalSlashPtr = sptr;
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!UL !&Z\n", ecnt, eptr);
}
if (sptr >= zptr)
{
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(VmsPtr,'\0\0');
return (0);
}
*sptr = '\0';
/* turn the first (if any) '$5N' of the file name back into a period */
if (!(sptr = FinalSlashPtr)) sptr = PathComponents;
while (*sptr)
{
if (*sptr++ != '$') continue;
if (!SAME2(sptr,'5N')) continue;
sptr[-1] = '.';
for (cptr = sptr + 2; *cptr; *sptr++ = *cptr++);
*sptr = '\0';
break;
}
len = MapOdsElementsToVms (PathComponents, ecnt, VmsPtr, SizeOfVmsPtr,
MapEllipsis);
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, VmsPtr);
return (len);
}
/*****************************************************************************/
/*
'ElementsPtr' contains a series of null-delimited strings (the '/' path
components) terminated by a empty string. 'ElementsCount' the number of
'/'-delimited parts of the string, including the "file" element - even if
empty. Turn this into a VMS file specification in storage pointed to by
'VmsPtr'. For empty elements (consecutive '/') substitute a forbidden
character that will render the specification useless. For parent directory
syntax do the same thing.
Returns the length of the VMS specification.
*/
int MapOdsElementsToVms
(
char *ElementsPtr,
int ElementsCount,
char *VmsPtr,
int SizeOfVmsPtr,
BOOL MapEllipsis
)
{
/* character inserted into a file specification to render it useless */
#define BSCHAR '|'
BOOL DECnet;
int ecnt;
char *cptr, *sptr, *tptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsElementsToVms() !UL !&B",
ElementsCount, MapEllipsis);
/* check the first element for DECnet syntax */
DECnet = false;
for (cptr = ElementsPtr; *cptr; cptr++)
{
if (!SAME2(cptr,'::')) continue;
DECnet = true;
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "DECNET");
break;
}
cptr = ElementsPtr;
zptr = (sptr = VmsPtr) + SizeOfVmsPtr;
if (DECnet) ElementsCount--;
if (ElementsCount == 1)
{
/********************/
/* single component */
/********************/
if (*cptr)
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
else
if (sptr < zptr) *sptr++ = BSCHAR;
}
else
if (ElementsCount == 2)
{
/***********************/
/* top-level directory */
/***********************/
if (DECnet)
{
/* copy first component as-is */
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
cptr++;
}
/* start with the first component, the "device" */
if (*cptr)
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
else
if (sptr < zptr) *sptr++ = BSCHAR;
cptr++;
/* append a Master File Directory component */
for (tptr = ":[000000]"; *tptr && sptr < zptr; *sptr++ = *tptr++);
/* add the second component, the "file" (which can be empty) */
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
}
else
if (ElementsCount >= 3)
{
/****************/
/* subdirectory */
/****************/
if (DECnet)
{
/* copy first component as-is */
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
cptr++;
}
/* start with the first component, the "device" */
if (*cptr)
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
else
if (sptr < zptr) *sptr++ = BSCHAR;
cptr++;
/* avoid accidentally creating a DECnet ("::") specification */
if (*(sptr-1) != ':' && sptr < zptr) *sptr++ = ':';
if (sptr < zptr) *sptr++ = '[';
if (cptr[0] == '.' && cptr[1] == '.' && cptr[2] == '.' && MapEllipsis)
for (tptr = "000000"; *tptr && sptr < zptr; *sptr++ = *tptr++);
for (ecnt = 2; ecnt < ElementsCount; ecnt++)
{
/* add the next component, a "directory" */
if (!*cptr && ecnt < ElementsCount)
{
/* empty element (on all but any file component) */
if (sptr < zptr) *sptr++ = BSCHAR;
}
else
if (cptr[0] == '-')
{
/* check for parent directory syntax, squash if it is! */
for (tptr = cptr; *tptr == '-' || *tptr == '.'; tptr++);
if (*tptr)
{
/* NOT parent directory syntax */
if (*(sptr-1) != '[' && sptr < zptr) *sptr++ = '.';
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
}
else
{
/* parent directory syntax */
while (*cptr && sptr < zptr)
{
*sptr++ = BSCHAR;
cptr++;
}
}
}
else
{
if (*(sptr-1) != '[' && *cptr != '.' && sptr < zptr) *sptr++ = '.';
while (*cptr && sptr < zptr)
{
if (*cptr != '.')
{
*sptr++ = *cptr++;
continue;
}
if (!SAME2(cptr+1,'..') || MapEllipsis)
{
*sptr++ = *cptr++;
continue;
}
/* excise the ellipsis wildcard */
cptr += 3;
if (sptr < zptr) *sptr++ = BSCHAR;
if (sptr < zptr) *sptr++ = BSCHAR;
if (sptr < zptr) *sptr++ = BSCHAR;
}
}
cptr++;
}
if (*(sptr-1) == '[')
{
/* the entire directory structure has been excised! */
for (tptr = "000000"; *tptr && sptr < zptr; *sptr++ = *tptr++);
}
if (sptr < zptr) *sptr++ = ']';
/* add the last component, the "file" (which can be empty) */
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
}
if (sptr < zptr) *sptr = '\0';
if (sptr >= zptr)
{
/* storage overflowed */
SET2(VmsPtr,'\0\0');
return (0);
}
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("!&B !UL !&Z\n", DECnet, sptr-VmsPtr, VmsPtr);
return (sptr - VmsPtr);
#undef BSCHAR
}
/*****************************************************************************/
/*
Convert a VMS full file specification into a URL-style specification, example:
"DEVICE:[DIR1.DIR2]FILE.TXT" into "/device/dir1/dir2/file.txt", or just a file
name and type portion (ensuring it's correctly converted and escaped). The URL
has URL forbidden characters URL-encoded.
Can process ODS-2, ODS-5 (EFS), SRI (MultiNet NFS), PATHWORKS (v4/5) and
Advanced Server (PATHWORKS V6) / Samba encodings.
Returns the length of the generated URL-style path.
*/
int MapOdsVmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd,
int PathOds
)
{
int len;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsVmsToUrl() !UL !&B !&Z !UL",
PathOds, AbsorbMfd, VmsPtr, SizeOfPathPtr);
switch (PathOds)
{
case 0 :
case MAPURL_PATH_ODS_2 :
len = MapOds2VmsToUrl (PathPtr, VmsPtr, SizeOfPathPtr, AbsorbMfd);
break;
#ifdef ODS_EXTENDED
case MAPURL_PATH_ODS_5 :
len = MapOds5VmsToUrl (PathPtr, VmsPtr, SizeOfPathPtr, AbsorbMfd);
break;
#endif /* ODS_EXTENDED */
case MAPURL_PATH_ODS_ADS :
case MAPURL_PATH_ODS_SMB :
len = MapOdsAdsVmsToUrl (PathPtr, VmsPtr, SizeOfPathPtr, AbsorbMfd);
break;
case MAPURL_PATH_ODS_PWK :
len = MapOdsPwkVmsToUrl (PathPtr, VmsPtr, SizeOfPathPtr, AbsorbMfd);
break;
case MAPURL_PATH_ODS_SRI :
len = MapOdsSriVmsToUrl (PathPtr, VmsPtr, SizeOfPathPtr, AbsorbMfd);
break;
default :
memcpy (PathPtr, "/sanity/check/MapOdsUrlToVms", len=30);
}
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!UL !&Z\n", len, PathPtr);
return (len);
}
/*****************************************************************************/
/*
Convert a VMS full file specification into a URL-style specification, example:
"DEVICE:[DIR1.DIR2]FILE.TXT" into "/device/dir1/dir2/file.txt", or just a file
name and type portion (ensuring it's correctly converted and escaped). Expects
file specification to be ODS-2 compliant and forces the URL to all lower-case.
Returns the length of the generated URL-style path.
*/
int MapOds2VmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd
)
{
char *cptr, *eptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOds2VmsToUrl() !&B !&Z !UL",
AbsorbMfd, VmsPtr, SizeOfPathPtr);
zptr = (sptr = PathPtr) + SizeOfPathPtr;
/* look for indications it's a full file specification */
cptr = VmsPtr;
while (*cptr && !SAME2(cptr,':[') &&
*cptr != ']' && *cptr != '/') cptr++;
if (!*cptr || *cptr == '/')
{
/* no VMS device/directory components detected */
cptr = VmsPtr;
}
else
{
/* copy device/directory components */
cptr = VmsPtr;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (SAME2(cptr,'::'))
{
/* DECnet */
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '/';
continue;
}
if (SAME2(cptr,':['))
{
cptr++;
cptr++;
/* remove any reference to a Master File Directory */
if (AbsorbMfd && (MATCH7(cptr,"000000]") || MATCH7(cptr,"000000.")))
cptr += 6;
else
*sptr++ = '/';
continue;
}
if (*cptr == '.')
{
if (SAME3(cptr,'...'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
}
else
{
*sptr++ = '/';
if (SAME3(cptr,'.]['))
cptr += 3;
else
cptr++;
}
continue;
}
if (*cptr == ']')
{
*sptr++ = '/';
cptr++;
break;
}
*sptr++ = TOLO(*cptr++);
}
}
/* copy the file component */
while (*cptr && sptr < zptr) *sptr++ = TOLO(*cptr++);
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!&Z\n", PathPtr);
if (sptr < zptr) return ((sptr - PathPtr) - 2);
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(PathPtr,'\0\0');
return (0);
}
/*****************************************************************************/
/*
Convert a VMS full file ODS-5 compliant specification into a URL-style
specification, example: "DEVICE:[dir1.DIR2]a^.file.txt" into
"/device/dir1/DIR2/a file.txt", or a URL-style string that contains ODS-5
escaped characters, example "/device/device/dir1/DIR2/a^.file.txt" into
"/device/dir1/DIR2/a file.txt" (ensuring it's correctly converted and escaped).
Will decode literal ^-escaped and hexadecimal ^-escaped characters and leaves
the case as-is.
Returns the length of the generated URL-style path.
*/
#ifdef ODS_EXTENDED
int MapOds5VmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd
)
{
unsigned char ch;
char *cptr, *eptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOds5VmsToUrl() !&B !&Z !UL",
AbsorbMfd, VmsPtr, SizeOfPathPtr);
zptr = (sptr = PathPtr) + SizeOfPathPtr;
/* look for indications it's a full file specification */
cptr = VmsPtr;
while (*cptr && !SAME2(cptr,':[') &&
*cptr != ']' && *cptr != '/')
{
if (cptr[0] == '^' && isxdigit(cptr[1]) && isxdigit(cptr[2]))
cptr += 3;
else
if (cptr[0] == '^' && cptr[1] == 'U' &&
isxdigit(cptr[2]) && isxdigit(cptr[3]) &&
isxdigit(cptr[4]) && isxdigit(cptr[5]))
cptr += 6;
else
if (cptr[0] == '^')
cptr += 2;
else
cptr++;
}
if (!*cptr || *cptr == '/')
{
/* no VMS device/directory components detected */
cptr = VmsPtr;
}
else
{
/* copy device/directory components */
cptr = VmsPtr;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (SAME2(cptr,'::'))
{
/* DECnet */
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '/';
continue;
}
if (SAME2(cptr,':['))
{
cptr++;
cptr++;
/* remove any reference to a Master File Directory */
if (AbsorbMfd && (MATCH7(cptr,"000000]") || MATCH7(cptr,"000000.")))
cptr += 6;
else
*sptr++ = '/';
continue;
}
if (*cptr == '.')
{
if (SAME3(cptr,'...'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
}
else
{
*sptr++ = '/';
if (SAME3(cptr,'.]['))
cptr += 3;
else
cptr++;
}
continue;
}
if (*cptr == ']')
{
*sptr++ = '/';
cptr++;
break;
}
if (*cptr == '^')
{
/* ODS-5 extended specification escape character */
cptr++;
switch (*cptr)
{
case '!' : case '#' : case '&' : case '\'' : case '\"' :
case '(' : case ')' : case '+' : case '@' : case '{' :
case '}' : case '.' : case ',' : case ';' : case '[' :
case ']' : case '%' : case '^' : case '=' : case ' ' :
case '`' : case '|' :
*sptr++ = *cptr++;
break;
case '_' :
*sptr++ = ' ';
cptr++;
break;
default :
if (!isxdigit (*cptr))
{
*sptr++ = *cptr++;
break;
}
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
if (*cptr) cptr++;
*sptr++ = ch;
}
continue;
}
if (sptr < zptr) *sptr++ = *cptr++;
}
}
/* copy the file component */
while (*cptr && sptr < zptr)
{
if (*cptr != '^')
{
*sptr++ = *cptr++;
continue;
}
/* ODS-5 extended specification escape character */
cptr++;
switch (*cptr)
{
case '!' : case '#' : case '&' : case '\'' : case '`' :
case '(' : case ')' : case '+' : case '@' : case '{' :
case '}' : case '.' : case ',' : case ';' : case '[' :
case ']' : case '%' : case '^' : case '=' : case ' ' :
*sptr++ = *cptr++;
break;
case '_' :
*sptr++ = ' ';
cptr++;
break;
default :
if (!isxdigit (*cptr))
{
*sptr++ = *cptr++;
break;
}
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
if (*cptr) cptr++;
*sptr++ = ch;
}
}
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!&Z\n", PathPtr);
if (sptr < zptr) return ((sptr - PathPtr) - 2);
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(PathPtr,'\0\0');
return (0);
}
#endif /* ODS_EXTENDED */
/*****************************************************************************/
/*
Convert a VMS full file specification into a URL-style specification, example:
"DEVICE:[DIR1.DIR2]__$A__2A__$FILE.TXT" into "/device/dir1/dir2/A file.txt", or
a URL-style specification, example "/device/dir1/dir2/A__20file.txt" into
"/device/dir1/dir2/A file.txt" (ensuring it's correctly converted and escaped).
Expects file specification to be Advanced Server compliant. Alphabetic '$'
case flags reset on a per-path-component basis.
Returns the length of the generated URL-style path.
*/
int MapOdsAdsVmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd
)
{
BOOL isDevice,
loCase;
char ch;
char *cptr, *eptr, *sptr, *zptr,
*NamePtr,
*PeriodPtr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsAdsVmsToUrl() !&B !&Z !UL",
AbsorbMfd, VmsPtr, SizeOfPathPtr);
zptr = (sptr = PathPtr) + SizeOfPathPtr;
/* look for indications it's a full file specification */
cptr = VmsPtr;
while (*cptr && !SAME2(cptr,':[') &&
*cptr != ']' && *cptr != '/') cptr++;
if (!*cptr || *cptr == '/')
{
/* no VMS device/directory components detected */
cptr = VmsPtr;
}
else
{
/* copy device/directory components */
isDevice = loCase = true;
cptr = VmsPtr;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (SAME2(cptr,'::'))
{
/* DECnet */
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '/';
loCase = true;
continue;
}
if (SAME2(cptr,':['))
{
cptr++;
cptr++;
/* remove any reference to a Master File Directory */
if (AbsorbMfd && (MATCH7(cptr,"000000]") || MATCH7(cptr,"000000.")))
cptr += 6;
else
*sptr++ = '/';
isDevice = false;
loCase = true;
continue;
}
if (*cptr == '.')
{
if (SAME3(cptr,'...'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
}
else
{
*sptr++ = '/';
if (SAME3(cptr,'.]['))
cptr += 3;
else
cptr++;
}
loCase = true;
continue;
}
if (*cptr == ']')
{
cptr++;
*sptr++ = '/';
isDevice = false;
loCase = true;
break;
}
/* don't need to be concerned with periods in directories */
if (!SAME2(cptr,'__') || isDevice)
{
if (loCase)
*sptr++ = TOLO(*cptr++);
else
*sptr++ = TOUP(*cptr++);
continue;
}
/* convert from Advanced Server encoding */
cptr++;
cptr++;
if (*cptr == '$')
{
cptr++;
loCase = !loCase;
continue;
}
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
else
ch = '?';
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
else
ch = '?';
if (*cptr) cptr++;
if (loCase)
*sptr++ = TOLO(ch);
else
*sptr++ = TOUP(ch);
}
}
/* copy the file component */
PeriodPtr = NULL;
NamePtr = cptr;
loCase = true;
while (*cptr && sptr < zptr)
{
if (*cptr != '_')
{
if (*cptr != '.')
{
if (loCase)
*sptr++ = TOLO(*cptr++);
else
*sptr++ = TOUP(*cptr++);
continue;
}
PeriodPtr = sptr;
*sptr++ = *cptr++;
continue;
}
/* need to cater for possible '__xx', '_._xx', '__.xx' */
if (!SAME2(cptr,'__') && !SAME2(cptr,'_.'))
{
/* an isolated underscore */
if (sptr < zptr) *sptr++ = *cptr++;
continue;
}
cptr++;
if (SAME2(cptr,'._'))
{
if (cptr != NamePtr + 39)
{
/* not an ODS-2 required period */
if (sptr < zptr) *sptr++ = *cptr++;
continue;
}
/* step over the ODS-2 required period */
cptr++;
}
else
if (SAME2(cptr,'_.'))
{
/* after two underscores can only be an ODS-2 required period */
cptr++;
}
cptr++;
/* convert from Advanced Server encoding */
if (*cptr == '$')
{
cptr++;
loCase = !loCase;
continue;
}
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
else
ch = '?';
if (*cptr) cptr++;
/* if it's an ODS-2 required period just ignore it (i.e. '__x.x') */
if (*cptr == '.') cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
else
ch = '?';
if (*cptr) cptr++;
if (loCase)
*sptr++ = TOLO(ch);
else
*sptr++ = TOUP(ch);
}
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
if (PeriodPtr)
{
/* remove the ODS-2 required period if there is a trailing period */
for (cptr = PeriodPtr+1; *cptr && *cptr != '.'; cptr++);
if (*cptr)
{
for (cptr = (sptr = PeriodPtr) + 1; *cptr; *sptr++ = *cptr++);
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
}
}
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!&Z\n", PathPtr);
if (sptr < zptr) return ((sptr - PathPtr) - 2);
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(PathPtr,'\0\0');
return (0);
}
/*****************************************************************************/
/*
The Advanced Server (PATHWORKS 6) / Samba encoding maps the period as described
in the description of MapOdsUrlToAdsVms(). This function decodes the file
name plus type then find the last period in it and uses that following as the
file type.
*/
char* MapOdsAdsFileType (char *FileType)
{
static char AdsFileType [96];
int Length;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsAdsFileType() !&Z", FileType);
Length = MapOdsAdsVmsToUrl (AdsFileType, FileType,
sizeof(AdsFileType), true);
cptr = AdsFileType + Length;
while (cptr > AdsFileType && *cptr != '.') cptr--;
if (WATCH_MODULE(WATCH_MOD_MAPURL)) WatchDataFormatted ("!&Z\n", cptr);
return (cptr);
}
/*****************************************************************************/
/*
Convert a VMS full file specification into a URL-style specification, example:
"DEVICE:[DIR1.DIR2]A$2AFILE.TXT" into "/device/dir1/dir2/a file.txt", or a
URL-style specification, example "/device/dir1/dir2/a$20file.txt" into
"/device/dir1/dir2/a file.txt" (ensuring it's correctly converted and escaped).
Expects file specification to be PATHWORKS v4/5 compliant and forces the URL to
all lower-case.
Returns the length of the generated URL-style path.
*/
int MapOdsPwkVmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd
)
{
BOOL isDevice;
char ch;
char *cptr, *eptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsPwkVmsToUrl() !&B !&Z !UL",
AbsorbMfd, VmsPtr, SizeOfPathPtr);
zptr = (sptr = PathPtr) + SizeOfPathPtr;
/* look for indications it's a full file specification */
cptr = VmsPtr;
while (*cptr && !SAME2(cptr,':[') &&
*cptr != ']' && *cptr != '/') cptr++;
if (!*cptr || *cptr == '/')
{
/* no VMS device/directory components detected */
cptr = VmsPtr;
}
else
{
/* copy device/directory components */
isDevice = true;
cptr = VmsPtr;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (SAME2(cptr,'::'))
{
/* DECnet */
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '/';
continue;
}
if (SAME2(cptr,':['))
{
cptr++;
cptr++;
/* remove any reference to a Master File Directory */
if (AbsorbMfd && (MATCH7(cptr,"000000]") || MATCH7(cptr,"000000.")))
cptr += 6;
else
*sptr++ = '/';
isDevice = false;
continue;
}
if (*cptr == '.')
{
*sptr++ = '/';
if (SAME3(cptr,'...'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
}
else
{
*sptr++ = '/';
if (SAME3(cptr,'.]['))
cptr += 3;
else
cptr++;
}
continue;
}
if (*cptr == ']')
{
cptr++;
*sptr++ = '/';
break;
}
if (*cptr != '$' || isDevice)
{
*sptr++ = TOLO(*cptr++);
continue;
}
/* convert from PATHWORKS encoding */
cptr++;
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
else
ch = '?';
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
else
ch = '?';
if (*cptr) cptr++;
*sptr++ = ch;
}
}
/* copy the file component */
while (*cptr && sptr < zptr)
{
if (*cptr != '$')
{
*sptr++ = TOLO(*cptr++);
continue;
}
/* convert from PATHWORKS encoding */
cptr++;
ch = 0;
if (*cptr >= '0' && *cptr <= '9')
ch = (*cptr - (int)'0') << 4;
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch = (TOLO(*cptr) - (int)'a' + 10) << 4;
else
ch = '?';
if (*cptr) cptr++;
if (*cptr >= '0' && *cptr <= '9')
ch += (*cptr - (int)'0');
else
if (TOLO(*cptr) >= 'a' && TOLO(*cptr) <= 'f')
ch += (TOLO(*cptr) - (int)'a' + 10);
else
ch = '?';
if (*cptr) cptr++;
*sptr++ = ch;
}
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!&Z\n", PathPtr);
if (sptr < zptr) return ((sptr - PathPtr) - 2);
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(PathPtr,'\0\0');
return (0);
}
/*****************************************************************************/
/*
Convert a VMS full file SRI (e.g. MultiNet NFS) compliant specification into a
URL-style specification, example: "DEVICE:[DIR1.DIR2]A$5NFILE.TXT" into
"/device/dir1/dir2/a file.txt", or a URL-style specification, example
"/device/dir1/dir2/a$5nfile.txt" into "/device/dir1/dir2/a file.txt" (ensuring
it's correctly converted and escaped). Expects file specification to be SRI
compliant. The SRI scheme is quite complex. Refer to online documentation
associated with Process Software's MultiNet NFS server. Alphabetic '$' case
flags reset on a per-path-component basis.
Returns the length of the generated URL-style path.
*/
int MapOdsSriVmsToUrl
(
char *PathPtr,
char *VmsPtr,
int SizeOfPathPtr,
BOOL AbsorbMfd
)
{
BOOL isDevice,
loCase;
char ch;
char *cptr, *eptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsSriVmsToUrl() !&B !&Z !UL",
AbsorbMfd, VmsPtr, SizeOfPathPtr);
zptr = (sptr = PathPtr) + SizeOfPathPtr;
/* look for indications it's a full file specification */
cptr = VmsPtr;
while (*cptr && !SAME2(cptr,':[') &&
*cptr != ']' && *cptr != '/') cptr++;
if (!*cptr || *cptr == '/')
{
/* no VMS device/directory components detected */
cptr = VmsPtr;
}
else
{
/* copy device/directory components */
isDevice = loCase = true;
cptr = VmsPtr;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (SAME2(cptr,'::'))
{
/* DECnet */
*sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = '/';
loCase = true;
continue;
}
if (SAME2(cptr,':['))
{
cptr++;
cptr++;
/* remove any reference to a Master File Directory */
if (AbsorbMfd && (MATCH7(cptr,"000000]") || MATCH7(cptr,"000000.")))
cptr += 6;
else
*sptr++ = '/';
isDevice = false;
loCase = true;
continue;
}
if (*cptr == '.')
{
*sptr++ = '/';
if (SAME3(cptr,'...'))
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
}
else
{
*sptr++ = '/';
if (SAME3(cptr,'.]['))
cptr += 3;
else
cptr++;
}
loCase = true;
continue;
}
if (*cptr == ']')
{
*sptr++ = '/';
cptr++;
break;
}
if (isDevice)
*sptr++ = TOLO(*cptr++);
else
if (*cptr == '$')
*sptr++ = MapOdsSriCharVmsToUrl (&cptr, &loCase);
else
if (loCase)
*sptr++ = TOLO(*cptr++);
else
*sptr++ = TOUP(*cptr++);
}
}
/* copy the file component */
loCase = true;
while (*cptr && sptr < zptr)
{
if (*cptr == '.') loCase = true;
if (*cptr == '$')
*sptr++ = MapOdsSriCharVmsToUrl (&cptr, &loCase);
else
if (loCase)
*sptr++ = TOLO(*cptr++);
else
*sptr++ = TOUP(*cptr++);
}
if (sptr < zptr) *sptr++ = '\0';
if (sptr < zptr) *sptr++ = '\0';
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchDataFormatted ("!&Z\n", PathPtr);
if (sptr < zptr) return ((sptr - PathPtr) - 2);
/* storage overflowed */
if (WATCH_MODULE_DETAIL)
WatchThis (WATCHALL, WATCH_MOD_MAPURL, "OVERFLOW");
SET2(PathPtr,'\0\0');
return (0);
}
/*****************************************************************************/
/*
Return a single character that has been decoded from the string pointed to by
the storage supplied by 'stringPtrPtr'. If the decode detects an error in the
encoding then it returns a question mark (crude, but hey it should be obvious
to the end-user!) The SRI scheme is quite complex. Refer to online
documentation associated with Process Software's MultiNet NFS server.
*/
char MapOdsSriCharVmsToUrl
(
char **stringPtrPtr,
BOOL *loCasePtr
)
{
static char SriDecodeTable [6][26] =
{
/* table $4A-Z */
{ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, /* A-H */
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, /* I-P */
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, /* Q-X */
0x19, 0x1a }, /* Y-Z */
/* table $5A-Z */
{ 0x21, 0x22, 0x23, '?', 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, '?', 0x2e, 0x2f, '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', 0x3a },
/* table $6A-Z */
{ 0x00, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, '?', '?',
0x29, '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?' },
/* table $7A-Z */
{ 0x20, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, '?', '?',
0x29, '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?' },
/* table $8A-Z */
{ 0x40, 0x5b, 0x5c, 0x5d, 0x5e, '?', '?', '?',
0x29, '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?' },
/* table $9A-Z */
{ 0x60, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, '?', '?',
0x29, '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?' },
};
char ch, idx;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsSriCharVmsToUrl() !&B !4AZ", *loCasePtr, *stringPtrPtr);
cptr = *stringPtrPtr;
if (*cptr == '$')
{
cptr++;
if (*cptr == '2' || *cptr == '3')
{
ch = (*cptr++ - '0') << 6;
if (*cptr >= '0' && *cptr <= '7')
{
ch |= (*cptr++ - '0') << 3;
if (*cptr >= '0' && *cptr <= '7')
ch |= (*cptr++ -'0');
else
{
ch = '?';
cptr++;
}
}
else
{
ch = '?';
cptr++;
}
}
else
if (*cptr >= '4' && *cptr <= '9')
{
idx = *cptr++ - '4';
if (*cptr >= 'A' && *cptr <= 'Z')
ch = SriDecodeTable[idx][*(unsigned char*)cptr-'A'];
else
ch = '?';
cptr++;
}
else
if (*cptr >= 'A' && *cptr <= 'Z')
{
*loCasePtr = !*loCasePtr;
if (*loCasePtr)
ch = TOLO(*cptr++);
else
ch = TOUP(*cptr++);
}
else
if (*cptr == '$')
ch = *cptr++;
else
{
ch = '?';
cptr++;
}
}
else
if (*loCasePtr)
ch = TOLO(*cptr++);
else
ch = TOUP(*cptr++);
if (WATCH_MODULE_DETAIL)
WatchDataFormatted ("{!UL}!-!#AZ 0x!2XL !-!&C\n",
cptr - *stringPtrPtr, *stringPtrPtr, ch);
*stringPtrPtr = cptr;
return (ch);
}
/*****************************************************************************/
/*
The SRI encoding maps the first period in any multi-period file type as a
period and any thereafter as '$5N' sequences. Find any final '$5N' sequence
and map this into a "real" file type returning a pointer to this static
storage. If there is no '$5N' in the string then just return a pointer to the
original string.
*/
char* MapOdsSriFileType (char *FileType)
{
static char SriFileType [96];
int Length;
char *cptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsSriFileType() !&Z", FileType);
Length = MapOdsSriVmsToUrl (SriFileType, FileType,
sizeof(SriFileType), true);
cptr = SriFileType + Length;
while (cptr > SriFileType && *cptr != '.') cptr--;
if (WATCH_MODULE(WATCH_MOD_MAPURL)) WatchDataFormatted ("!&Z\n", cptr);
return (cptr);
}
/*****************************************************************************/
/*
Map something like ODS-2:[dir1.dir2]name.TYPE to /ODS-2/dir1/dir2/name.TYPE
and ODS-5:[dir1.dir2]name^.dot.TYPE to /ODS-5/dir1/dir2/name.dot.TYPE
suitable for use by the C-RTL. Returns a VMS status.
*/
int MapOdsVmsToUnix
(
char *VmsFileSpec,
char *UnixFileSpec,
int SizeOfUnixFileSpec
)
{
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_MAPURL))
WatchThis (WATCHALL, WATCH_MOD_MAPURL,
"MapOdsVmsToUnix() !&Z !UL", VmsFileSpec, SizeOfUnixFileSpec);
zptr = (sptr = UnixFileSpec) + SizeOfUnixFileSpec;
if (!VmsFileSpec[0])
{
*sptr = '\0';
return (SS$_NORMAL);
}
if (sptr < zptr) *sptr++ = '/';
cptr = VmsFileSpec;
while (*cptr && *cptr != ':' && sptr < zptr)
{
if (*cptr == '^') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr == ':') cptr++;
if (*cptr == '[') cptr++;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && *cptr != ']' && sptr < zptr)
{
while (*cptr && *cptr != '.' && *cptr != ']' && sptr < zptr)
{
if (*cptr == '^') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (*cptr == '.')
{
if (sptr < zptr) *sptr++ = '/';
cptr++;
}
}
if (*cptr == ']') cptr++;
if (sptr < zptr) *sptr++ = '/';
while (*cptr && sptr < zptr)
{
if (*cptr == '^') cptr++;
if (*cptr) *sptr++ = *cptr++;
}
if (sptr >= zptr) return (SS$_RESULTOVF);
*sptr = '\0';
return (SS$_NORMAL);
}
/*****************************************************************************/