← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib5250/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
http://bugs.debian.org/561165
http://bugs.debian.org/561166
Fix many compiler warnings, especially implicit pointer conversions
(closes: #561165, #561166).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib5250/field.c
 
1
/* TN5250
 
2
 * Copyright (C) 1997-2008 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
}