~ubuntu-branches/ubuntu/maverick/tn5250/maverick

« back to all changes in this revision

Viewing changes to src/field.c

  • Committer: Bazaar Package Importer
  • Author(s): Carey Evans
  • Date: 2009-12-17 22:23:00 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20091217222300-cyutcin1bc0m9wrd
Tags: 0.17.4-2
Fix many compiler warnings, especially implicit pointer conversions
(closes: #561165, #561166).

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* TN5250
2
 
 * Copyright (C) 1997 Michael Madore
3
 
 * 
4
 
 * This file is part of TN5250.
5
 
 *
6
 
 * TN5250 is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU Lesser General Public License as published by
8
 
 * the Free Software Foundation; either version 2.1, or (at your option)
9
 
 * any later version.
10
 
 * 
11
 
 * TN5250 is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU Lesser General Public License for more details.
15
 
 * 
16
 
 * You should have received a copy of the GNU Lesser General Public License
17
 
 * along with this software; see the file COPYING.  If not, write to
18
 
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19
 
 * Boston, MA 02111-1307 USA
20
 
 * 
21
 
 */
22
 
 
23
 
#include "tn5250-private.h"
24
 
 
25
 
 
26
 
/****f* lib5250/tn5250_field_new
27
 
 * NAME
28
 
 *    tn5250_field_new
29
 
 * SYNOPSIS
30
 
 *    ret = tn5250_field_new (w);
31
 
 * INPUTS
32
 
 *    int                  w          - 
33
 
 * DESCRIPTION
34
 
 *    DOCUMENT ME!!!
35
 
 *****/
36
 
Tn5250Field *
37
 
tn5250_field_new (int w)
38
 
{
39
 
  Tn5250Field *This = tn5250_new (Tn5250Field, 1);
40
 
  if (This == NULL)
41
 
    {
42
 
      return NULL;
43
 
    }
44
 
  memset (This, 0, sizeof (Tn5250Field));
45
 
  This->id = -1;
46
 
  This->w = w;
47
 
  return This;
48
 
}
49
 
 
50
 
 
51
 
/****f* lib5250/tn5250_field_copy
52
 
 * NAME
53
 
 *    tn5250_field_copy
54
 
 * SYNOPSIS
55
 
 *    ret = tn5250_field_copy (This);
56
 
 * INPUTS
57
 
 *    Tn5250Field *        This       - 
58
 
 * DESCRIPTION
59
 
 *    DOCUMENT ME!!!
60
 
 *****/
61
 
Tn5250Field *
62
 
tn5250_field_copy (Tn5250Field * This)
63
 
{
64
 
  Tn5250Field *fld = tn5250_new (Tn5250Field, 1);
65
 
  if (fld == NULL)
66
 
    {
67
 
      return NULL;
68
 
    }
69
 
  memcpy (fld, This, sizeof (Tn5250Field));
70
 
  fld->next = NULL;
71
 
  fld->prev = NULL;
72
 
  fld->script_slot = NULL;
73
 
  return fld;
74
 
}
75
 
 
76
 
 
77
 
/****f* lib5250/tn5250_field_destroy
78
 
 * NAME
79
 
 *    tn5250_field_destroy
80
 
 * SYNOPSIS
81
 
 *    tn5250_field_destroy (This);
82
 
 * INPUTS
83
 
 *    Tn5250Field *        This       - 
84
 
 * DESCRIPTION
85
 
 *    DOCUMENT ME!!!
86
 
 *****/
87
 
void
88
 
tn5250_field_destroy (Tn5250Field * This)
89
 
{
90
 
  free (This);
91
 
}
92
 
 
93
 
 
94
 
#ifndef NDEBUG
95
 
/****f* lib5250/tn5250_field_dump
96
 
 * NAME
97
 
 *    tn5250_field_dump
98
 
 * SYNOPSIS
99
 
 *    tn5250_field_dump (This);
100
 
 * INPUTS
101
 
 *    Tn5250Field *        This       - 
102
 
 * DESCRIPTION
103
 
 *    DOCUMENT ME!!!
104
 
 *****/
105
 
void
106
 
tn5250_field_dump (Tn5250Field * This)
107
 
{
108
 
  Tn5250Uint16 ffw = This->FFW;
109
 
 
110
 
  TN5250_LOG (("tn5250_field_dump: ffw flags = "));
111
 
  if ((ffw & TN5250_FIELD_BYPASS) != 0)
112
 
    {
113
 
      TN5250_LOG (("bypass "));
114
 
    }
115
 
  if ((ffw & TN5250_FIELD_DUP_ENABLE) != 0)
116
 
    {
117
 
      TN5250_LOG (("dup-enable "));
118
 
    }
119
 
  if ((ffw & TN5250_FIELD_MODIFIED) != 0)
120
 
    {
121
 
      TN5250_LOG (("mdt "));
122
 
    }
123
 
  if ((ffw & TN5250_FIELD_AUTO_ENTER) != 0)
124
 
    {
125
 
      TN5250_LOG (("auto-enter"));
126
 
    }
127
 
  if ((ffw & TN5250_FIELD_FER) != 0)
128
 
    {
129
 
      TN5250_LOG (("fer "));
130
 
    }
131
 
  if ((ffw & TN5250_FIELD_MONOCASE) != 0)
132
 
    {
133
 
      TN5250_LOG (("monocase "));
134
 
    }
135
 
  if ((ffw & TN5250_FIELD_MANDATORY) != 0)
136
 
    {
137
 
      TN5250_LOG (("mandatory "));
138
 
    }
139
 
 
140
 
  TN5250_LOG (("\ntn5250_field_dump: fcw flags = "));
141
 
  if (This->resequence != 0)
142
 
    {
143
 
      TN5250_LOG (("Entry field resequencing: %d ", This->resequence));
144
 
    }
145
 
  if (This->magstripe)
146
 
    {
147
 
      TN5250_LOG (("Magnetic stripe reader entry field "));
148
 
    }
149
 
  if (This->lightpen)
150
 
    {
151
 
      TN5250_LOG (("Selector light pen or cursor select field "));
152
 
    }
153
 
  if (This->magandlight)
154
 
    {
155
 
      TN5250_LOG (("Magnetic stripe reader and selector light pen entry field "));
156
 
    }
157
 
  if (This->lightandattn)
158
 
    {
159
 
      TN5250_LOG (("Selector light pen and selectable attention entry field "));
160
 
    }
161
 
  if (This->ideographiconly)
162
 
    {
163
 
      TN5250_LOG (("Ideographic-only entry field "));
164
 
    }
165
 
  if (This->ideographicdatatype)
166
 
    {
167
 
      TN5250_LOG (("Ideographic data type entry field "));
168
 
    }
169
 
  if (This->ideographiceither)
170
 
    {
171
 
      TN5250_LOG (("Ideographic-either entry field "));
172
 
    }
173
 
  if (This->ideographicopen)
174
 
    {
175
 
      TN5250_LOG (("Ideographic-open entry field "));
176
 
    }
177
 
  if (This->transparency != 0)
178
 
    {
179
 
      TN5250_LOG (("Transparency entry field: %d ", This->transparency));
180
 
    }
181
 
  if (This->forwardedge)
182
 
    {
183
 
      TN5250_LOG (("Forward edge trigger entry field "));
184
 
    }
185
 
  if (This->continuous)
186
 
    {
187
 
      TN5250_LOG (("continuous "));
188
 
    }
189
 
  if (tn5250_field_is_continued_first (This))
190
 
    {
191
 
      TN5250_LOG (("(first) "));
192
 
    }
193
 
  if (tn5250_field_is_continued_middle (This))
194
 
    {
195
 
      TN5250_LOG (("(middle) "));
196
 
    }
197
 
  if (tn5250_field_is_continued_last (This))
198
 
    {
199
 
      TN5250_LOG (("(last) "));
200
 
    }
201
 
  if (This->wordwrap)
202
 
    {
203
 
      TN5250_LOG (("wordwrap "));
204
 
    }
205
 
  if (This->nextfieldprogressionid != 0)
206
 
    {
207
 
      TN5250_LOG (("cursor progression: %d ", This->nextfieldprogressionid));
208
 
    }
209
 
  if ((int) This->highlightentryattr != 0)
210
 
    {
211
 
      TN5250_LOG (("Highlighted entry field: %x ", This->highlightentryattr));
212
 
    }
213
 
  if ((int) This->pointeraid != 0)
214
 
    {
215
 
      TN5250_LOG (("Pointer device selection entry field: %x ", This->pointeraid));
216
 
    }
217
 
  if (This->selfcheckmod11)
218
 
    {
219
 
      TN5250_LOG (("Self-check modulus 11 entry field "));
220
 
    }
221
 
  if (This->selfcheckmod10)
222
 
    {
223
 
      TN5250_LOG (("Self-check modulus 10 entry field "));
224
 
    }
225
 
 
226
 
  TN5250_LOG (("\ntn5250_field_dump: type = %s\n",
227
 
               tn5250_field_description (This)));
228
 
  TN5250_LOG (("tn5250_field_dump: adjust = %s\ntn5250_field_dump: data = ",
229
 
               tn5250_field_adjust_description (This)));
230
 
  TN5250_LOG (("\n"));
231
 
}
232
 
#endif
233
 
 
234
 
 
235
 
/****f* lib5250/tn5250_field_hit_test
236
 
 * NAME
237
 
 *    tn5250_field_hit_test
238
 
 * SYNOPSIS
239
 
 *    ret = tn5250_field_hit_test (This, y, x);
240
 
 * INPUTS
241
 
 *    Tn5250Field *        This       - 
242
 
 *    int                  y          - 
243
 
 *    int                  x          - 
244
 
 * DESCRIPTION
245
 
 *    Determine if the screen position at row ``y'', column ``x'' is contained
246
 
 *    within this field.  (A hit-test, in other words.)
247
 
 *****/
248
 
int
249
 
tn5250_field_hit_test (Tn5250Field * This, int y, int x)
250
 
{
251
 
  int pos = (y * This->w) + x;
252
 
  return (pos >= tn5250_field_start_pos (This)
253
 
          && pos <= tn5250_field_end_pos (This));
254
 
}
255
 
 
256
 
 
257
 
/****f* lib5250/tn5250_field_start_pos
258
 
 * NAME
259
 
 *    tn5250_field_start_pos
260
 
 * SYNOPSIS
261
 
 *    ret = tn5250_field_start_pos (This);
262
 
 * INPUTS
263
 
 *    Tn5250Field *        This       - 
264
 
 * DESCRIPTION
265
 
 *    Figure out the starting address of this field.
266
 
 *****/
267
 
int
268
 
tn5250_field_start_pos (Tn5250Field * This)
269
 
{
270
 
  return This->start_row * This->w + This->start_col;
271
 
}
272
 
 
273
 
 
274
 
/****f* lib5250/tn5250_field_end_pos
275
 
 * NAME
276
 
 *    tn5250_field_end_pos
277
 
 * SYNOPSIS
278
 
 *    ret = tn5250_field_end_pos (This);
279
 
 * INPUTS
280
 
 *    Tn5250Field *        This       - 
281
 
 * DESCRIPTION
282
 
 *    Figure out the ending address of this field.
283
 
 *****/
284
 
int
285
 
tn5250_field_end_pos (Tn5250Field * This)
286
 
{
287
 
  return tn5250_field_start_pos (This) + tn5250_field_length (This) - 1;
288
 
}
289
 
 
290
 
 
291
 
/****f* lib5250/tn5250_field_end_row
292
 
 * NAME
293
 
 *    tn5250_field_end_row
294
 
 * SYNOPSIS
295
 
 *    ret = tn5250_field_end_row (This);
296
 
 * INPUTS
297
 
 *    Tn5250Field *        This       - 
298
 
 * DESCRIPTION
299
 
 *    Figure out the ending row of this field.
300
 
 *****/
301
 
int
302
 
tn5250_field_end_row (Tn5250Field * This)
303
 
{
304
 
  return tn5250_field_end_pos (This) / This->w;
305
 
}
306
 
 
307
 
 
308
 
/****f* lib5250/tn5250_field_end_col
309
 
 * NAME
310
 
 *    tn5250_field_end_col
311
 
 * SYNOPSIS
312
 
 *    ret = tn5250_field_end_col (This);
313
 
 * INPUTS
314
 
 *    Tn5250Field *        This       - 
315
 
 * DESCRIPTION
316
 
 *    Figure out the ending column of this field.
317
 
 *****/
318
 
int
319
 
tn5250_field_end_col (Tn5250Field * This)
320
 
{
321
 
  return tn5250_field_end_pos (This) % This->w;
322
 
}
323
 
 
324
 
 
325
 
/****f* lib5250/tn5250_field_description
326
 
 * NAME
327
 
 *    tn5250_field_description
328
 
 * SYNOPSIS
329
 
 *    ret = tn5250_field_description (This);
330
 
 * INPUTS
331
 
 *    Tn5250Field *        This       - 
332
 
 * DESCRIPTION
333
 
 *    Get a description of this field.
334
 
 *****/
335
 
const char *
336
 
tn5250_field_description (Tn5250Field * This)
337
 
{
338
 
  switch (This->FFW & TN5250_FIELD_FIELD_MASK)
339
 
    {
340
 
    case TN5250_FIELD_ALPHA_SHIFT:
341
 
      return "Alpha Shift";
342
 
    case TN5250_FIELD_DUP_ENABLE:
343
 
      return "Dup Enabled";
344
 
    case TN5250_FIELD_ALPHA_ONLY:
345
 
      return "Alpha Only";
346
 
    case TN5250_FIELD_NUM_SHIFT:
347
 
      return "Numeric Shift";
348
 
    case TN5250_FIELD_NUM_ONLY:
349
 
      return "Numeric Only";
350
 
    case TN5250_FIELD_KATA_SHIFT:
351
 
      return "Katakana";
352
 
    case TN5250_FIELD_DIGIT_ONLY:
353
 
      return "Digits Only";
354
 
    case TN5250_FIELD_MAG_READER:
355
 
      return "Mag Reader I/O Field";
356
 
    case TN5250_FIELD_SIGNED_NUM:
357
 
      return "Signed Numeric";
358
 
    default:
359
 
      return "(?)";
360
 
    }
361
 
}
362
 
 
363
 
 
364
 
/****f* lib5250/tn5250_field_adjust_description
365
 
 * NAME
366
 
 *    tn5250_field_adjust_description
367
 
 * SYNOPSIS
368
 
 *    ret = tn5250_field_adjust_description (This);
369
 
 * INPUTS
370
 
 *    Tn5250Field *        This       - 
371
 
 * DESCRIPTION
372
 
 *    Get a description of the mandatory fill mode for this field.
373
 
 *****/
374
 
const char *
375
 
tn5250_field_adjust_description (Tn5250Field * This)
376
 
{
377
 
  switch (This->FFW & TN5250_FIELD_MAND_FILL_MASK)
378
 
    {
379
 
    case TN5250_FIELD_NO_ADJUST:
380
 
      return "No Adjust";
381
 
    case TN5250_FIELD_MF_RESERVED_1:
382
 
      return "Reserved 1";
383
 
    case TN5250_FIELD_MF_RESERVED_2:
384
 
      return "Reserved 2";
385
 
    case TN5250_FIELD_MF_RESERVED_3:
386
 
      return "Reserved 3";
387
 
    case TN5250_FIELD_MF_RESERVED_4:
388
 
      return "Reserved 4";
389
 
    case TN5250_FIELD_RIGHT_ZERO:
390
 
      return "Right Adjust, Zero Fill";
391
 
    case TN5250_FIELD_RIGHT_BLANK:
392
 
      return "Right Adjust, Blank Fill";
393
 
    case TN5250_FIELD_MANDATORY_FILL:
394
 
      return "Mandatory Fill";
395
 
    default:
396
 
      return "";
397
 
    }
398
 
}
399
 
 
400
 
 
401
 
/****f* lib5250/tn5250_field_count_left
402
 
 * NAME
403
 
 *    tn5250_field_count_left
404
 
 * SYNOPSIS
405
 
 *    ret = tn5250_field_count_left (This, y, x);
406
 
 * INPUTS
407
 
 *    Tn5250Field *        This       - 
408
 
 *    int                  y          - 
409
 
 *    int                  x          - 
410
 
 * DESCRIPTION
411
 
 *    Return the number of characters in the this field which
412
 
 *    are to the left of the specified cursor position.  Used
413
 
 *    as an index to insert data when the user types.
414
 
 *****/
415
 
int
416
 
tn5250_field_count_left (Tn5250Field * This, int y, int x)
417
 
{
418
 
  int pos;
419
 
 
420
 
  pos = (y * This->w + x);
421
 
  pos -= tn5250_field_start_pos (This);
422
 
 
423
 
  TN5250_ASSERT (tn5250_field_hit_test (This, y, x));
424
 
  TN5250_ASSERT (pos >= 0);
425
 
  TN5250_ASSERT (pos < tn5250_field_length (This));
426
 
 
427
 
  return pos;
428
 
}
429
 
 
430
 
 
431
 
/****f* lib5250/tn5250_field_count_right
432
 
 * NAME
433
 
 *    tn5250_field_count_right
434
 
 * SYNOPSIS
435
 
 *    ret = tn5250_field_count_right (This, y, x);
436
 
 * INPUTS
437
 
 *    Tn5250Field *        This       - 
438
 
 *    int                  y          - 
439
 
 *    int                  x          - 
440
 
 * DESCRIPTION
441
 
 *    This returns the number of characters in the specified field
442
 
 *    which are to the right of the specified cursor position.
443
 
 *****/
444
 
int
445
 
tn5250_field_count_right (Tn5250Field * This, int y, int x)
446
 
{
447
 
  TN5250_ASSERT (tn5250_field_hit_test (This, y, x));
448
 
  return tn5250_field_end_pos (This) - (y * This->w + x);
449
 
}
450
 
 
451
 
 
452
 
/****f* lib5250/tn5250_field_valid_char
453
 
 * NAME
454
 
 *    tn5250_field_valid_char
455
 
 * SYNOPSIS
456
 
 *    ret = tn5250_field_valid_char (field, ch);
457
 
 * INPUTS
458
 
 *    Tn5250Field *        field      - 
459
 
 *    int                  ch         - 
460
 
 *    int         *        src        -
461
 
 * DESCRIPTION
462
 
 *    Determine if the supplied character is a valid data character
463
 
 *    for this field, and return system reference code for errors (SRC)
464
 
 *****/
465
 
int
466
 
tn5250_field_valid_char (Tn5250Field * field, int ch, int *src)
467
 
{
468
 
  TN5250_LOG (("HandleKey: fieldtype = %d; char = '%c'.\n",
469
 
               tn5250_field_type (field), ch));
470
 
 
471
 
  *src = TN5250_KBDSRC_NONE;
472
 
 
473
 
  switch (tn5250_field_type (field))
474
 
    {
475
 
    case TN5250_FIELD_ALPHA_SHIFT:
476
 
      return 1;
477
 
 
478
 
    case TN5250_FIELD_ALPHA_ONLY:
479
 
      if (!(isalpha (ch) || ch == ',' || ch == '.' || ch == '-' || ch == ' '))
480
 
        {
481
 
          *src = TN5250_KBDSRC_ALPHAONLY;
482
 
          return 0;
483
 
        }
484
 
      return 1;
485
 
 
486
 
    case TN5250_FIELD_NUM_SHIFT:
487
 
      return 1;
488
 
 
489
 
    case TN5250_FIELD_NUM_ONLY:
490
 
      if (!(isdigit (ch) || ch == ',' || ch == '.' || ch == '-' || ch == ' '))
491
 
        {
492
 
          *src = TN5250_KBDSRC_NUMONLY;
493
 
          return 0;
494
 
        }
495
 
      return 1;
496
 
 
497
 
    case TN5250_FIELD_KATA_SHIFT:
498
 
      TN5250_LOG (("KATAKANA not implemented.\n"));
499
 
      return 1;
500
 
 
501
 
    case TN5250_FIELD_DIGIT_ONLY:
502
 
      if (!isdigit (ch))
503
 
        {
504
 
          *src = TN5250_KBDSRC_ONLY09;
505
 
          return 0;
506
 
        }
507
 
      return 1;
508
 
 
509
 
    case TN5250_FIELD_MAG_READER:
510
 
      *src = TN5250_KBDSRC_DATA_DISALLOWED;
511
 
      return 0;
512
 
 
513
 
    case TN5250_FIELD_SIGNED_NUM:
514
 
      if (!isdigit (ch))
515
 
        {
516
 
          *src = TN5250_KBDSRC_ONLY09;
517
 
          return 0;
518
 
        }
519
 
      return 1;
520
 
    }
521
 
  return 0;
522
 
}
523
 
 
524
 
 
525
 
/****f* lib5250/tn5250_field_set_mdt
526
 
 * NAME
527
 
 *    tn5250_field_set_mdt
528
 
 * SYNOPSIS
529
 
 *    tn5250_field_set_mdt (This);
530
 
 * INPUTS
531
 
 *    Tn5250Field *        This       - 
532
 
 * DESCRIPTION
533
 
 *    Set the MDT flag for this field and for the table which owns it.
534
 
 *****/
535
 
void
536
 
tn5250_field_set_mdt (Tn5250Field * This)
537
 
{
538
 
  TN5250_ASSERT (This->table != NULL);
539
 
 
540
 
  /* Taken from tn5250j
541
 
   * get the first field of a continued edit field if it is continued
542
 
   */
543
 
  if ((This->continuous) && !tn5250_field_is_continued_first (This))
544
 
    {
545
 
      Tn5250Field *iter;
546
 
 
547
 
      for (iter = This->prev;
548
 
           (iter->continuous && !tn5250_field_is_continued_first (iter));
549
 
           iter = iter->prev)
550
 
        {
551
 
          TN5250_ASSERT (iter->continuous);
552
 
        }
553
 
 
554
 
      tn5250_field_set_mdt (iter);
555
 
      tn5250_dbuffer_set_mdt (iter->table);
556
 
    }
557
 
  else
558
 
    {
559
 
      This->FFW |= TN5250_FIELD_MODIFIED;
560
 
      tn5250_dbuffer_set_mdt (This->table);
561
 
    }
562
 
  return;
563
 
}
564
 
 
565
 
 
566
 
/****f* lib5250/tn5250_field_list_destroy
567
 
 * NAME
568
 
 *    tn5250_field_list_destroy
569
 
 * SYNOPSIS
570
 
 *    ret = tn5250_field_list_destroy (list);
571
 
 * INPUTS
572
 
 *    Tn5250Field *        list       - 
573
 
 * DESCRIPTION
574
 
 *    Destroy all fields in a field list.
575
 
 *****/
576
 
Tn5250Field *
577
 
tn5250_field_list_destroy (Tn5250Field * list)
578
 
{
579
 
  Tn5250Field *iter, *next;
580
 
 
581
 
  if ((iter = list) != NULL)
582
 
    {
583
 
      /*@-usereleased@ */
584
 
      do
585
 
        {
586
 
          next = iter->next;
587
 
          tn5250_field_destroy (iter);
588
 
          iter = next;
589
 
        }
590
 
      while (iter != list);
591
 
      /*@=usereleased@ */
592
 
    }
593
 
  return NULL;
594
 
}
595
 
 
596
 
 
597
 
/****f* lib5250/tn5250_field_list_add
598
 
 * NAME
599
 
 *    tn5250_field_list_add
600
 
 * SYNOPSIS
601
 
 *    ret = tn5250_field_list_add (list, node);
602
 
 * INPUTS
603
 
 *    Tn5250Field *        list       - 
604
 
 *    Tn5250Field *        node       - 
605
 
 * DESCRIPTION
606
 
 *    Add a field to the end of a list of fields.
607
 
 *****/
608
 
Tn5250Field *
609
 
tn5250_field_list_add (Tn5250Field * list, Tn5250Field * node)
610
 
{
611
 
  node->prev = node->next = NULL;
612
 
 
613
 
  if (list == NULL)
614
 
    {
615
 
      node->next = node->prev = node;
616
 
      return node;
617
 
    }
618
 
  node->next = list;
619
 
  node->prev = list->prev;
620
 
  node->prev->next = node;
621
 
  node->next->prev = node;
622
 
  return list;
623
 
}
624
 
 
625
 
 
626
 
/****f* lib5250/tn5250_field_list_remove
627
 
 * NAME
628
 
 *    tn5250_field_list_remove
629
 
 * SYNOPSIS
630
 
 *    ret = tn5250_field_list_remove (list, node);
631
 
 * INPUTS
632
 
 *    Tn5250Field *        list       - 
633
 
 *    Tn5250Field *        node       - 
634
 
 * DESCRIPTION
635
 
 *    Remove a field from a list of fields.
636
 
 *****/
637
 
Tn5250Field *
638
 
tn5250_field_list_remove (Tn5250Field * list, Tn5250Field * node)
639
 
{
640
 
  if (list == NULL)
641
 
    {
642
 
      return NULL;
643
 
    }
644
 
  if (list->next == list && list == node)
645
 
    {
646
 
      node->next = node->prev = NULL;
647
 
      return NULL;
648
 
    }
649
 
  if (list == node)
650
 
    {
651
 
      list = list->next;
652
 
    }
653
 
 
654
 
  node->next->prev = node->prev;
655
 
  node->prev->next = node->next;
656
 
  node->prev = node->next = NULL;
657
 
  return list;
658
 
}
659
 
 
660
 
 
661
 
/****f* lib5250/tn5250_field_list_find_by_id
662
 
 * NAME
663
 
 *    tn5250_field_list_find_by_id
664
 
 * SYNOPSIS
665
 
 *    ret = tn5250_field_list_find_by_id (list, id);
666
 
 * INPUTS
667
 
 *    Tn5250Field *        list       - 
668
 
 *    int                  id         - 
669
 
 * DESCRIPTION
670
 
 *    Find a field by its numeric id.
671
 
 *****/
672
 
Tn5250Field *
673
 
tn5250_field_list_find_by_id (Tn5250Field * list, int id)
674
 
{
675
 
  Tn5250Field *iter;
676
 
 
677
 
  if ((iter = list) != NULL)
678
 
    {
679
 
      do
680
 
        {
681
 
          if (iter->id == id)
682
 
            return iter;
683
 
          iter = iter->next;
684
 
        }
685
 
      while (iter != list);
686
 
    }
687
 
  return NULL;
688
 
}
689
 
 
690
 
 
691
 
/****f* lib5250/tn5250_field_list_copy
692
 
 * NAME
693
 
 *    tn5250_field_list_copy
694
 
 * SYNOPSIS
695
 
 *    ret = tn5250_field_list_copy (This);
696
 
 * INPUTS
697
 
 *    Tn5250Field *        This       - 
698
 
 * DESCRIPTION
699
 
 *    Copy all fields in a list to another list.
700
 
 *****/
701
 
Tn5250Field *
702
 
tn5250_field_list_copy (Tn5250Field * This)
703
 
{
704
 
  Tn5250Field *new_list = NULL, *iter, *new_field;
705
 
  if ((iter = This) != NULL)
706
 
    {
707
 
      do
708
 
        {
709
 
          new_field = tn5250_field_copy (iter);
710
 
          if (new_field != NULL)
711
 
            {
712
 
              new_list = tn5250_field_list_add (new_list, new_field);
713
 
            }
714
 
          iter = iter->next;
715
 
        }
716
 
      while (iter != This);
717
 
    }
718
 
  return new_list;
719
 
}