Download as
Browse Code »

Commit 4c176b46afbd9c6b7d98e07fbeb2c64e66b80d10

Authored by perry.werneck@gmail.com
1 parent f90ede05
Exists in master and in 5 other branches develop, edit-header-bar, keypads, script-support, v5.2

Movendo mais campos para a estrutura de sessao

Showing 5 changed files with 170 additions and 171 deletions   Show diff stats
src/include/lib3270/session.h
  Diff comments   View file @4c176b4
... ... @@ -104,6 +104,7 @@
104 104 unsigned short rows;
105 105 unsigned short cols;
106 106 int cursor_addr;
  107 + int buffer_addr;
107 108 char flipped;
108 109 int screen_alt; /**< alternate screen? */
109 110 int is_altbuffer;
... ... @@ -141,11 +142,11 @@
141 142 char reading;
142 143 char excepting;
143 144  
144   - /* State change callbacks. */
  145 + // State change callbacks.
145 146 struct lib3270_state_callback *st_callbacks[LIB3270_STATE_USER];
146 147 struct lib3270_state_callback *st_last[LIB3270_STATE_USER];
147 148  
148   - /* Session based callbacks */
  149 + // Session based callbacks
149 150 void (*configure)(H3270 *session, unsigned short rows, unsigned short cols);
150 151 void (*update)(H3270 *session, int baddr, unsigned char c, unsigned short attr, unsigned char cursor);
151 152 void (*changed)(H3270 *session, int bstart, int bend);
... ...
src/lib3270/ctlr.c
  Diff comments   View file @4c176b4
... ... @@ -52,12 +52,10 @@
52 52 #include "ft_dftc.h"
53 53 #include "hostc.h"
54 54 #include "kybdc.h"
55   -// #include "macrosc.h"
56 55 #include "popupsc.h"
57 56 #include "screenc.h"
58 57 #include "scrollc.h"
59 58 #include "seec.h"
60   -// #include "selectc.h"
61 59 #include "sfc.h"
62 60 #include "statusc.h"
63 61 #include "tablesc.h"
... ... @@ -76,7 +74,7 @@ extern unsigned char aid;
76 74 //int maxCOLS = 0;
77 75 // int cursor_addr;
78 76  
79   -int buffer_addr;
  77 +// int buffer_addr;
80 78 // Boolean screen_alt = False; /* alternate screen? */
81 79 // Boolean is_altbuffer = False;
82 80  
... ... @@ -180,8 +178,8 @@ void ctlr_reinit(H3270 *session, unsigned cmask)
180 178  
181 179 Replace(zero_buf, (unsigned char *)Calloc(sizeof(struct ea),sz));
182 180  
183   - session->cursor_addr = 0;
184   - buffer_addr = 0;
  181 + session->cursor_addr = 0;
  182 + session->buffer_addr = 0;
185 183 }
186 184 }
187 185  
... ... @@ -1161,12 +1159,12 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1161 1159 /* XXX: Should there be a ctlr_add_cs call here? */
1162 1160 #define START_FIELD(fa) { \
1163 1161 current_fa = fa; \
1164   - ctlr_add_fa(buffer_addr, fa, 0); \
1165   - ctlr_add_cs(buffer_addr, 0); \
1166   - ctlr_add_fg(buffer_addr, 0); \
1167   - ctlr_add_bg(buffer_addr, 0); \
1168   - ctlr_add_gr(buffer_addr, 0); \
1169   - ctlr_add_ic(buffer_addr, 0); \
  1162 + ctlr_add_fa(h3270.buffer_addr, fa, 0); \
  1163 + ctlr_add_cs(h3270.buffer_addr, 0); \
  1164 + ctlr_add_fg(h3270.buffer_addr, 0); \
  1165 + ctlr_add_bg(h3270.buffer_addr, 0); \
  1166 + ctlr_add_gr(h3270.buffer_addr, 0); \
  1167 + ctlr_add_ic(h3270.buffer_addr, 0); \
1170 1168 trace_ds("%s",see_attr(fa)); \
1171 1169 h3270.formatted = True; \
1172 1170 }
... ... @@ -1182,7 +1180,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1182 1180 default_cs = 0;
1183 1181 default_ic = 0;
1184 1182 trace_primed = True;
1185   - buffer_addr = h3270.cursor_addr;
  1183 + h3270.buffer_addr = h3270.cursor_addr;
1186 1184 if (WCC_RESET(buf[1])) {
1187 1185 if (erase)
1188 1186 reply_mode = SF_SRM_FIELD;
... ... @@ -1220,7 +1218,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1220 1218  
1221 1219 last_cmd = True;
1222 1220 last_zpt = False;
1223   - current_fa = get_field_attribute(&h3270,buffer_addr);
  1221 + current_fa = get_field_attribute(&h3270,h3270.buffer_addr);
1224 1222  
1225 1223 #define ABORT_WRITEx { \
1226 1224 rv = PDS_BAD_ADDR; \
... ... @@ -1241,22 +1239,23 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1241 1239 previous = ORDER;
1242 1240 cp++; /* skip field attribute */
1243 1241 START_FIELD(*cp);
1244   - ctlr_add_fg(buffer_addr, 0);
1245   - ctlr_add_bg(buffer_addr, 0);
1246   - INC_BA(buffer_addr);
  1242 + ctlr_add_fg(h3270.buffer_addr, 0);
  1243 + ctlr_add_bg(h3270.buffer_addr, 0);
  1244 + INC_BA(h3270.buffer_addr);
1247 1245 last_cmd = True;
1248 1246 last_zpt = False;
1249 1247 break;
1250 1248 case ORDER_SBA: /* set buffer address */
1251 1249 cp += 2; /* skip buffer address */
1252   - buffer_addr = DECODE_BADDR(*(cp-1), *cp);
  1250 + h3270.buffer_addr = DECODE_BADDR(*(cp-1), *cp);
1253 1251 END_TEXT("SetBufferAddress");
1254 1252 previous = SBA;
1255   - trace_ds("%s",rcba(buffer_addr));
1256   - if (buffer_addr >= h3270.cols * h3270.rows) {
  1253 + trace_ds("%s",rcba(h3270.buffer_addr));
  1254 + if (h3270.buffer_addr >= h3270.cols * h3270.rows)
  1255 + {
1257 1256 ABORT_WRITE("invalid SBA address");
1258 1257 }
1259   - current_fa = get_field_attribute(&h3270,buffer_addr);
  1258 + current_fa = get_field_attribute(&h3270,h3270.buffer_addr);
1260 1259 last_cmd = True;
1261 1260 last_zpt = False;
1262 1261 break;
... ... @@ -1265,7 +1264,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1265 1264 if (previous != SBA)
1266 1265 trace_ds("%s",rcba(buffer_addr));
1267 1266 previous = ORDER;
1268   - cursor_move(buffer_addr);
  1267 + cursor_move(h3270.buffer_addr);
1269 1268 last_cmd = True;
1270 1269 last_zpt = False;
1271 1270 break;
... ... @@ -1277,9 +1276,9 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1277 1276 * of an unprotected field, simply advance one
1278 1277 * position.
1279 1278 */
1280   - if (h3270.ea_buf[buffer_addr].fa &&
1281   - !FA_IS_PROTECTED(h3270.ea_buf[buffer_addr].fa)) {
1282   - INC_BA(buffer_addr);
  1279 + if (h3270.ea_buf[h3270.buffer_addr].fa &&
  1280 + !FA_IS_PROTECTED(h3270.ea_buf[h3270.buffer_addr].fa)) {
  1281 + INC_BA(h3270.buffer_addr);
1283 1282 last_zpt = False;
1284 1283 last_cmd = True;
1285 1284 break;
... ... @@ -1288,8 +1287,8 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1288 1287 * Otherwise, advance to the first position of the
1289 1288 * next unprotected field.
1290 1289 */
1291   - baddr = next_unprotected(buffer_addr);
1292   - if (baddr < buffer_addr)
  1290 + baddr = next_unprotected(h3270.buffer_addr);
  1291 + if (baddr < h3270.buffer_addr)
1293 1292 baddr = 0;
1294 1293 /*
1295 1294 * Null out the remainder of the current field -- even
... ... @@ -1300,21 +1299,21 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1300 1299 */
1301 1300 if (!last_cmd || last_zpt) {
1302 1301 trace_ds("(nulling)");
1303   - while ((buffer_addr != baddr) &&
1304   - (!h3270.ea_buf[buffer_addr].fa)) {
1305   - ctlr_add(buffer_addr, EBC_null, 0);
1306   - ctlr_add_cs(buffer_addr, 0);
1307   - ctlr_add_fg(buffer_addr, 0);
1308   - ctlr_add_bg(buffer_addr, 0);
1309   - ctlr_add_gr(buffer_addr, 0);
1310   - ctlr_add_ic(buffer_addr, 0);
1311   - INC_BA(buffer_addr);
  1302 + while ((h3270.buffer_addr != baddr) &&
  1303 + (!h3270.ea_buf[h3270.buffer_addr].fa)) {
  1304 + ctlr_add(h3270.buffer_addr, EBC_null, 0);
  1305 + ctlr_add_cs(h3270.buffer_addr, 0);
  1306 + ctlr_add_fg(h3270.buffer_addr, 0);
  1307 + ctlr_add_bg(h3270.buffer_addr, 0);
  1308 + ctlr_add_gr(h3270.buffer_addr, 0);
  1309 + ctlr_add_ic(h3270.buffer_addr, 0);
  1310 + INC_BA(h3270.buffer_addr);
1312 1311 }
1313 1312 if (baddr == 0)
1314 1313 last_zpt = True;
1315 1314 } else
1316 1315 last_zpt = False;
1317   - buffer_addr = baddr;
  1316 + h3270.buffer_addr = baddr;
1318 1317 last_cmd = True;
1319 1318 break;
1320 1319 case ORDER_RA: /* repeat to address */
... ... @@ -1389,34 +1388,34 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1389 1388 }
1390 1389 do {
1391 1390 if (add_dbcs) {
1392   - ctlr_add(buffer_addr, add_c1,
  1391 + ctlr_add(h3270.buffer_addr, add_c1,
1393 1392 default_cs);
1394 1393 } else {
1395 1394 if (ra_ge)
1396   - ctlr_add(buffer_addr, add_c1,
  1395 + ctlr_add(h3270.buffer_addr, add_c1,
1397 1396 CS_GE);
1398 1397 else if (default_cs)
1399   - ctlr_add(buffer_addr, add_c1,
  1398 + ctlr_add(h3270.buffer_addr, add_c1,
1400 1399 default_cs);
1401 1400 else
1402   - ctlr_add(buffer_addr, add_c1,
  1401 + ctlr_add(h3270.buffer_addr, add_c1,
1403 1402 0);
1404 1403 }
1405   - ctlr_add_fg(buffer_addr, default_fg);
1406   - ctlr_add_gr(buffer_addr, default_gr);
1407   - ctlr_add_ic(buffer_addr, default_ic);
1408   - INC_BA(buffer_addr);
  1404 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1405 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1406 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1407 + INC_BA(h3270.buffer_addr);
1409 1408 if (add_dbcs) {
1410   - ctlr_add(buffer_addr, add_c2,
  1409 + ctlr_add(h3270.buffer_addr, add_c2,
1411 1410 default_cs);
1412   - ctlr_add_fg(buffer_addr, default_fg);
1413   - ctlr_add_bg(buffer_addr, default_bg);
1414   - ctlr_add_gr(buffer_addr, default_gr);
1415   - ctlr_add_ic(buffer_addr, default_ic);
1416   - INC_BA(buffer_addr);
  1411 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1412 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1413 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1414 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1415 + INC_BA(h3270.buffer_addr);
1417 1416 }
1418   - } while (buffer_addr != baddr);
1419   - current_fa = get_field_attribute(&h3270,buffer_addr);
  1417 + } while (h3270.buffer_addr != baddr);
  1418 + current_fa = get_field_attribute(&h3270,h3270.buffer_addr);
1420 1419 last_cmd = True;
1421 1420 last_zpt = False;
1422 1421 break;
... ... @@ -1439,15 +1438,15 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1439 1438 ABORT_WRITE("EUA overwriting left half of DBCS character");
1440 1439 }
1441 1440 do {
1442   - if (h3270.ea_buf[buffer_addr].fa)
1443   - current_fa = h3270.ea_buf[buffer_addr].fa;
  1441 + if (h3270.ea_buf[h3270.buffer_addr].fa)
  1442 + current_fa = h3270.ea_buf[h3270.buffer_addr].fa;
1444 1443 else if (!FA_IS_PROTECTED(current_fa)) {
1445   - ctlr_add(buffer_addr, EBC_null,
  1444 + ctlr_add(h3270.buffer_addr, EBC_null,
1446 1445 CS_BASE);
1447 1446 }
1448   - INC_BA(buffer_addr);
1449   - } while (buffer_addr != baddr);
1450   - current_fa = get_field_attribute(&h3270,buffer_addr);
  1447 + INC_BA(h3270.buffer_addr);
  1448 + } while (h3270.buffer_addr != baddr);
  1449 + current_fa = get_field_attribute(&h3270,h3270.buffer_addr);
1451 1450 last_cmd = True;
1452 1451 last_zpt = False;
1453 1452 break;
... ... @@ -1461,13 +1460,13 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1461 1460 trace_ds("%s", see_ebc(*cp));
1462 1461 if (*cp)
1463 1462 trace_ds("'");
1464   - ctlr_add(buffer_addr, *cp, CS_GE);
1465   - ctlr_add_fg(buffer_addr, default_fg);
1466   - ctlr_add_bg(buffer_addr, default_bg);
1467   - ctlr_add_gr(buffer_addr, default_gr);
1468   - ctlr_add_ic(buffer_addr, default_ic);
1469   - INC_BA(buffer_addr);
1470   - current_fa = get_field_attribute(&h3270,buffer_addr);
  1463 + ctlr_add(h3270.buffer_addr, *cp, CS_GE);
  1464 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1465 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1466 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1467 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1468 + INC_BA(h3270.buffer_addr);
  1469 + current_fa = get_field_attribute(&h3270,h3270.buffer_addr);
1471 1470 last_cmd = False;
1472 1471 last_zpt = False;
1473 1472 break;
... ... @@ -1478,14 +1477,14 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1478 1477 previous = ORDER;
1479 1478 cp++;
1480 1479 na = *cp;
1481   - if (h3270.ea_buf[buffer_addr].fa) {
  1480 + if (h3270.ea_buf[h3270.buffer_addr].fa) {
1482 1481 for (i = 0; i < (int)na; i++) {
1483 1482 cp++;
1484 1483 if (*cp == XA_3270) {
1485 1484 trace_ds(" 3270");
1486 1485 cp++;
1487   - ctlr_add_fa(buffer_addr, *cp,
1488   - h3270.ea_buf[buffer_addr].cs);
  1486 + ctlr_add_fa(h3270.buffer_addr, *cp,
  1487 + h3270.ea_buf[h3270.buffer_addr].cs);
1489 1488 trace_ds("%s",see_attr(*cp));
1490 1489 } else if (*cp == XA_FOREGROUND) {
1491 1490 trace_ds("%s",
... ... @@ -1493,20 +1492,20 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1493 1492 *(cp + 1)));
1494 1493 cp++;
1495 1494 if (appres.m3279)
1496   - ctlr_add_fg(buffer_addr, *cp);
  1495 + ctlr_add_fg(h3270.buffer_addr, *cp);
1497 1496 } else if (*cp == XA_BACKGROUND) {
1498 1497 trace_ds("%s",
1499 1498 see_efa(*cp,
1500 1499 *(cp + 1)));
1501 1500 cp++;
1502 1501 if (appres.m3279)
1503   - ctlr_add_bg(buffer_addr, *cp);
  1502 + ctlr_add_bg(h3270.buffer_addr, *cp);
1504 1503 } else if (*cp == XA_HIGHLIGHTING) {
1505 1504 trace_ds("%s",
1506 1505 see_efa(*cp,
1507 1506 *(cp + 1)));
1508 1507 cp++;
1509   - ctlr_add_gr(buffer_addr, *cp & 0x0f);
  1508 + ctlr_add_gr(h3270.buffer_addr, *cp & 0x0f);
1510 1509 } else if (*cp == XA_CHARSET) {
1511 1510 int cs = 0;
1512 1511  
... ... @@ -1518,7 +1517,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1518 1517 cs = CS_APL;
1519 1518 else if (*cp == 0xf8)
1520 1519 cs = CS_DBCS;
1521   - ctlr_add_cs(buffer_addr, cs);
  1520 + ctlr_add_cs(h3270.buffer_addr, cs);
1522 1521 } else if (*cp == XA_ALL) {
1523 1522 trace_ds("%s",
1524 1523 see_efa(*cp,
... ... @@ -1528,7 +1527,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1528 1527 trace_ds("%s",
1529 1528 see_efa(*cp,
1530 1529 *(cp + 1)));
1531   - ctlr_add_ic(buffer_addr,
  1530 + ctlr_add_ic(h3270.buffer_addr,
1532 1531 (*(cp + 1) == 1));
1533 1532 cp++;
1534 1533 } else {
... ... @@ -1536,7 +1535,7 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1536 1535 cp++;
1537 1536 }
1538 1537 }
1539   - INC_BA(buffer_addr);
  1538 + INC_BA(h3270.buffer_addr);
1540 1539 } else
1541 1540 cp += na * 2;
1542 1541 last_cmd = True;
... ... @@ -1600,12 +1599,12 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1600 1599 }
1601 1600 if (!any_fa)
1602 1601 START_FIELD(0);
1603   - ctlr_add_cs(buffer_addr, efa_cs);
1604   - ctlr_add_fg(buffer_addr, efa_fg);
1605   - ctlr_add_bg(buffer_addr, efa_bg);
1606   - ctlr_add_gr(buffer_addr, efa_gr);
1607   - ctlr_add_ic(buffer_addr, efa_ic);
1608   - INC_BA(buffer_addr);
  1602 + ctlr_add_cs(h3270.buffer_addr, efa_cs);
  1603 + ctlr_add_fg(h3270.buffer_addr, efa_fg);
  1604 + ctlr_add_bg(h3270.buffer_addr, efa_bg);
  1605 + ctlr_add_gr(h3270.buffer_addr, efa_gr);
  1606 + ctlr_add_ic(h3270.buffer_addr, efa_ic);
  1607 + INC_BA(h3270.buffer_addr);
1609 1608 last_cmd = True;
1610 1609 last_zpt = False;
1611 1610 break;
... ... @@ -1671,12 +1670,12 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1671 1670 if (default_cs == CS_DBCS || d != DBCS_NONE) {
1672 1671 ABORT_WRITE("invalid format control order in DBCS field");
1673 1672 }
1674   - ctlr_add(buffer_addr, *cp, default_cs);
1675   - ctlr_add_fg(buffer_addr, default_fg);
1676   - ctlr_add_bg(buffer_addr, default_bg);
1677   - ctlr_add_gr(buffer_addr, default_gr);
1678   - ctlr_add_ic(buffer_addr, default_ic);
1679   - INC_BA(buffer_addr);
  1673 + ctlr_add(h3270.buffer_addr, *cp, default_cs);
  1674 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1675 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1676 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1677 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1678 + INC_BA(h3270.buffer_addr);
1680 1679 last_cmd = True;
1681 1680 last_zpt = False;
1682 1681 break;
... ... @@ -1695,12 +1694,12 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1695 1694 }
1696 1695 /* All is well. */
1697 1696 previous = ORDER;
1698   - ctlr_add(buffer_addr, *cp, default_cs);
1699   - ctlr_add_fg(buffer_addr, default_fg);
1700   - ctlr_add_bg(buffer_addr, default_bg);
1701   - ctlr_add_gr(buffer_addr, default_gr);
1702   - ctlr_add_ic(buffer_addr, default_ic);
1703   - INC_BA(buffer_addr);
  1697 + ctlr_add(h3270.buffer_addr, *cp, default_cs);
  1698 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1699 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1700 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1701 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1702 + INC_BA(h3270.buffer_addr);
1704 1703 last_cmd = True;
1705 1704 last_zpt = False;
1706 1705 break;
... ... @@ -1714,8 +1713,8 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1714 1713 if (d != DBCS_NONE && why == DBCS_FIELD) {
1715 1714 ABORT_WRITE("SI in DBCS field");
1716 1715 }
1717   - fa_addr = find_field_attribute(&h3270,buffer_addr);
1718   - baddr = buffer_addr;
  1716 + fa_addr = find_field_attribute(&h3270,h3270.buffer_addr);
  1717 + baddr = h3270.buffer_addr;
1719 1718 DEC_BA(baddr);
1720 1719 while (!aborted &&
1721 1720 ((fa_addr >= 0 && baddr != fa_addr) ||
... ... @@ -1734,19 +1733,19 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1734 1733 }
1735 1734 /* All is well. */
1736 1735 previous = ORDER;
1737   - ctlr_add(buffer_addr, *cp, default_cs);
1738   - ctlr_add_fg(buffer_addr, default_fg);
1739   - ctlr_add_bg(buffer_addr, default_bg);
1740   - ctlr_add_gr(buffer_addr, default_gr);
1741   - ctlr_add_ic(buffer_addr, default_ic);
1742   - INC_BA(buffer_addr);
  1736 + ctlr_add(h3270.buffer_addr, *cp, default_cs);
  1737 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1738 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1739 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1740 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1741 + INC_BA(h3270.buffer_addr);
1743 1742 last_cmd = True;
1744 1743 last_zpt = False;
1745 1744 break;
1746 1745 case FCORDER_NULL: /* NULL or DBCS control char */
1747 1746 previous = NULLCH;
1748 1747 add_dbcs = False;
1749   - d = ctlr_lookleft_state(buffer_addr, &why);
  1748 + d = ctlr_lookleft_state(h3270.buffer_addr, &why);
1750 1749 if (d == DBCS_RIGHT) {
1751 1750 ABORT_WRITE("NULL overwriting right half of DBCS character");
1752 1751 }
... ... @@ -1787,19 +1786,19 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1787 1786 END_TEXT("NULL");
1788 1787 add_c1 = *cp;
1789 1788 }
1790   - ctlr_add(buffer_addr, add_c1, default_cs);
1791   - ctlr_add_fg(buffer_addr, default_fg);
1792   - ctlr_add_bg(buffer_addr, default_bg);
1793   - ctlr_add_gr(buffer_addr, default_gr);
1794   - ctlr_add_ic(buffer_addr, default_ic);
1795   - INC_BA(buffer_addr);
  1789 + ctlr_add(h3270.buffer_addr, add_c1, default_cs);
  1790 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1791 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1792 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1793 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1794 + INC_BA(h3270.buffer_addr);
1796 1795 if (add_dbcs) {
1797   - ctlr_add(buffer_addr, add_c2, default_cs);
1798   - ctlr_add_fg(buffer_addr, default_fg);
1799   - ctlr_add_bg(buffer_addr, default_bg);
1800   - ctlr_add_gr(buffer_addr, default_gr);
1801   - ctlr_add_ic(buffer_addr, default_ic);
1802   - INC_BA(buffer_addr);
  1796 + ctlr_add(h3270.buffer_addr, add_c2, default_cs);
  1797 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1798 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1799 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1800 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1801 + INC_BA(h3270.buffer_addr);
1803 1802 }
1804 1803 last_cmd = False;
1805 1804 last_zpt = False;
... ... @@ -1845,20 +1844,20 @@ ctlr_write(unsigned char buf[], int buflen, Boolean erase)
1845 1844 #if defined(X3270_DBCS) /*[*/
1846 1845 }
1847 1846 #endif /*]*/
1848   - ctlr_add(buffer_addr, add_c1, default_cs);
1849   - ctlr_add_fg(buffer_addr, default_fg);
1850   - ctlr_add_bg(buffer_addr, default_bg);
1851   - ctlr_add_gr(buffer_addr, default_gr);
1852   - ctlr_add_ic(buffer_addr, default_ic);
1853   - INC_BA(buffer_addr);
  1847 + ctlr_add(h3270.buffer_addr, add_c1, default_cs);
  1848 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1849 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1850 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1851 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1852 + INC_BA(h3270.buffer_addr);
1854 1853 #if defined(X3270_DBCS) /*[*/
1855 1854 if (add_dbcs) {
1856   - ctlr_add(buffer_addr, add_c2, default_cs);
1857   - ctlr_add_fg(buffer_addr, default_fg);
1858   - ctlr_add_bg(buffer_addr, default_bg);
1859   - ctlr_add_gr(buffer_addr, default_gr);
1860   - ctlr_add_ic(buffer_addr, default_ic);
1861   - INC_BA(buffer_addr);
  1855 + ctlr_add(h3270.buffer_addr, add_c2, default_cs);
  1856 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1857 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1858 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1859 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1860 + INC_BA(h3270.buffer_addr);
1862 1861 }
1863 1862 #endif /*]*/
1864 1863 last_cmd = False;
... ... @@ -1930,14 +1929,14 @@ ctlr_write_sscp_lu(unsigned char buf[], int buflen)
1930 1929 * Insert NULLs to the end of the line and advance to
1931 1930 * the beginning of the next line.
1932 1931 */
1933   - s_row = buffer_addr / h3270.cols;
1934   - while ((buffer_addr / h3270.cols) == s_row) {
1935   - ctlr_add(buffer_addr, EBC_null, default_cs);
1936   - ctlr_add_fg(buffer_addr, default_fg);
1937   - ctlr_add_bg(buffer_addr, default_bg);
1938   - ctlr_add_gr(buffer_addr, default_gr);
1939   - ctlr_add_ic(buffer_addr, default_ic);
1940   - INC_BA(buffer_addr);
  1932 + s_row = h3270.buffer_addr / h3270.cols;
  1933 + while ((h3270.buffer_addr / h3270.cols) == s_row) {
  1934 + ctlr_add(h3270.buffer_addr, EBC_null, default_cs);
  1935 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1936 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1937 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1938 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1939 + INC_BA(h3270.buffer_addr);
1941 1940 }
1942 1941 break;
1943 1942  
... ... @@ -1945,17 +1944,17 @@ ctlr_write_sscp_lu(unsigned char buf[], int buflen)
1945 1944 /* Some hosts forget they're talking SSCP-LU. */
1946 1945 cp++;
1947 1946 i++;
1948   - trace_ds(" StartField%s %s [translated to space]\n",rcba(buffer_addr), see_attr(*cp));
1949   - ctlr_add(buffer_addr, EBC_space, default_cs);
1950   - ctlr_add_fg(buffer_addr, default_fg);
1951   - ctlr_add_bg(buffer_addr, default_bg);
1952   - ctlr_add_gr(buffer_addr, default_gr);
1953   - ctlr_add_ic(buffer_addr, default_ic);
1954   - INC_BA(buffer_addr);
  1947 + trace_ds(" StartField%s %s [translated to space]\n",rcba(h3270.buffer_addr), see_attr(*cp));
  1948 + ctlr_add(h3270.buffer_addr, EBC_space, default_cs);
  1949 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1950 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1951 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1952 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1953 + INC_BA(h3270.buffer_addr);
1955 1954 break;
1956 1955 case ORDER_IC:
1957 1956 trace_ds(" InsertCursor%s [ignored]\n",
1958   - rcba(buffer_addr));
  1957 + rcba(h3270.buffer_addr));
1959 1958 break;
1960 1959 case ORDER_SBA:
1961 1960 // baddr = DECODE_BADDR(*(cp+1), *(cp+2));
... ... @@ -1972,33 +1971,31 @@ ctlr_write_sscp_lu(unsigned char buf[], int buflen)
1972 1971 c = EBC_space;
1973 1972 else
1974 1973 c = *cp;
1975   - ctlr_add(buffer_addr, c, CS_GE);
1976   - ctlr_add_fg(buffer_addr, default_fg);
1977   - ctlr_add_bg(buffer_addr, default_bg);
1978   - ctlr_add_gr(buffer_addr, default_gr);
1979   - ctlr_add_ic(buffer_addr, default_ic);
1980   - INC_BA(buffer_addr);
  1974 + ctlr_add(h3270.buffer_addr, c, CS_GE);
  1975 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1976 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1977 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1978 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1979 + INC_BA(h3270.buffer_addr);
1981 1980 break;
1982 1981  
1983 1982 default:
1984   - ctlr_add(buffer_addr, *cp, default_cs);
1985   - ctlr_add_fg(buffer_addr, default_fg);
1986   - ctlr_add_bg(buffer_addr, default_bg);
1987   - ctlr_add_gr(buffer_addr, default_gr);
1988   - ctlr_add_ic(buffer_addr, default_ic);
1989   - INC_BA(buffer_addr);
  1983 + ctlr_add(h3270.buffer_addr, *cp, default_cs);
  1984 + ctlr_add_fg(h3270.buffer_addr, default_fg);
  1985 + ctlr_add_bg(h3270.buffer_addr, default_bg);
  1986 + ctlr_add_gr(h3270.buffer_addr, default_gr);
  1987 + ctlr_add_ic(h3270.buffer_addr, default_ic);
  1988 + INC_BA(h3270.buffer_addr);
1990 1989 break;
1991 1990 }
1992 1991 }
1993   - cursor_move(buffer_addr);
1994   - sscp_start = buffer_addr;
  1992 + cursor_move(h3270.buffer_addr);
  1993 + sscp_start = h3270.buffer_addr;
1995 1994  
1996 1995 /* Unlock the keyboard. */
1997 1996 aid = AID_NO;
1998 1997 do_reset(False);
1999 1998  
2000   - /* Let a script go. */
2001   -// sms_host_output();
2002 1999 }
2003 2000  
2004 2001 #if defined(X3270_DBCS) /*[*/
... ... @@ -2341,8 +2338,8 @@ ctlr_clear(H3270 *session, Boolean can_snap)
2341 2338 /* Clear the screen. */
2342 2339 (void) memset((char *)session->ea_buf, 0, session->rows*session->cols*sizeof(struct ea));
2343 2340 cursor_move(0);
2344   - buffer_addr = 0;
2345   - // unselect(0, ROWS*COLS);
  2341 + session->buffer_addr = 0;
  2342 + lib3270_unselect(session);
2346 2343 session->formatted = False;
2347 2344 default_fg = 0;
2348 2345 default_bg = 0;
... ... @@ -2368,8 +2365,8 @@ ctlr_blanks(void)
2368 2365 h3270.ea_buf[baddr].cc = EBC_space;
2369 2366 }
2370 2367 cursor_move(0);
2371   - buffer_addr = 0;
2372   - // unselect(0, ROWS*COLS);
  2368 + h3270.buffer_addr = 0;
  2369 + lib3270_unselect(&h3270);
2373 2370 h3270.formatted = False;
2374 2371 ALL_CHANGED;
2375 2372 }
... ...
src/lib3270/ctlr.h
  Diff comments   View file @4c176b4
... ... @@ -17,5 +17,5 @@
17 17 * External declarations for ctlr.c data structures.
18 18 */
19 19  
20   -extern int buffer_addr; /**< buffer address */
21   -extern struct ea *ea_buf; /**< 3270 device buffer */
  20 +// extern int buffer_addr; /**< buffer address */
  21 +// extern struct ea *ea_buf; /**< 3270 device buffer */
... ...
src/lib3270/kybd.c
  Diff comments   View file @4c176b4
... ... @@ -522,9 +522,10 @@ key_AID(unsigned char aid_code)
522 522 return;
523 523 }
524 524 }
525   - if (IN_SSCP && aid_code == AID_ENTER) {
  525 + if (IN_SSCP && aid_code == AID_ENTER)
  526 + {
526 527 /* Act as if the host had written our input. */
527   - buffer_addr = h3270.cursor_addr;
  528 + h3270.buffer_addr = h3270.cursor_addr;
528 529 }
529 530 if (!IN_SSCP || aid_code != AID_CLEAR) {
530 531 status_twait(&h3270);
... ... @@ -863,7 +864,7 @@ key_Character(int code, Boolean with_ge, Boolean pasting, Boolean *skipped)
863 864 */
864 865 xaddr = baddr;
865 866 DEC_BA(xaddr);
866   - if (ea_buf[xaddr].cc == EBC_so) {
  867 + if (h3270.ea_buf[xaddr].cc == EBC_so) {
867 868 DEC_BA(baddr);
868 869 if (!ins_prep(faddr, baddr, 1))
869 870 return False;
... ... @@ -892,7 +893,7 @@ key_Character(int code, Boolean with_ge, Boolean pasting, Boolean *skipped)
892 893 INC_BA(xaddr);
893 894 INC_BA(baddr);
894 895 INC_BA(xaddr);
895   - was_si = (ea_buf[xaddr].cc == EBC_si);
  896 + was_si = (h3270.ea_buf[xaddr].cc == EBC_si);
896 897 ctlr_add(xaddr, EBC_space, CS_BASE);
897 898 ctlr_add_fg(xaddr, 0);
898 899 ctlr_add_gr(xaddr, 0);
... ... @@ -2414,7 +2415,7 @@ LIB3270_ACTION( clear )
2414 2415 return 0;
2415 2416 }
2416 2417 #endif /*]*/
2417   - buffer_addr = 0;
  2418 + h3270.buffer_addr = 0;
2418 2419 ctlr_clear(&h3270,True);
2419 2420 cursor_move(0);
2420 2421 if (CONNECTED)
... ...
src/lib3270/sf.c
  Diff comments   View file @4c176b4
... ... @@ -573,7 +573,7 @@ sf_create_partition(unsigned char buf[], int buflen)
573 573 trace_ds(")\n");
574 574  
575 575 cursor_move(0);
576   - buffer_addr = 0;
  576 + h3270.buffer_addr = 0;
577 577  
578 578 return PDS_OKAY_NO_OUTPUT;
579 579 }
... ...