[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]
[2380]
[2381]
[2382]
[2383]
[2384]
[2385]
[2386]
[2387]
[2388]
[2389]
[2390]
[2391]
[2392]
[2393]
[2394]
[2395]
[2396]
[2397]
[2398]
[2399]
[2400]
[2401]
[2402]
[2403]
[2404]
[2405]
[2406]
[2407]
[2408]
[2409]
[2410]
[2411]
[2412]
[2413]
[2414]
[2415]
[2416]
[2417]
[2418]
[2419]
[2420]
[2421]
[2422]
[2423]
[2424]
[2425]
[2426]
[2427]
[2428]
[2429]
[2430]
[2431]
[2432]
[2433]
[2434]
[2435]
[2436]
[2437]
[2438]
[2439]
[2440]
[2441]
[2442]
[2443]
[2444]
[2445]
[2446]
[2447]
[2448]
[2449]
[2450]
[2451]
[2452]
[2453]
[2454]
[2455]
[2456]
[2457]
[2458]
[2459]
[2460]
[2461]
[2462]
[2463]
[2464]
[2465]
[2466]
[2467]
[2468]
[2469]
[2470]
[2471]
[2472]
[2473]
[2474]
[2475]
[2476]
[2477]
[2478]
[2479]
[2480]
[2481]
[2482]
[2483]
[2484]
[2485]
[2486]
[2487]
[2488]
[2489]
[2490]
[2491]
[2492]
[2493]
[2494]
[2495]
[2496]
[2497]
[2498]
[2499]
[2500]
[2501]
[2502]
[2503]
[2504]
[2505]
[2506]
[2507]
[2508]
[2509]
[2510]
[2511]
[2512]
[2513]
[2514]
[2515]
[2516]
[2517]
[2518]
[2519]
[2520]
[2521]
[2522]
[2523]
[2524]
[2525]
[2526]
[2527]
[2528]
[2529]
[2530]
[2531]
[2532]
[2533]
[2534]
[2535]
[2536]
[2537]
[2538]
[2539]
[2540]
[2541]
[2542]
[2543]
[2544]
[2545]
[2546]
[2547]
[2548]
[2549]
[2550]
[2551]
[2552]
[2553]
[2554]
[2555]
[2556]
[2557]
[2558]
[2559]
[2560]
[2561]
[2562]
[2563]
[2564]
[2565]
[2566]
[2567]
[2568]
[2569]
[2570]
[2571]
[2572]
[2573]
[2574]
[2575]
[2576]
[2577]
[2578]
[2579]
[2580]
[2581]
[2582]
[2583]
[2584]
[2585]
[2586]
[2587]
[2588]
[2589]
[2590]
[2591]
[2592]
[2593]
[2594]
[2595]
[2596]
[2597]
[2598]
[2599]
[2600]
[2601]
[2602]
[2603]
[2604]
[2605]
[2606]
[2607]
[2608]
[2609]
[2610]
[2611]
[2612]
[2613]
[2614]
[2615]
[2616]
[2617]
[2618]
[2619]
[2620]
[2621]
[2622]
[2623]
[2624]
[2625]
[2626]
[2627]
[2628]
[2629]
[2630]
[2631]
[2632]
[2633]
[2634]
[2635]
[2636]
[2637]
[2638]
[2639]
[2640]
[2641]
[2642]
[2643]
[2644]
[2645]
[2646]
[2647]
[2648]
[2649]
[2650]
[2651]
[2652]
[2653]
[2654]
[2655]
[2656]
[2657]
[2658]
[2659]
[2660]
[2661]
[2662]
[2663]
[2664]
[2665]
[2666]
[2667]
[2668]
[2669]
[2670]
[2671]
[2672]
[2673]
/*****************************************************************************
/*
FAO.c
Formatted write using $FAO()-like directives, just a functional subset, it also
differs in some significant ways, including extended functionality. The
functions can write into either specified storage or into the request's output
buffer (probably more efficient that $FAO()ing into storage then copying this
to the network buffer). All parameters are passed via a $FAOL()-like
pointer-to-longword-vector. Strings are always assumed to be null-terminated.
A resultant string is always null-terminated (even after an error), hence the
'BufferSize' can always only store 'BufferSize'-1 characters. 'LengthPtr'
provides storage for the number of characters minus the null-termination.
It is no exageration to state that this functionality has made the sorts of
things undertaken with it ten times easier and more efficient!!
$FAO DIRECTIVES SUPPORTED
-------------------------
!AC counted ASCII string (first byte must be count, i.e. 0 to 255 chars)
!AZ null-terminated string
!SL decimal, signed longword
!SQ signed quadword (indirect character MUST be used (i.e. "!@SQ"))
!UL decimal, unsigned longword
!XL hexadecimal, longword
!ZL zero-filled decimal, unsigned longword
!%D date/time
!%I numeric to ASCII identifier
!%S if the last converted numeric value was not 1 add "S"
!%s if the last converted numeric value was not 1 add "s"
!%T time
!* multiple '*'+1 characters
!+ step-over the next parameter from the vector (anything BUT a "!&@")
!- back-up to the previous parameter in the vector (anything BUT a "!&@")
!< begin specified width output field (cannot nest, must have width!)
!> end specified width output field
!! exclamation mark
WASD EXTENSIONS
---------------
!&. replace non-printable characters with periods (e.g. "!&.AZ")
!&\ replace non-printable characters with slash-escapes (e.g. "!&\\AZ")
!&, big numberize the following number (e.g. "!&,SL")
!&,, comma-ize the following number (e.g. "!&,,SL")
!&; HTML-escape the following string (e.g. "!&;AZ")
!&% URL-encode the following string (e.g. "!&%AZ")
!&[ format string as a file specification (requires preceding ODS flag)
!&^ force the following string to upper case
!&! force the following string to lower case
!&_ underline the following string if it contains a space (<u>..</u>)
!&" quote/escape the following string if it contains a space ("..\"..")
!&+ if !AZ string is not null or empty then add a leading space
!&/ if !AZ string is not null or empty the add a trailing newline
!&> right justfy (or left fill, if prefered)
!&8 UTF-8 encode string (8 bit characters only)
!&A address as a parameter, as "&00000000" (for module WATCHing)
!&B boolean (for WATCHing)
!&C a single character
!&D date/time string truncated after the minute
!&E until end-of-line (i.e. up to the next <CR> or <LF>)
!&F local function address, as "00000000()" (for module WATCHing)
!&H bytes in hexadecimal (field width is number)
!&I dotted-decimal from 32 bit network-order IP address
!&L same as !UL but implicitly comma-ized (as by '!&,')
!&M full status message string (returned from sys$getmsg())
!&m text-only status message string (returned from sys$getmsg())
!&O add " SELECTED" if true, "" if false (for <select> option items)
!&P request URI (mask password, for module WATCHing)
!&R add " CHECKED" if true, "" if false (for <input> radio buttons)
!&S VMS status value, as "%X00000000" (plus message string if non-success)
!&U URL encode
!&W weekday/date/time (field-width applies to date/time component only)
!&X hexadecimal value, as "0x00000000"
!&Z null-terminated string, as "{length}string" (for module WATCHing)
!&? simple conditional, "!&?string if *vector TRUE\rstring if FALSE\r"
!&@ nested format string address from vector (FILO stacks the current one)
!%% same as !&@ (for backward compatibility of strings in WASD_CONFIG_MSG)
The WASD extensions perform two roles. Some modify the way a following
directive is formatted, for example HTML-escaping it. Others provide
additonal format directives to standard $FAO. Field width should always be
placed BEFORE the WASD extensions. Indirection should be indicated immediately
before the respective formatting directive.
Each directive can have a positive, decimal integer between the '!' and the
directive providing a field width, e.g. "!10AZ", or have the field width taken
from the vector using "!#AZ". These behave in the same manner as the sys$fao()
field width parameter.
Any directive may use the indirect character (unlike sys$fao(), where only
numeric directives may). This indicates the vector value is the 32 bit address
of the value, rather than the value itself, e.g. "!@AZ", "!10@UL", etc.
VERSION HISTORY
---------------
28-JUN-2021 MGD FaoToMemory()
12-OCT-2020 MGD '&,' FaoBigNumber() optionally numbers 'P', 'G', 'M', 'k'
'&,,' can be used to "force" comma-izing a string of digits
16-JUL-2019 MGD '&>' right justify (or left fill)
24-JUL-2018 MGD FaoLibPutOutput()
29-OCT-2017 MGD bugfix; '%D' do not cancel field-width then "(none)"
02-JAN-2016 MGD bugfix; |if (fw <= 0) fw = 32;| to |if (fw < 0) fw = 32;|
23-APR-2015 MGD bugfix; FaoSAK() sdptr = StrDscBuffer(StrDscPtr);
11-JUL-2013 MGD FaoUrlEncodeTable tilde from "%7e" to "~" (cadaver issue)
11-SEP-2010 MGD '&\' slash-escapes common non-printable codes
27-JUN-2010 MGD '&S' now provides message string if non-success
30-MAY-2010 MGD '&8' UTF-8 encode string (only 8 bit characters)
09-JUN-2007 MGD use STR_DSC
make '!&E' the same functionality as previously '!&L'
and make '!&L' an implicitly comma-ized '!UL'
16-JUL-2005 MGD '&.' replace non-printable characters with periods,
replace ErrorNoticed() with FaoErrorNoticed() in
FaoToStdout() and FaoToOpcom() for the obvious reason
01-MAR-2003 MGD '&+' if not null or empty !AZ adds a leading space,
'&/' if not null or empty !AZ adds a trailing newline,
change behaviour of NULL !AZ to showing an empty string
18-OCT-2002 MGD '&"' quotes if there is a space in the string
19-AUG-2002 MGD '&[' for ODS file naming conversions,
'&^' now force-to-upper-case, '&!' force-to-lower,
'&_' underlines if there is a space in the string
08-AUG-2002 MGD '&U' request URI (mask password) now '&P',
'&U' now URL-encodes a URL (allowing for query string, etc.)
16-JUN-2002 MGD make field-width work for '&,'
31-MAR-2002 MGD '&U' request URI (mask password)
17-MAR-2002 MGD 'SQ' kludge for VAX quadword values
10-JAN-2002 MGD add !&R and !&O
04-AUG-2001 MGD differentiate WASD extensions with '!&',
support module WATCHing
07-JUL-2001 MGD add !IP to FaolSAK()
17-MAY-2001 MGD dignified with a module of its own
02-FEB-2001 MGD add !%I to FaolSAK()
27-AUG-2000 MGD add !SL to FaolSAK()
04-MAR-2000 MGD add FaolSAK() and its siblings
FaoToBuffer(), FaolToBuffer(), FaoToNet()
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
#undef _VMS__V6__SOURCE
#define _VMS__V6__SOURCE
#undef __VMS_VER
#define __VMS_VER 70000000
#undef __CRTL_VER
#define __CRTL_VER 70000000
#endif
/* standard C header files */
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* VMS related header files */
#include <descrip.h>
#include <jpidef.h>
#include <libdef.h>
#include <libdtdef.h>
#include <lnmdef.h>
#include <opcdef.h>
#include <prvdef.h>
#include <psldef.h>
#include <rms.h>
#include <secdef.h>
#include <ssdef.h>
#include <stsdef.h>
/* application related header files */
#include "wasd.h"
#define WASD_MODULE "FAO"
/******************/
/* global storage */
/******************/
#if WATCH_MOD
BOOL DebugFaoSak;
# define DEBUG_FAOSAK DebugFaoSak
#else
# define DEBUG_FAOSAK 0
#endif
int OpcomMessages,
OpcomTarget;
char *FaoUrlEncodeTable [] =
{
"%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
"%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",
"%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
"%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",
"%20", "%21", "%22", "%23", "$", "%25", "%26", "%27",
"%28", "%29", "*", "%2b", "%2c", "-", ".", "/",
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "%3a", ";", "%3c", "%3d", "%3e", "%3f",
"%40", "A", "B", "C", "D", "E", "F", "G", /* 0x47 */
"H", "I", "J", "K", "L", "M", "N", "O", /* 0x4f */
"P", "Q", "R", "S", "T", "U", "V", "W", /* 0x57 */
"X", "Y", "Z", "%5b", "%5c", "%5d", "%5e", "_", /* 0x5f */
"%60", "a", "b", "c", "d", "e", "f", "g", /* 0x67 */
"h", "i", "j", "k", "l", "m", "n", "o", /* 0x6f */
"p", "q", "r", "s", "t", "u", "v", "w", /* 0x77 */
"x", "y", "z", "%7b", "%7c", "%7d", "~", "%7f",
"%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
"%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",
"%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
"%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",
"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",
"%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",
"%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",
"%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",
"%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",
"%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",
"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",
"%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",
"%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",
"%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",
"%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
"%ff", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"
};
/* keep this for a couple of versions until the above proves itself */
char *FaoUrlEncodeTable2 [] =
{
"%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
"%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",
"%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
"%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",
"%20", "%21", "%22", "%23", "$", "%25", "%26", "%27",
"%28", "%29", "*", "%2b", "%2c", "-", ".", "/",
"0", "1", "2", "3", "4", "5", "6", "7",
"8", "9", "%3a", ";", "%3c", "%3d", "%3e", "%3f",
"%40", "A", "B", "C", "D", "E", "F", "G", /* 0x47 */
"H", "I", "J", "K", "L", "M", "N", "O", /* 0x4f */
"P", "Q", "R", "S", "T", "U", "V", "W", /* 0x57 */
"X", "Y", "Z", "%5b", "%5c", "%5d", "%5e", "_", /* 0x5f */
"%60", "a", "b", "c", "d", "e", "f", "g", /* 0x67 */
"h", "i", "j", "k", "l", "m", "n", "o", /* 0x6f */
"p", "q", "r", "s", "t", "u", "v", "w", /* 0x77 */
"x", "y", "z", "%7b", "%7c", "%7d", "%7e", "%7f",
"%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
"%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",
"%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
"%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",
"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",
"%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",
"%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",
"%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",
"%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",
"%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",
"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",
"%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",
"%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",
"%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",
"%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
"%ff", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"
};
/********************/
/* external storage */
/********************/
#ifdef DBUG
extern BOOL Debug;
#else
#define Debug 0
#endif
extern BOOL OdsExtended;
extern int OutputBufferSize;
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck[],
SoftwareID[];
extern char *DayName[];
extern HTTPD_PROCESS HttpdProcess;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
FAOL Swiss Army Knife. This is the primary FAO function described in the
module prologue. It will be more than obvious it has been written to optimize
efficiency (in the author's limited appreciation anyway) rather than
readability.
*/
int FaolSAK
(
REQUEST_STRUCT *rqptr,
void *BufferPtr,
int BufferSize,
ushort *LengthPtr,
char *FormatString,
ulong *VectorPtr
)
{
#define FORMAT_STACK_MAX 8
static char HexDigits [] = "0123456789abcdef";
static char HexDigitsUpper [] = "0123456789ABCDEF";
static char EncBuffer [] = "%xx";
static char OneChar [] = "\0";
static $DESCRIPTOR (DayDateTimeFaoDsc, "!AZ, !#%D\0");
static $DESCRIPTOR (HexValueFaoDsc, "0x!8XL\0");
static $DESCRIPTOR (LengthStringFaoDsc, "{!UL}!-!#AZ\0");
static $DESCRIPTOR (Md5FaoDsc, "!8XL!8XL!8XL!8XL\0");
static $DESCRIPTOR (Md5WidthFaoDsc, "!#<!8XL!8XL!8XL!8XL!>\0");
static $DESCRIPTOR (PDFaoDsc, "!%D\0");
static $DESCRIPTOR (PIFaoDsc, "!%I\0");
static $DESCRIPTOR (PTFaoDsc, "!%T\0");
static $DESCRIPTOR (SLFaoDsc, "!SL\0");
static $DESCRIPTOR (SLWidthFaoDsc, "!#SL\0");
static $DESCRIPTOR (SQFaoDsc, "!@SQ\0");
static $DESCRIPTOR (SQWidthFaoDsc, "!#@SQ\0");
static $DESCRIPTOR (ULFaoDsc, "!UL\0");
static $DESCRIPTOR (ULWidthFaoDsc, "!#UL\0");
static $DESCRIPTOR (VmsStatusFaoDsc, "%X!8XL\0");
static $DESCRIPTOR (VmsStatusMsgFaoDsc, "%X!8XL (!AZ)\0");
static $DESCRIPTOR (WatchingAddressFaoDsc, "&!8XL/!AZ()\0");
static $DESCRIPTOR (WatchingFunctionFaoDsc, "!8XL()\0");
static $DESCRIPTOR (XLFaoDsc, "!XL\0");
static $DESCRIPTOR (XLWidthFaoDsc, "!#XL\0");
static $DESCRIPTOR (ZLFaoDsc, "!ZL\0");
static $DESCRIPTOR (ZLWidthFaoDsc, "!#ZL\0");
BOOL BigNumber,
CommaNumber,
FileSpec,
ForceLowerCase,
ForceUpperCase,
HtmlEscape,
IndirectValue,
PeriodNonPrintable,
QuoteIfSpace,
RightJustify,
SlashNonPrintable,
SpaceThenString,
TrailingNewlineString,
UnderlineIfSpace,
UrlEncode,
Utf8Encode;
int ch, fw, ofw, idx,
status,
CommaCount,
DescrLength,
FileOds,
LastNumericValue,
SysGetMsgFlags;
int64 Time64;
int64 *Time64Ptr;
ushort Length;
ulong DayOfWeek,
VectorValue;
ulong *ulptr;
char *bptr, *bzptr, *cptr, *fptr, *sptr, *zptr,
*HexDigitsPtr,
*LastFptr;
char *FormatStack [FORMAT_STACK_MAX];
char FileString [ODS_MAX_FILE_NAME_LENGTH],
String [2048];
$DESCRIPTOR (StringDsc, String);
struct dsc$descriptor *VmsDscPtr;
STR_DSC *sdptr,
*StrDscPtr;
STR_DSC_AUTO (BufferDsc);
#if WATCH_MOD
{
static BOOL DebugFaoSakCheck;
if (!DebugFaoSakCheck)
{
DebugFaoSakCheck = true;
DebugFaoSak = getenv ("WASD_DEBUG_FAOSAK");
}
}
#endif
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_FAO))
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO,
"FaolSAK() !&X !UL !&X !AZ",
BufferPtr, BufferSize, LengthPtr, FormatString);
status = SS$_NORMAL;
LastNumericValue = 1;
/* start with output-field-width set to infinite */
ofw = -1;
if (LengthPtr) *LengthPtr = 0;
if (BufferPtr)
{
if (BufferSize == -1)
{
/* writing to specified STR_DSC storage */
sdptr = StrDscPtr = (STR_DSC*)BufferPtr;
sdptr = StrDscBuffer (sdptr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
else
{
/* writing to specified char[] storage */
sdptr = StrDscPtr = StrDscExternal (NULL, &BufferDsc,
BufferPtr, BufferSize);
bptr = STR_DSC_PTR(sdptr) = BufferPtr;
bzptr = STR_DSC_PTR(sdptr) + BufferSize-1;
}
}
else
{
/* writing to network buffer */
sdptr = StrDscIfNotBegin (rqptr, &rqptr->NetWriteBufferDsc,
OutputBufferSize);
sdptr = StrDscPtr = StrDscBuffer (sdptr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
/* put initial format string into index zero of the format string stack */
idx = 0;
FormatStack[idx] = FormatString;
/*************************/
/* nested format strings */
/*************************/
for (;;)
{
/*****************/
/* format string */
/*****************/
fptr = FormatStack[idx];
while (*fptr)
{
while (*fptr && *fptr != '!' && ofw)
{
/* a literal character */
if (bptr < bzptr)
{
*bptr++ = *fptr++;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
/* if end of literal characters (i.e. not a '!') then break */
if (!*fptr) break;
/* if no character follows the '!' then just forget it */
LastFptr = fptr;
if (!*++fptr) break;
/*********************/
/* format directives */
/*********************/
if (DEBUG_FAOSAK)
fprintf (stdout, "fptr |%10.10s|\n", fptr);
fw = -1;
IndirectValue = false;
/*********************/
/* field width, etc. */
/*********************/
if (isdigit(*fptr))
{
/* field-width */
fw = atoi(fptr);
while (isdigit(*fptr)) fptr++;
/* for writes into network buffers, let's keep this < 1024 */
if (!BufferPtr) fw &= 0xfff;
}
else
if (*fptr == '#')
{
/* field-width from vector */
fptr++;
fw = (int)*VectorPtr++;
/* for writes into network buffers, let's keep this < 1024 */
if (!BufferPtr) fw &= 0xfff;
}
/** if (DEBUG_FAOSAK) fprintf (stdout, "fw: %d\n", fw); **/
if (*fptr == '@')
{
fptr++;
IndirectValue = true;
}
FileOds = 0;
DescrLength = -1;
CommaNumber = BigNumber = FileSpec = ForceLowerCase = ForceUpperCase =
HtmlEscape = PeriodNonPrintable = QuoteIfSpace = RightJustify =
SpaceThenString = SlashNonPrintable = TrailingNewlineString =
UnderlineIfSpace = UrlEncode = Utf8Encode = false;
while (*fptr == '&')
{
/************************/
/* formatting modifiers */
/************************/
if (SAME2(fptr,'&.'))
{
fptr += 2;
PeriodNonPrintable = true;
continue;
}
if (SAME2(fptr,'&\\'))
{
fptr += 2;
SlashNonPrintable = true;
continue;
}
if (SAME2(fptr,'&,,'))
{
fptr += 3;
BigNumber = CommaNumber = true;
continue;
}
if (SAME2(fptr,'&,'))
{
fptr += 2;
BigNumber = true;
continue;
}
if (SAME2(fptr,'&;'))
{
fptr += 2;
HtmlEscape = true;
continue;
}
if (SAME2(fptr,'&%'))
{
fptr += 2;
UrlEncode = true;
continue;
}
if (SAME2(fptr,'&['))
{
fptr += 2;
FileSpec = true;
/* get the numeric value of the file naming schema */
FileOds = *VectorPtr++;
continue;
}
if (SAME2(fptr,'&!'))
{
fptr += 2;
ForceLowerCase = true;
continue;
}
if (SAME2(fptr,'&^'))
{
fptr += 2;
ForceUpperCase = true;
continue;
}
if (SAME2(fptr,'&_'))
{
fptr += 2;
UnderlineIfSpace = true;
continue;
}
if (SAME2(fptr,'&"'))
{
fptr += 2;
QuoteIfSpace = true;
continue;
}
if (SAME2(fptr,'&+'))
{
fptr += 2;
SpaceThenString = true;
continue;
}
if (SAME2(fptr,'&/'))
{
fptr += 2;
TrailingNewlineString = true;
continue;
}
if (SAME2(fptr,'&8'))
{
fptr += 2;
Utf8Encode = true;
continue;
}
if (SAME2(fptr,'&>'))
{
fptr += 2;
RightJustify = true;
continue;
}
break;
}
if (*fptr == '@')
{
fptr++;
IndirectValue = true;
}
/* default is no string to copy if it drops through */
sptr = NULL;
/* directives in guessed order of most common usage */
if (SAME2(fptr,'AZ'))
{
/**************************/
/* null-terminated string */
/**************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
sptr = *(char*)*VectorPtr++;
}
else
sptr = (char*)*VectorPtr++;
if (WATCHMOD (rqptr, WATCH_MOD_FAO))
if (!sptr)
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO, "(null)");
if (!sptr) sptr = "";
/* null or empty string suppresses these */
if (!sptr[0]) SpaceThenString = TrailingNewlineString = false;
if (DEBUG_FAOSAK) fprintf (stdout, "!AZ |%s|\n", sptr);
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'UL') ||
SAME2(fptr,'&L'))
{
/*********************/
/* unsigned longword */
/*********************/
if (SAME2(fptr,'&L')) BigNumber = true;
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = *(ULONGPTR)VectorPtr++;
}
else
LastNumericValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!UL %d\n", LastNumericValue);
if (fw > 0 && !BigNumber)
status = sys$fao (&ULWidthFaoDsc, 0, &StringDsc,
fw, LastNumericValue);
else
status = sys$fao (&ULFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
if (!BigNumber) fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'XL'))
{
/************************/
/* hexadecimal longword */
/************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = *(ULONGPTR)VectorPtr++;
}
else
LastNumericValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!UL %d\n", LastNumericValue);
if (fw > 0 && !BigNumber)
status = sys$fao (&XLWidthFaoDsc, 0, &StringDsc,
fw, LastNumericValue);
else
status = sys$fao (&XLFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
if (!BigNumber) fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'ZL'))
{
/************************/
/* zero-filled longword */
/************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = *(ULONGPTR)VectorPtr++;
}
else
LastNumericValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!UL %d\n", LastNumericValue);
if (fw > 0 && !BigNumber)
status = sys$fao (&ZLWidthFaoDsc, 0, &StringDsc,
fw, LastNumericValue);
else
status = sys$fao (&ZLFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
if (!BigNumber) fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&@') ||
SAME2(fptr,'%%')) /* for backward compatibility */
{
/************************/
/* nested format string */
/************************/
fptr += 2;
if (idx >= FORMAT_STACK_MAX)
{
status = SS$_OVRMAXARG;
break;
}
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
cptr = *(char*)*VectorPtr++;
}
else
cptr = (char*)*VectorPtr++;
if (!cptr)
{
status = SS$_ACCVIO;
break;
}
/* if empty then just continue with the current format string */
if (!cptr[0]) continue;
/* save the current format string pointer */
FormatStack[idx++] = fptr;
/* set the new format string pointer */
fptr = FormatStack[idx] = cptr;
if (DEBUG_FAOSAK)
fprintf (stdout, "!&@ idx: %d fptr |%s|\n", idx, fptr);
continue;
}
else
if (SAME2(fptr,'&h') ||
SAME2(fptr,'&H'))
{
/***************/
/* hexadecimal */
/***************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
cptr = *(char*)*VectorPtr++;
}
else
cptr = (char*)*VectorPtr++;
if (!cptr)
sptr = "(null)";
else
{
if (SAME2(fptr,'&h'))
HexDigitsPtr = HexDigits;
else
HexDigitsPtr = HexDigitsUpper;
zptr = (sptr = String) + sizeof(String)-1;
if (fw < 0) fw = 32;
while (fw-- > 0)
{
if (sptr >= zptr) break;
*sptr++ = HexDigitsPtr[(*(uchar*)cptr >> 4) & 0x0f];
if (sptr >= zptr) break;
*sptr++ = HexDigitsPtr[*(uchar*)cptr & 0x0f];
cptr++;
}
*sptr = '\0';
sptr = String;
}
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&I'))
{
/**************************************/
/* dotted-decimal/IPv6-hex IP address */
/**************************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = *(ULONGPTR)VectorPtr++;
}
else
LastNumericValue = *VectorPtr++;
/* 'LastNumericValue' can be a pointer or an integer */
if (LastNumericValue)
sptr = TcpIpAddressToString (LastNumericValue, fw);
else
sptr = "(null)";
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&E'))
{
/*****************/
/* the next line */
/*****************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
sptr = *(char*)*VectorPtr++;
}
else
sptr = (char*)*VectorPtr++;
if (sptr)
{
for (zptr = sptr;
*zptr && *zptr != '\r' && *zptr != '\n';
zptr++);
/* use field-width to control how much of the string is output */
fw = zptr - sptr;
if (DEBUG_FAOSAK)
fprintf (stdout, "!&L |%*.*s|\n", fw, fw, sptr);
status = sys$fao (&LengthStringFaoDsc, 0, &StringDsc, fw, sptr);
sptr = String;
}
else
sptr = "{0}(null)";
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&M') ||
SAME2(fptr,'&m'))
{
/******************/
/* status message */
/******************/
if (SAME2(fptr,'&M'))
SysGetMsgFlags = 15;
else
SysGetMsgFlags = 1;
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
VectorValue = *(ULONGPTR)VectorPtr++;
}
else
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%M %d\n", VectorValue);
status = sys$getmsg (VectorValue, &Length, &StringDsc,
SysGetMsgFlags, 0);
if (VMSnok (status))
sptr = "*ERROR* sys$getmsg()";
else
{
(sptr = String)[Length] = '\0';
if (SysGetMsgFlags == 15) sptr++;
}
if (DEBUG_FAOSAK)
fprintf (stdout, "sys$getmsg() |%s|\n", String);
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'SQ'))
{
/*******************/
/* signed quadword */
/*******************/
/*
Note that the "!SQ" directive is being used, for VMS 6.2
the "!UQ" && "!UJ" loop infinitely for signed values.
Also note the indirect character MUST be used (i.e. "!@SQ").
Also that VAX doesn't support it - so a kludge is employed.
*/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = 0;
}
else
{
/* must be indirect */
#if WATCH_MOD
fprintf (stdout, "%%HTTPD-W-FAO, SS$_BADPARAM %s:%d\n \\%s\\\n",
FI_LI, fptr-2);
#endif /* WATCH_MOD */
status = SS$_BADPARAM;
break;
}
if (DEBUG_FAOSAK)
fprintf (stdout, "!SQ %d\n", LastNumericValue);
if (fw > 0 && !BigNumber)
status = sys$fao (&SQWidthFaoDsc, 0, &StringDsc,
fw, *VectorPtr++);
else
status = sys$fao (&SQFaoDsc, 0, &StringDsc,
*VectorPtr++);
if (VMSnok (status)) break;
if (!BigNumber) fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'SL'))
{
/*******************/
/* signed longword */
/*******************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
LastNumericValue = *(ULONGPTR)VectorPtr++;
}
else
LastNumericValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!SL %d\n", LastNumericValue);
if (fw > 0 && !BigNumber)
status = sys$fao (&SLWidthFaoDsc, 0, &StringDsc,
fw, LastNumericValue);
else
status = sys$fao (&SLFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
if (!BigNumber) fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'%D') ||
SAME2(fptr,'&D'))
{
/*************/
/* date/time */
/*************/
cptr = fptr;
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
Time64Ptr = *(INT64PTR)VectorPtr++;
}
else
Time64Ptr = *(INT64PTR)VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%D %d\n", Time64Ptr);
if (!Time64Ptr) sys$gettim (Time64Ptr = &Time64);
if (!*(INT64PTR)Time64Ptr)
sptr = "(none)";
else
{
status = sys$fao (&PDFaoDsc, 0, &StringDsc, Time64Ptr);
if (VMSnok (status)) break;
for (sptr = String; *sptr && *sptr != '-'; sptr++);
/* absolute times have leading space changed to leading zero */
if (*sptr && String[0] == ' ')
(sptr = String)[0] = '0';
else
if (*sptr)
sptr = String;
else
/* delta times have leading spaces absorbed */
for (sptr = String; *sptr && *sptr == ' '; sptr++);
if (SAME2(cptr,'&D'))
{
/* massage the time a little further */
for (cptr = sptr; *cptr && *cptr != ' '; cptr++);
if (*cptr)
if (sptr[2] == '-')
*cptr++ = ':';
else
*cptr++ = '-';
while (*cptr && *cptr != ':') cptr++;
if (*cptr) cptr++;
while (*cptr && *cptr != ':') cptr++;
*cptr = '\0';
}
}
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'%I'))
{
/***********************/
/* numeric to ASCII ID */
/***********************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
VectorValue = *(ULONGPTR)VectorPtr++;
}
else
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%D %d\n", VectorValue);
status = sys$fao (&PIFaoDsc, 0, &StringDsc, VectorValue);
if (VMSnok (status)) break;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'%T'))
{
/********/
/* time */
/********/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
Time64Ptr = *(INT64PTR)VectorPtr++;
}
else
Time64Ptr = *(INT64PTR)VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%T %d\n", Time64Ptr);
if (!Time64Ptr) sys$gettim (Time64Ptr = &Time64);
if (!*(INT64PTR)Time64Ptr)
{
sptr = "(none)";
if (fw > 0) fw = -1;
}
else
{
status = sys$fao (&PTFaoDsc, 0, &StringDsc, Time64Ptr);
if (VMSnok (status)) break;
sptr = String;
}
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'%s') ||
SAME2(fptr,'%S'))
{
/******************/
/* add 'S' or 's' */
/******************/
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%%c\n", *(fptr+1));
if (LastNumericValue == 1)
{
fptr += 2;
continue;
}
fptr++;
fw = -1;
if (*fptr++ == 's')
sptr = "s";
else
sptr = "S";
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'AC'))
{
/************************/
/* counted ASCII string */
/************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
cptr = *(char*)*VectorPtr++;
}
else
cptr = (char*)*VectorPtr++;
if (!cptr)
{
status = SS$_ACCVIO;
break;
}
if (DEBUG_FAOSAK)
fprintf (stdout, "!AC %d |%s|\n", (uint)*cptr, cptr+1);
/* get the count byte */
ch = (uint)*cptr++;
while (ch)
{
if (bptr < bzptr)
{
*bptr++ = *cptr++;
ch--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
/* only if required drop through to space-fill */
if (fw <= 0) continue;
/* no string to copy */
sptr = NULL;
}
else
if (SAME2(fptr,'&C'))
{
/* a single character */
fptr += 2;
String[0] = *VectorPtr++;
String[1] = '\0';
sptr = String;
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&P'))
{
/*****************/
/* mask password */
/*****************/
fptr += 2;
cptr = (char*)*VectorPtr++;
if (!cptr) cptr = "(null)";
zptr = (sptr = String) + sizeof(String)-1;
while (*cptr && sptr < zptr)
{
if (cptr[0] == ':' && cptr[1] == '/' && cptr[2] == '/') break;
*sptr++ = *cptr++;
}
if (*cptr)
{
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
if (sptr < zptr) *sptr++ = *cptr++;
while (*cptr && *cptr != '/' && *cptr != '@' && sptr < zptr)
*sptr++ = *cptr++;
if (*cptr == '@')
{
if (sptr < zptr) *sptr++ = *cptr++;
while (sptr > String && *sptr != ':') sptr--;
if (*sptr == ':')
{
sptr++;
while (*sptr && *sptr != '@') *sptr++ = '*';
if (*sptr) sptr++;
}
}
while (*cptr && sptr < zptr) *sptr++ = *cptr++;
}
*sptr = '\0';
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&U'))
{
/******************/
/* encode URL/URI */
/******************/
fptr += 2;
cptr = (char*)*VectorPtr++;
if (cptr)
StringUrlEncodeURL (cptr, sptr = String, sizeof(String));
else
sptr = "(null)";
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&W'))
{
/*********************/
/* weekday/date/time */
/*********************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
Time64Ptr = *(INT64PTR)VectorPtr++;
}
else
Time64Ptr = *(INT64PTR)VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!%%W %d\n", Time64Ptr);
if (!Time64Ptr) sys$gettim (Time64Ptr = &Time64);
if (!*(INT64PTR)Time64Ptr)
{
sptr = "(none)";
if (fw > 0) fw = -1;
}
else
if (VMSnok (lib$day_of_week (Time64Ptr, &DayOfWeek)))
sptr = "*ERROR*1";
else
if (VMSnok (sys$fao (&DayDateTimeFaoDsc, 0, &StringDsc,
DayName[DayOfWeek], fw > 0 ? fw : 23, Time64Ptr)))
sptr = "*ERROR*2";
else
sptr = String;
/* reset the field-width (only applies to date/time) */
if (fw > 0) fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&R'))
{
/************************/
/* radio button boolean */
/************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
VectorValue = *(ULONGPTR)VectorPtr++;
}
else
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!&? %d\n", VectorValue);
if (VectorValue) sptr = " CHECKED"; else sptr = "";
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&O'))
{
/*************************/
/* select option boolean */
/*************************/
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
VectorValue = *(ULONGPTR)VectorPtr++;
}
else
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!&? %d\n", VectorValue);
if (VectorValue) sptr = " SELECTED"; else sptr = "";
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&?'))
{
/**********************/
/* simple conditional */
/**********************/
/* e.g. "!&?string if *vector TRUE\rstring if FALSE\r" */
fptr += 2;
if (IndirectValue)
{
if (!*VectorPtr)
{
status = SS$_ACCVIO;
break;
}
VectorValue = *(ULONGPTR)VectorPtr++;
}
else
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!&? %d\n", VectorValue);
if (!VectorValue)
{
/* if false skip over the true string */
while (*fptr && *fptr != '\r') fptr++;
if (*fptr == '\r') fptr++;
if (!*fptr) break;
}
while (*fptr && *fptr != '\r' && fw && ofw)
{
if (bptr < bzptr)
{
*bptr++ = *fptr++;
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
if (*fptr != '\r')
{
/* field-width has expired before the return */
while (*fptr && *fptr != '\r') fptr++;
}
if (*fptr == '\r') fptr++;
if (VectorValue)
{
/* was true, skip over the false string */
while (*fptr && *fptr != '\r') fptr++;
if (*fptr == '\r') fptr++;
}
/* only if required drop through to space-fill */
if (fw <= 0) continue;
}
else
if (*fptr == '+')
{
/**************************/
/* discard next parameter */
/**************************/
fptr++;
VectorValue = *VectorPtr++;
if (DEBUG_FAOSAK)
fprintf (stdout, "!+ %d\n", VectorValue);
}
else
if (*fptr == '-')
{
/****************************/
/* reuse previous parameter */
/****************************/
fptr++;
VectorValue = *--VectorPtr;
if (DEBUG_FAOSAK)
fprintf (stdout, "!- %d\n", VectorValue);
}
else
if (*fptr == '!')
{
/****************************/
/* an escaped '!' character */
/****************************/
if (DEBUG_FAOSAK) fprintf (stdout, "!!\n");
fptr++;
sptr = "!";
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (*fptr == '*')
{
/*****************************/
/* multiple '*'+1 characters */
/*****************************/
if (DEBUG_FAOSAK) fprintf (stdout, "!*\n");
if (!*++fptr) fw = 0;
while (fw > 0 && ofw)
{
if (bptr < bzptr)
{
*bptr++ = *fptr;
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
if (*fptr) fptr++;
continue;
}
else
if (*fptr == '<')
{
/****************************/
/* begin output-field-width */
/****************************/
if (DEBUG_FAOSAK) fprintf (stdout, "!<\n");
fptr++;
if (ofw >= 0)
{
/* can't nest these little blighters! */
#if WATCH_MOD
fprintf (stdout, "%%HTTPD-W-FAO, SS$_BADPARAM %s:%d\n \\%s\\\n",
FI_LI, fptr-1);
#endif /* WATCH_MOD */
status = SS$_BADPARAM;
break;
}
ofw = fw;
continue;
}
else
if (*fptr == '>')
{
/**************************/
/* end output-field-width */
/**************************/
if (DEBUG_FAOSAK) fprintf (stdout, "!>\n");
fptr++;
if (ofw < 0)
{
/* didn't notice a leading "!<" */
#if WATCH_MOD
fprintf (stdout, "%%HTTPD-W-FAO, SS$_BADPARAM %s:%d\n \\%s\\\n",
FI_LI, fptr-1);
#endif /* WATCH_MOD */
status = SS$_BADPARAM;
break;
}
/* get (any) current outstanding that needs space-filling */
fw = ofw;
/* reset output-field-width to infinite */
ofw = -1;
/* only if required drop through to space-fill */
if (fw <= 0) continue;
}
/***********************/
/* mainly for WATCHing */
/***********************/
else
if (SAME2(fptr,'&A'))
{
/* an "address" as &x00000000 */
fptr += 2;
LastNumericValue = *VectorPtr++;
if (!LastNumericValue)
cptr = "null";
else
if (!(cptr = WatchFunction (LastNumericValue)))
cptr = "?";
status = sys$fao (&WatchingAddressFaoDsc, 0, &StringDsc,
LastNumericValue, cptr);
if (VMSnok (status)) break;
fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&B'))
{
/* a boolean */
fptr += 2;
LastNumericValue = *VectorPtr++;
if (LastNumericValue) sptr = "TRUE"; else sptr = "FALSE";
fw = -1;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&F'))
{
/* a "function" address as &00000000 */
fptr += 2;
LastNumericValue = *VectorPtr++;
status = sys$fao (&WatchingFunctionFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&S'))
{
/* VMS status value as %X00000000 */
fptr += 2;
LastNumericValue = *VectorPtr++;
if (LastNumericValue && VMSnok (LastNumericValue))
{
/* for non-success status provide corresponding message */
char Msg [256];
$DESCRIPTOR (MsgDsc, Msg);
SysGetMsgFlags = 15;
status = sys$getmsg (LastNumericValue, &Length, &MsgDsc,
SysGetMsgFlags, 0);
if (VMSnok (status))
strcpy (Msg, "*ERROR* sys$getmsg()");
else
Msg[Length] = '\0';
status = sys$fao (&VmsStatusMsgFaoDsc, 0, &StringDsc,
LastNumericValue, Msg);
}
else
status = sys$fao (&VmsStatusFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&X'))
{
/* hexadecimal as 0x00000000 */
fptr += 2;
LastNumericValue = *VectorPtr++;
status = sys$fao (&HexValueFaoDsc, 0, &StringDsc,
LastNumericValue);
if (VMSnok (status)) break;
fw = -1;
sptr = String;
/* drop through to buffer the string pointed to by 'sptr' */
}
else
if (SAME2(fptr,'&Z'))
{
/* a null-terminated string as {length}string */
fptr += 2;
sptr = (char*)*VectorPtr++;
if (sptr)
{
status = sys$fao (&LengthStringFaoDsc, 0, &StringDsc,
strlen(sptr), sptr);
sptr = String;
}
else
sptr = "{0}(null)";
if (DEBUG_FAOSAK) fprintf (stdout, "!AZ |%s|\n", sptr);
/* drop through to buffer the string pointed to by 'sptr' */
}
else
{
#if WATCH_MOD
fprintf (stdout, "%%HTTPD-W-FAO, SS$_BADPARAM %s:%d\n \\%s\\\n",
FI_LI, fptr);
#endif /* WATCH_MOD */
status = SS$_BADPARAM;
break;
}
/*********************************/
/* copy a string into the buffer */
/*********************************/
if (DEBUG_FAOSAK)
fprintf (stdout, "sptr |%s|\n", sptr ? sptr : "(null)");
if (sptr)
{
if (RightJustify)
{
/*****************/
/* right justify */
/*****************/
Length = fw - strlen(sptr);
while (fw && ofw && Length > 0)
{
if (bptr < bzptr)
{
*bptr++ = ' ';
Length--;
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
if (BigNumber && !CommaNumber)
{
/**************/
/* big number */
/**************/
if ((cptr = FaoBigNumber (sptr)) != sptr)
sptr = cptr;
else
CommaNumber = true;
}
if (CommaNumber)
{
/****************/
/* comma number */
/****************/
sptr = FaoCommaNumber (sptr);
}
}
if (sptr)
{
if (FileSpec)
{
/**********************/
/* file specification */
/**********************/
switch (FileOds)
{
case 0 :
case MAPURL_PATH_ODS_2 :
if (!ForceUpperCase) ForceLowerCase = true;
/* just leave 'sptr' the way it is! */
break;
#ifdef ODS_EXTENDED
case MAPURL_PATH_ODS_5 :
MapOds5VmsToUrl (FileString, sptr,
sizeof(FileString), true);
sptr = FileString;
break;
#endif /* ODS_EXTENDED */
case MAPURL_PATH_ODS_ADS :
case MAPURL_PATH_ODS_SMB :
MapOdsAdsVmsToUrl (FileString, sptr,
sizeof(FileString), true);
sptr = FileString;
break;
case MAPURL_PATH_ODS_PWK :
MapOdsPwkVmsToUrl (FileString, sptr,
sizeof(FileString), true);
sptr = FileString;
break;
case MAPURL_PATH_ODS_SRI :
MapOdsSriVmsToUrl (FileString, sptr,
sizeof(FileString), true);
sptr = FileString;
break;
default :
return (SS$_BADPARAM);
}
}
if (QuoteIfSpace || SpaceThenString || UnderlineIfSpace)
{
for (cptr = sptr; *cptr && *cptr != ' '; cptr++);
if (*cptr || SpaceThenString)
{
if (QuoteIfSpace)
cptr = "\"";
else
if (SpaceThenString)
cptr = " ";
else
cptr = "<u>";
while (*cptr)
{
if (bptr < bzptr)
{
*bptr++ = *cptr++;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
else
QuoteIfSpace = UnderlineIfSpace = false;
}
if (HtmlEscape)
{
/**********************/
/* HTML-escape string */
/**********************/
while (*sptr && fw && ofw)
{
fw--;
ofw--;
if (Utf8Encode && (*sptr & 0x80))
{
cptr = String;
cptr[0] = ((*sptr & 0xc0) >> 6) | 0xc0;
cptr[1] = (*sptr++ & 0x3f) | 0x80;
cptr[2] = '\0';
}
else
{
if (ForceLowerCase)
ch = TOLO(*sptr++);
else
if (ForceUpperCase)
ch = TOUP(*sptr++);
else
ch = *sptr++;
switch (ch)
{
case '<' :
cptr = "<";
break;
case '>' :
cptr = ">";
break;
case '&' :
cptr = "&";
break;
case '\"' :
if (QuoteIfSpace)
cptr = "\\"";
else
cptr = """;
break;
default :
/* insert this character as-is */
*(cptr = OneChar) = ch;
}
}
/* add the character(s) */
while (*cptr)
{
if (bptr < bzptr)
{
*bptr++ = *cptr++;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
}
else
if (UrlEncode)
{
/*********************/
/* URL-encode string */
/*********************/
while (*sptr && fw && ofw)
{
fw--;
ofw--;
cptr = NULL;
if (Utf8Encode && (*sptr & 0x80))
{
cptr = String;
ch = ((*sptr & 0xc0) >> 6) | 0xc0;
cptr[0]= FaoUrlEncodeTable[(uchar)ch][0];
cptr[1]= FaoUrlEncodeTable[(uchar)ch][1];
cptr[2]= FaoUrlEncodeTable[(uchar)ch][2];
ch = (*sptr++ & 0x3f) | 0x80;
cptr[3]= FaoUrlEncodeTable[(uchar)ch][0];
cptr[4]= FaoUrlEncodeTable[(uchar)ch][1];
cptr[5]= FaoUrlEncodeTable[(uchar)ch][2];
cptr[6] = '\0';
}
else
{
if (ForceLowerCase)
ch = TOLO(*sptr++);
else
if (ForceUpperCase)
ch = TOUP(*sptr++);
else
ch = *sptr++;
if (QuoteIfSpace && ch == '\"')
cptr = "%5c%22";
else
cptr = FaoUrlEncodeTable[(uchar)ch];
}
while (*cptr)
{
if (bptr < bzptr)
{
*bptr++ = *cptr++;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
}
else
{
/******************/
/* literal string */
/******************/
ch = '\0';
while (*sptr && fw && ofw)
{
if (bptr < bzptr)
{
if (ch)
{
*bptr++ = ch;
ch = '\0';
sptr++;
}
else
if (QuoteIfSpace && *sptr == '\"')
{
*bptr++ = '\\';
ch = *sptr;
}
else
if (PeriodNonPrintable && !isprint(*sptr))
{
*bptr++ = '.';
sptr++;
}
else
if (SlashNonPrintable && !isprint(*sptr))
{
switch (*sptr)
{
case '\a' : ch = 'a'; break;
case '\b' : ch = 'b'; break;
case '\f' : ch = 'f'; break;
case '\n' : ch = 'n'; break;
case '\r' : ch = 'r'; break;
case '\t' : ch = 't'; break;
case '\v' : ch = 'v'; break;
default : ch = '.';
}
*bptr++ = '\\';
}
else
if (Utf8Encode && (*sptr & 0x80))
{
*bptr++ = ((*sptr & 0xc0) >> 6) | 0xc0;
if (bptr < bzptr)
*bptr++ = (*sptr++ & 0x3f) | 0x80;
else
ch = (*sptr & 0x3f) | 0x80;
}
else
if (ForceLowerCase)
*bptr++ = TOLO(*sptr++);
else
if (ForceUpperCase)
*bptr++ = TOUP(*sptr++);
else
*bptr++ = *sptr++;
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
if (QuoteIfSpace || TrailingNewlineString || UnderlineIfSpace)
{
if (QuoteIfSpace)
cptr = "\"";
else
if (TrailingNewlineString)
cptr = "\n";
else
cptr = "</u>";
while (*cptr)
{
if (bptr < bzptr)
{
*bptr++ = *cptr++;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
}
/***************************************************/
/* if positive field-width, right-fill with spaces */
/***************************************************/
if (fw <= 0) continue;
while (fw > 0 && ofw)
{
if (bptr < bzptr)
{
*bptr++ = ' ';
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
/*********************/
/* end format string */
/*********************/
if (VMSnok (status)) break;
/* if there are still pointers on the format stack */
if (DEBUG_FAOSAK) fprintf (stdout, "idx: %d\n", idx);
if (!idx) break;
idx--;
}
/*****************************/
/* end nested format strings */
/*****************************/
if (VMSnok (status))
{
if (WATCHMOD (rqptr, WATCH_MOD_FAO))
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO, "ERROR !AZ", LastFptr);
/* if an error was detected append from the offending directive */
fptr = LastFptr;
while (*fptr)
{
if (bptr < bzptr)
{
*bptr++ = *fptr++;
fw--;
ofw--;
continue;
}
if (STR_DSC_IS_EXTERNAL(sdptr)) goto FaolSAKovf;
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
sdptr = StrDscBuffer (StrDscPtr);
bptr = STR_DSC_PTR(sdptr) + STR_DSC_LEN(sdptr);
bzptr = STR_DSC_PTR(sdptr) + STR_DSC_SIZE(sdptr);
}
}
*bptr = '\0';
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
if (LengthPtr)
{
if (STR_DSC_LEN(sdptr) > 65535)
{
/* indicate that we can't represent what we've written to buffer */
*LengthPtr = 65535;
status = SS$_BUFFEROVF;
}
else
*LengthPtr = (ushort)STR_DSC_LEN(sdptr);
}
if (Watch.Category)
{
/* if we're WATCHing anything at all */
if (VMSnok (status))
{
/* and an error is being reported */
int cnt;
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO, "!&S", status);
WatchDataFormatted ("!&Z\n", FormatString);
for (cnt = 0; cnt <= idx; cnt++)
WatchDataFormatted ("!UL !&Z\n", cnt, FormatStack[cnt]);
}
}
return (status);
FaolSAKovf:
{
/* writing to storage and it's overflowed */
*bptr = '\0';
STR_DSC_LEN(sdptr) = bptr - STR_DSC_PTR(sdptr);
if (LengthPtr) *LengthPtr = (ushort)STR_DSC_LEN(sdptr);
return (SS$_BUFFEROVF);
}
}
/*****************************************************************************/
/*
Given a string of digits, generate an equivalent exa, peta, giga, mega, kilo.
The logical name value can be "2" (MiB) or "10" (MB) or "0" (to disable).
*/
char* FaoBigNumber (char *digits)
{
static float BigNumberBytes = -1.0;
static char buf [32];
int dcnt;
float fdigits;
char ch;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
if (!digits || BigNumberBytes < 0.0)
{
BigNumberBytes = 0.0; /* default disabled */
if (cptr = SysTrnLnm (WASD_BIG_NUMBER))
{
if (atol (cptr) == 2)
BigNumberBytes = 1024.0;
else
if (atol (cptr) == 10)
BigNumberBytes = 1000.0;
else
{
BigNumberBytes = 0.0;
return (digits);
}
}
if (!digits) return (NULL);
}
if (BigNumberBytes == 0.0) return (digits);
dcnt = 0;
zptr = (sptr = buf) + sizeof(buf)-1;
for (cptr = digits; *cptr && sptr < zptr; *sptr++ = *cptr++) dcnt++;
*sptr = '\0';
if (dcnt <= 3) return (buf);
if (dcnt <= 6)
ch = 'k';
else
if (dcnt <= 9)
ch = 'M';
else
if (dcnt <= 12)
ch = 'G';
else
if (dcnt <= 12)
ch = 'P';
else
ch = 'E';
buf[6] = '\0';
fdigits = (float)atoi(buf) / BigNumberBytes;
if (fdigits >= 10.0)
sprintf (buf, "%.0f%c", fdigits, ch);
else
sprintf (buf, "%.1f%c", fdigits, ch);
return (buf);
}
/*****************************************************************************/
/*
Given a string of digits, generate a comma-separated equivalent.
*/
char* FaoCommaNumber (char *digits)
{
static char buf [32];
int ccnt;
char ch;
char *cptr, *sptr, *zptr;
/*********/
/* begin */
/*********/
for (ccnt = 0; digits[ccnt]; ccnt++);
if (((ccnt-1) / 3) < 1) return (digits);
zptr = (sptr = buf) + sizeof(buf)-1;
if (!(ccnt = ccnt % 3)) ccnt = 3;
cptr = digits;
while (*cptr && sptr < zptr)
{
if (!ccnt--)
{
*sptr++ = ',';
ccnt = 2;
}
if (sptr < zptr) *sptr++ = *cptr++;
}
*sptr = '\0';
return (buf);
}
/*****************************************************************************/
/*
Sanity bugchecks if |VectorPtr| has overflowed the |FaoVector| space.
Should be called immedaitely before the FaoToBuffer() call for writes that have
the potential to become buggy because of code modifications (and yes, I got
caught, and yes it cost me a few hours).
*/
FaoCheck
(
int SizeOfFaoVector,
ulong *FaoVectorPtr,
ulong *VectorPtr,
char *SourceModuleName,
int SourceLineNumber
)
{
char String [64];
/*********/
/* begin */
/*********/
if ((uchar*)VectorPtr - (uchar*)FaoVectorPtr <= SizeOfFaoVector) return;
sprintf (String, "storage: %d vector: %d (longwords)",
SizeOfFaoVector/ sizeof(ulong),
((uchar*)VectorPtr - (uchar*)FaoVectorPtr) / sizeof(ulong));
ErrorExitVmsStatus (SS$_BUGCHECK, String,
SourceModuleName, SourceLineNumber);
}
/*****************************************************************************/
/*
This is a variable-argument wrapper for FaolSAK(), see that for greater
detail. This function just gets all the arguments from the call stack and puts
them into a longword vector that FaolSAK() can use. 'LengthPtr'
provides storage for returning the length of the generated string. The
resultant string is always null-terminated (unless an error), hence the
'BufferSize' can always only store 'BufferSize'-1 characters. 'LengthPtr'
provides storage for the number of characters minus the null-termination. If
'BufferSize' is passed containing -1 then the 'BufferPtr' specifies a STR_DSC
structure.
*/
int FaoToBuffer
(
char *BufferPtr,
int BufferSize,
ushort *LengthPtr,
char *FormatString,
...
)
{
int status,
argcnt;
ulong *vecptr;
ulong FaoVector [128];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO, "FaoToBuffer() !UL !8XL !SL",
argcnt, BufferPtr, BufferSize);
if (argcnt > 128+4) return (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 4; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (NULL, BufferPtr, BufferSize, LengthPtr,
FormatString, &FaoVector);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO, "!&S", status);
return (status);
}
/*****************************************************************************/
/*
This is a variable-argument wrapper for FaolSAK(), see that for greater
detail. This function just gets all the arguments from the call stack and puts
them into a longword vector that FaolSAK() can use. Output is to the client
network write descriptor.
*/
int FaoToNet
(
REQUEST_STRUCT *rqptr,
char *FormatString,
...
)
{
int status,
argcnt;
ulong *vecptr;
ulong FaoVector [128];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if (WATCHMOD (rqptr, WATCH_MOD_FAO))
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO, "FaoToNet() !UL", argcnt);
if (argcnt > 128+2) return (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 2; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (rqptr, NULL, 0, NULL, FormatString, &FaoVector);
if (WATCHMOD (rqptr, WATCH_MOD_FAO))
WatchThis (WATCHITM(rqptr), WATCH_MOD_FAO, "!&S", status);
return (status);
}
/****************************************************************************/
/*
A fixed-size, internal buffer of 986 bytes maximum is used and the result
output as an OPCOM message.
*/
int FaoToOpcom
(
char *FormatString,
...
)
{
static $DESCRIPTOR (OpcomDsc, "");
int status,
argcnt;
ushort slen;
ulong *vecptr;
ulong FaoVector [128+2];
va_list argptr;
struct
{
ulong TargetType;
ulong RequestId;
char MsgText [986+1];
} OpcomMsg;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO,
"FaoToOpcom() !UL !AZ", argcnt, FormatString);
if (argcnt > 128+1) return (SS$_OVRMAXARG);
vecptr = FaoVector;
*vecptr++ = HttpdProcess.PrcNam;
*vecptr++ = FormatString;
va_start (argptr, FormatString);
for (argcnt -= 1; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (NULL, OpcomMsg.MsgText, sizeof(OpcomMsg.MsgText), &slen,
"Process !AZ reports\r\n!&@", &FaoVector);
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
if (DEBUG_FAOSAK)
fprintf (stdout, "%d |%s|\n", slen, OpcomMsg.MsgText);
OpcomMsg.TargetType = OPC$_RQ_RQST + ((OpcomTarget & 0xffffff) << 8);
OpcomMsg.RequestId = 0;
OpcomDsc.dsc$a_pointer = &OpcomMsg;
OpcomDsc.dsc$w_length = slen + 8;
status = sys$sndopr (&OpcomDsc, 0);
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
return (status);
}
/****************************************************************************/
/*
A fixed-size, (fairly large) internal buffer is used and the result output to
the <stdout> stream.
*/
int FaoToStdout
(
char *FormatString,
...
)
{
int status,
argcnt;
ushort slen;
ulong *vecptr;
ulong FaoVector [128];
char Buffer [32767];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO,
"FaoToStdout() !UL !AZ", argcnt, FormatString);
if (argcnt > 128+1) return (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 1; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (NULL, Buffer, sizeof(Buffer), &slen,
FormatString, &FaoVector);
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
fputs (Buffer, stdout);
return (status);
}
/*****************************************************************************/
/*
If |rqptr| is NULL then to <stdout> or the network if not. For sysPlus..().
*/
int FaoToEither
(
REQUEST_STRUCT *rqptr,
char *FormatString,
...
)
{
int status,
argcnt;
ushort slen;
ulong *vecptr;
ulong FaoVector [128];
char Buffer [32767];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO,
"FaoToEither() !UL !UL", rqptr, argcnt);
if (rqptr == (REQUEST_STRUCT*)-1) return (SS$_NORMAL);
if (argcnt > 128+2) return (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 2; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
if (rqptr)
status = FaolSAK (rqptr, NULL, 0, NULL, FormatString, &FaoVector);
else
{
status = FaolSAK (NULL, Buffer, sizeof(Buffer), &slen,
FormatString, &FaoVector);
if (VMSok (status)) fputs (Buffer, stdout);
}
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
return (status);
}
/*****************************************************************************/
/*
Format a string into memory. Return a string status value if a format error.
*/
char* FaoToMemory
(
REQUEST_STRUCT *rqptr,
char *FormatString,
...
)
{
int status,
argcnt;
ushort slen;
ulong *vecptr;
ulong FaoVector [128];
char *bptr;
char Buffer [32767];
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO, "FaoToMemory() !UL", argcnt);
if (argcnt > 128+1) return (NULL);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 2; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (NULL, Buffer, sizeof(Buffer), &slen,
FormatString, &FaoVector);
if (VMSnok (status))
{
slen = sprintf (Buffer, "[%%X%08.08X]", status);
FaoErrorNoticed (status, FormatString, FI_LI);
return (NULL);
}
if (rqptr)
bptr = VmGetHeap (rqptr, slen);
else
bptr = VmGet (slen);
strcpy (bptr, Buffer);
return (bptr);
}
/****************************************************************************/
/*
A fixed-size, (fairly large) internal buffer is used and the result output
usinf LIB$PUT_OUTPUT(). Initially for before DECC is intialised. Can be used
for any standard output that bypasses the CRTL.
*/
int FaoLibPutOutput
(
char *FormatString,
...
)
{
int status,
argcnt;
ushort slen;
ulong *vecptr;
ulong FaoVector [128];
char Buffer [32767];
$DESCRIPTOR (BufferDsc, Buffer);
va_list argptr;
/*********/
/* begin */
/*********/
va_count (argcnt);
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO,
"FaoLibPutOutput() !UL !AZ", argcnt, FormatString);
if (argcnt > 128+1) return (SS$_OVRMAXARG);
vecptr = FaoVector;
va_start (argptr, FormatString);
for (argcnt -= 1; argcnt; argcnt--)
*vecptr++ = va_arg (argptr, ulong);
va_end (argptr);
status = FaolSAK (NULL, Buffer, sizeof(Buffer), &slen,
FormatString, &FaoVector);
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
BufferDsc.dsc$w_length = slen;
status = lib$put_output (&BufferDsc);
if (VMSnok (status)) FaoErrorNoticed (status, NULL, FI_LI);
return (status);
}
/*****************************************************************************/
/*
ErrorNoticed() uses FaoToStdout() and FaoToOpcom().
Let's not potentially compound our problems by trying to use ErrorNoticed()
from within those functions!
*/
FaoErrorNoticed
(
int StatusValue,
char *Explanation,
char *SourceModuleName,
int SourceLineNumber
)
{
static char CurrentTime64 [24],
GetMsgBuffer [256];
static $DESCRIPTOR (CurrentTime64Dsc, CurrentTime64);
static $DESCRIPTOR (GetMsgDsc, GetMsgBuffer);
static $DESCRIPTOR (TimeFaoDsc, "!20%D\0");
ushort slen;
/*********/
/* begin */
/*********/
if WATCH_MODULE(WATCH_MOD_FAO)
WatchThis (WATCHALL, WATCH_MOD_FAO, "FaoErrorNoticed()");
sys$fao (&TimeFaoDsc, NULL, &CurrentTime64Dsc, 0);
sys$getmsg (StatusValue, &slen, &GetMsgDsc, 0, 0);
GetMsgBuffer[slen] = '\0';
fprintf (stdout, "%%HTTPD-W-NOTICED, %s, %s:%d, %s, %%X%08.08X\n-%s\n",
CurrentTime64, SourceModuleName, SourceLineNumber,
Explanation, StatusValue, GetMsgBuffer+1);
}
/****************************************************************************/