← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/common/parse_qsub.c

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/common/parse_qsub.c
 
1
/*___INFO__MARK_BEGIN__*/
 
2
/*************************************************************************
 
3
 * 
 
4
 *  The Contents of this file are made available subject to the terms of
 
5
 *  the Sun Industry Standards Source License Version 1.2
 
6
 * 
 
7
 *  Sun Microsystems Inc., March, 2001
 
8
 * 
 
9
 * 
 
10
 *  Sun Industry Standards Source License Version 1.2
 
11
 *  =================================================
 
12
 *  The contents of this file are subject to the Sun Industry Standards
 
13
 *  Source License Version 1.2 (the "License"); You may not use this file
 
14
 *  except in compliance with the License. You may obtain a copy of the
 
15
 *  License at http://gridengine.sunsource.net/Gridengine_SISSL_license.html
 
16
 * 
 
17
 *  Software provided under this License is provided on an "AS IS" basis,
 
18
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 
19
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 
20
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 
21
 *  See the License for the specific provisions governing your rights and
 
22
 *  obligations concerning the Software.
 
23
 * 
 
24
 *   The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 
25
 * 
 
26
 *   Copyright: 2001 by Sun Microsystems, Inc.
 
27
 * 
 
28
 *   All Rights Reserved.
 
29
 * 
 
30
 ************************************************************************/
 
31
/*___INFO__MARK_END__*/
 
32
#include <string.h>
 
33
#include <stdlib.h>
 
34
#include <unistd.h>
 
35
 
 
36
#include "symbols.h"
 
37
#include "sge_all_listsL.h"
 
38
#include "parse_qsubL.h"
 
39
#include "parse_job_cull.h"
 
40
#include "sge_mailrec.h"
 
41
#include "parse_qsub.h"
 
42
#include "sge_feature.h"
 
43
#include "sge_userset.h"
 
44
#include "sge_parse_num_par.h"
 
45
#include "parse.h"
 
46
#include "sge_options.h"
 
47
#include "sgermon.h"
 
48
#include "sge_log.h"
 
49
#include "cull_parse_util.h"
 
50
#include "sge_string.h"
 
51
#include "sge_stdlib.h"
 
52
#include "sge_answer.h"
 
53
#include "sge_range.h"
 
54
#include "sge_ckpt.h"
 
55
#include "sge_ulong.h"
 
56
#include "sge_str.h"
 
57
#include "sge_centry.h"
 
58
#include "sge_job.h"
 
59
#include "sge_var.h"
 
60
#include "sge_answer.h"
 
61
 
 
62
#include "msg_common.h"
 
63
 
 
64
static int sge_parse_priority(lList **alpp, int *valp, char *priority_str);
 
65
static int var_list_parse_from_environment(lList **lpp, char **envp);
 
66
static int sge_parse_hold_list(char *hold_str, u_long32 prog_number);
 
67
static int sge_parse_mail_options(lList **alpp, char *mail_str, u_long32 prog_number); 
 
68
static int cull_parse_destination_identifier_list(lList **lpp, char *dest_str);
 
69
static int sge_parse_checkpoint_interval(char *time_str); 
 
70
static int set_yn_option (lList **opts, u_long32 opt, char *arg, char *value,
 
71
                          lList **alp);
 
72
 
 
73
 
 
74
 
 
75
/*
 
76
** NAME
 
77
**   cull_parse_cmdline
 
78
** PARAMETER
 
79
**   prog_number         - program number (QSUB, QSH etc.)
 
80
**   arg_list            - argument string list, e.g. argv,
 
81
**                         knows qsub, qalter and qsh options
 
82
**   envp                - pointer to environment
 
83
**   pcmdline            - NULL or pointer to list, SPA_Type
 
84
**                         set to contain the parsed options
 
85
**   flags               - FLG_USE_PSEUDOS: apply the following syntax:
 
86
**                         the first non-switch token is the job script, what
 
87
**                         follows are job arguments, mark the tokens as "script"
 
88
**                         or "jobarg" in the SPA_switch field
 
89
**                         0: dont do that, if a non-switch occurs, add it to
 
90
**                         the list with SPA_switch "" (an argument to a non-existing
 
91
**                         switch)
 
92
**                         FLG_QALTER: change treatment of non-options to qalter-specific
 
93
**                         pseudo options (only if FLG_USE_PSEUDOS is given) and changes
 
94
**                         parsing of -h
 
95
**
 
96
** RETURN
 
97
**   answer list, AN_Type or NULL if everything ok, the following stati can occur:
 
98
**   STATUS_EUNKNOWN   - bad internal error like NULL pointer received or no memory
 
99
**   STATUS_EEXIST     - option has been specified more than once, should be treated
 
100
**                       as a warning
 
101
**   STATUS_ESEMANTIC  - option that should have an argument had none
 
102
**   STATUS_ESYNTAX    - error parsing option argument
 
103
** DESCRIPTION
 
104
**
 
105
** NOTES
 
106
**    MT-NOTE: cull_parse_cmdline() is MT safe
 
107
*/
 
108
lList *cull_parse_cmdline(
 
109
u_long32 prog_number,
 
110
char **arg_list,
 
111
char **envp,
 
112
lList **pcmdline,
 
113
u_long32 flags 
 
114
) {
 
115
   char **sp;
 
116
   lList *answer = NULL;
 
117
   char str[1024 + 1];
 
118
   char i_opt[SGE_PATH_MAX + 1];
 
119
   lListElem *ep_opt;
 
120
   int i_ret;
 
121
   u_long32 is_qalter = flags & FLG_QALTER;
 
122
   bool is_hold_option = false;
 
123
   int hard_soft_flag = 0;
 
124
 
 
125
   DENTER(TOP_LAYER, "cull_parse_cmdline");
 
126
 
 
127
   if (!arg_list || !pcmdline) {
 
128
      answer_list_add(&answer, MSG_PARSE_NULLPOINTERRECEIVED, 
 
129
                      STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
 
130
      DRETURN(answer);
 
131
   }
 
132
 
 
133
   sp = arg_list;
 
134
 
 
135
   /* reset hard/soft flag */
 
136
   hard_soft_flag = 0;
 
137
   while (*sp) {
 
138
 
 
139
/*----------------------------------------------------------------------------*/
 
140
      /* "-a date_time */
 
141
 
 
142
      if (!strcmp("-a", *sp)) {
 
143
         u_long32 timeval;
 
144
 
 
145
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
146
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING, 
 
147
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
148
         }
 
149
 
 
150
         /* next field(s) is "date_time" */
 
151
         sp++;
 
152
         if (!*sp) {
 
153
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
154
                                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S,"-a");
 
155
 
 
156
            DRETURN(answer);
 
157
         }
 
158
 
 
159
         if (!ulong_parse_date_time_from_string(&timeval, NULL, *sp)) {
 
160
            answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
161
                                    MSG_ANSWER_WRONGTIMEFORMATEXSPECIFIEDTOAOPTION_S, *sp);
 
162
            DRETURN(answer);
 
163
         }
 
164
 
 
165
         ep_opt = sge_add_arg(pcmdline, a_OPT, lUlongT, *(sp - 1), *sp);
 
166
         lSetUlong(ep_opt, SPA_argval_lUlongT, timeval);
 
167
 
 
168
         sp++;
 
169
         continue;
 
170
      }
 
171
 
 
172
/*-----------------------------------------------------------------------------*/
 
173
      /* "-A account_string" */
 
174
 
 
175
      if (!strcmp("-A", *sp)) {
 
176
 
 
177
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
178
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING, 
 
179
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
180
         }
 
181
 
 
182
         /* next field is account_string */
 
183
         sp++;
 
184
         if (!*sp) {
 
185
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
186
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-A");
 
187
             DRETURN(answer);
 
188
         }
 
189
 
 
190
         DPRINTF(("\"-A %s\"\n", *sp));
 
191
 
 
192
         ep_opt = sge_add_arg(pcmdline, A_OPT, lStringT, *(sp - 1), *sp);
 
193
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
194
 
 
195
         sp++;
 
196
         continue;
 
197
      }
 
198
 
 
199
/*----------------------------------------------------------------------------*/
 
200
      /* either
 
201
       *    -ar ar_id
 
202
       * or
 
203
       *    -ar ar_id_list
 
204
       */
 
205
      if (prog_number == QRSTAT) {
 
206
         /* "-ar  advance_reservation */
 
207
 
 
208
         if (!strcmp("-ar", *sp)) {
 
209
            lList *ar_id_list = NULL;
 
210
 
 
211
            sp++;
 
212
            if (!*sp) {
 
213
               answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, 
 
214
                                       ANSWER_QUALITY_ERROR, 
 
215
                                       MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, 
 
216
                                       "-ar");                
 
217
               DRETURN(answer);
 
218
            }
 
219
 
 
220
            DPRINTF(("\"-ar %s\"\n", *sp));
 
221
 
 
222
            ulong_list_parse_from_string(&ar_id_list, &answer, *sp, ",");
 
223
 
 
224
            ep_opt = sge_add_arg(pcmdline, ar_OPT, lListT, *(sp - 1), *sp);
 
225
            lSetList(ep_opt, SPA_argval_lListT, ar_id_list);
 
226
 
 
227
            sp++;
 
228
            continue;
 
229
         }  
 
230
      } else {
 
231
         /* "-ar  advance_reservation */
 
232
 
 
233
         if (!strcmp("-ar", *sp)) {
 
234
            u_long32 ar_id;
 
235
            double ar_id_d;
 
236
 
 
237
            sp++;
 
238
            if (!*sp) {
 
239
               answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, 
 
240
                                       ANSWER_QUALITY_ERROR, 
 
241
                                       MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, 
 
242
                                       "-ar");                
 
243
               DRETURN(answer);
 
244
            }
 
245
 
 
246
            if (!parse_ulong_val(&ar_id_d, NULL, TYPE_INT, *sp, NULL, 0)) {
 
247
               answer_list_add(&answer, MSG_PARSE_INVALID_AR_MUSTBEUINT,
 
248
                                STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
249
               DRETURN(answer);
 
250
            }
 
251
 
 
252
 
 
253
            if (ar_id_d < 0) {
 
254
               answer_list_add(&answer, MSG_PARSE_INVALID_AR_MUSTBEUINT,
 
255
                                STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
256
               DRETURN(answer);
 
257
            }
 
258
 
 
259
            ar_id = ar_id_d;
 
260
            
 
261
            ep_opt = sge_add_arg(pcmdline, ar_OPT, lUlongT, *(sp - 1), *sp);
 
262
            lSetUlong(ep_opt, SPA_argval_lUlongT, ar_id);
 
263
 
 
264
            sp++;
 
265
            continue;
 
266
         }  
 
267
      }
 
268
/*----------------------------------------------------------------------------*/
 
269
      /* "-ac context_list */
 
270
      if (!strcmp("-ac", *sp)) {
 
271
         lList *variable_list = NULL;
 
272
         lListElem* lep = NULL;
 
273
 
 
274
         /* next field is context_list */
 
275
         sp++;
 
276
         if (!*sp) {
 
277
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
278
                                     MSG_PARSE_ACOPTIONMUSTHAVECONTEXTLISTLISTARGUMENT);
 
279
             DRETURN(answer);
 
280
         }
 
281
 
 
282
         DPRINTF(("\"-ac %s\"\n", *sp));
 
283
         i_ret = var_list_parse_from_string(&variable_list, *sp, 0);
 
284
         if (i_ret) {
 
285
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, 
 
286
                                     MSG_ANSWER_WRONGCONTEXTLISTFORMATAC_S , *sp);
 
287
             DRETURN(answer);
 
288
         }
 
289
         ep_opt = sge_add_arg(pcmdline, ac_OPT, lListT, *(sp - 1), *sp);
 
290
         lep = lCreateElem(VA_Type);
 
291
         lSetString(lep, VA_variable, "+");
 
292
         lInsertElem(variable_list, NULL, lep);
 
293
         lSetList(ep_opt, SPA_argval_lListT, variable_list);
 
294
 
 
295
         sp++;
 
296
         continue;
 
297
      }
 
298
 
 
299
 
 
300
/*----------------------------------------------------------------------------*/
 
301
      /* "-b y|n" */
 
302
 
 
303
      if (!is_qalter && !strcmp("-b", *sp)) {
 
304
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
305
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
306
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
307
         }
 
308
 
 
309
         /* next field is "y|n" */
 
310
         sp++;
 
311
         if (!*sp) {
 
312
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
313
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S,"-b");
 
314
             DRETURN(answer);
 
315
         }
 
316
 
 
317
         DPRINTF(("\"-b %s\"\n", *sp));
 
318
 
 
319
         if (set_yn_option(pcmdline, b_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
320
            DRETURN(answer);
 
321
         }
 
322
 
 
323
         sp++;
 
324
         continue;
 
325
      }
 
326
 
 
327
 
 
328
/*-----------------------------------------------------------------------------*/
 
329
      /* "-c [op] interval */
 
330
 
 
331
      if (!strcmp("-c", *sp)) {
 
332
          int attr;
 
333
          long interval;
 
334
 
 
335
         /* next field is [op] interval */
 
336
         sp++;
 
337
         if (!*sp) {
 
338
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
339
                                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-c");  
 
340
            DRETURN(answer);
 
341
         }
 
342
 
 
343
         DPRINTF(("\"%s %s\"\n", *(sp - 1), *sp));
 
344
 
 
345
         attr = sge_parse_checkpoint_attr(*sp);
 
346
         if (attr == 0) {
 
347
            interval = sge_parse_checkpoint_interval(*sp);
 
348
            if (!interval) {
 
349
               answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, 
 
350
                                       MSG_PARSE_CARGUMENTINVALID);
 
351
               DRETURN(answer);
 
352
            }
 
353
            ep_opt = sge_add_arg(pcmdline, c_OPT, lLongT, *(sp - 1), *sp);
 
354
            lSetLong(ep_opt, SPA_argval_lLongT, (long) interval);
 
355
         }
 
356
         else if (attr == -1) {
 
357
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
358
                                    MSG_PARSE_CSPECIFIERINVALID);
 
359
            DRETURN(answer);
 
360
         }
 
361
         else {
 
362
            ep_opt = sge_add_arg(pcmdline, c_OPT, lIntT, *(sp - 1), *sp);
 
363
            lSetInt(ep_opt, SPA_argval_lIntT, attr);
 
364
         }
 
365
 
 
366
         sp++;
 
367
         continue;
 
368
      }
 
369
 
 
370
/*-----------------------------------------------------------------------------*/
 
371
      /* "-cell cell_name or -ckpt ckpt_object" */
 
372
 
 
373
      /* This is another small change that needed to be made to allow DRMAA to
 
374
       * resuse this method.  The -cat option doesn't actually exist for any
 
375
       * command line utility.  It is a qsub style representation of the
 
376
       * DRMAA_JOB_CATEGORY attribute.  It will be processed and removed by the
 
377
       * drmaa_job2sge_job method. */
 
378
      if (!strcmp ("-cat", *sp) || !strcmp("-cell", *sp) || !strcmp("-ckpt", *sp)) {
 
379
 
 
380
         /* next field is job_cat or cell_name or ckpt_object*/
 
381
         sp++;
 
382
         if (!*sp) {
 
383
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
384
                                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, *(sp - 1));
 
385
            DRETURN(answer);
 
386
         }
 
387
 
 
388
         DPRINTF(("\"%s %s\"\n", *(sp - 1), *sp));
 
389
 
 
390
         ep_opt = sge_add_arg(pcmdline, 0, lStringT, *(sp - 1), *sp);
 
391
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
392
 
 
393
         sp++;
 
394
         continue;
 
395
      }
 
396
 
 
397
/*-----------------------------------------------------------------------------*/
 
398
      /* "-clear" */
 
399
 
 
400
      if (!strcmp("-clear", *sp)) {
 
401
 
 
402
         DPRINTF(("\"%s\"\n", *sp));
 
403
         ep_opt = sge_add_noarg(pcmdline, clear_OPT, *sp, NULL);
 
404
 
 
405
         sp++;
 
406
         continue;
 
407
      }
 
408
 
 
409
/*-----------------------------------------------------------------------------*/
 
410
      /* "-explain" */
 
411
 
 
412
      if (!strcmp("-explain", *sp)) {
 
413
 
 
414
         DPRINTF(("\"%s\"\n", *sp));
 
415
         ep_opt = sge_add_noarg(pcmdline, explain_OPT, *sp, NULL);
 
416
 
 
417
         sp++;
 
418
         continue;
 
419
      }
 
420
 
 
421
/*-----------------------------------------------------------------------------*/
 
422
      /* "-xml" */
 
423
 
 
424
      if (!strcmp("-xml", *sp)) {
 
425
 
 
426
         DPRINTF(("\"%s\"\n", *sp));
 
427
         ep_opt = sge_add_noarg(pcmdline, xml_OPT, *sp, NULL);
 
428
 
 
429
         sp++;
 
430
         continue;
 
431
      }
 
432
 
 
433
/*-----------------------------------------------------------------------------*/
 
434
      /* "-cwd" is mapped as -wd with NULL path, this case is handled in the second parsing stage*/
 
435
 
 
436
      if (!strcmp("-cwd", *sp)) {
 
437
         ep_opt = sge_add_noarg(pcmdline, wd_OPT, "-wd", NULL);
 
438
         DPRINTF(("\"%s\"\n", *sp));
 
439
         
 
440
         sp++;
 
441
         continue;
 
442
      }
 
443
 
 
444
/*-----------------------------------------------------------------------------*/
 
445
      /* "-C directive_prefix" */
 
446
      if (!strcmp("-C", *sp)) {
 
447
 
 
448
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
449
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
450
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
451
         }
 
452
 
 
453
         /* next field is directive_prefix */
 
454
         sp++;
 
455
         if (!*sp) {
 
456
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
457
                                      MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-C");
 
458
             DRETURN(answer);
 
459
         }
 
460
 
 
461
         DPRINTF(("\"-C %s\"\n", *sp));
 
462
 
 
463
         ep_opt = sge_add_arg(pcmdline, C_OPT, lStringT, *(sp - 1), *sp);
 
464
 
 
465
         if (strlen(*sp) > 0) {
 
466
            lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
467
         }
 
468
 
 
469
         sp++;
 
470
         continue;
 
471
      }
 
472
 
 
473
/*----------------------------------------------------------------------------*/
 
474
      /* "-d time */
 
475
      if (!strcmp("-d", *sp)) {
 
476
         double timeval;
 
477
         char tmp[1000];
 
478
 
 
479
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
480
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
481
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
482
         }
 
483
 
 
484
         /* next field is "time" */
 
485
         sp++;
 
486
         if (!*sp) {
 
487
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
488
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-d");
 
489
             DRETURN(answer);
 
490
         }
 
491
 
 
492
         DPRINTF(("\"-d %s\"\n", *sp));
 
493
 
 
494
         if (!parse_ulong_val(&timeval, NULL, TYPE_TIM, *sp, tmp, sizeof(tmp)-1)) {
 
495
            answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
496
                                    MSG_ANSWER_WRONGTIMEFORMATEXSPECIFIEDTODOPTION_S, *sp);
 
497
            DRETURN(answer);
 
498
         }
 
499
 
 
500
         ep_opt = sge_add_arg(pcmdline, d_OPT, lUlongT, *(sp-1), *sp);
 
501
         lSetUlong(ep_opt, SPA_argval_lUlongT, timeval);
 
502
 
 
503
         sp++;
 
504
         continue;
 
505
      }
 
506
 
 
507
 
 
508
/*----------------------------------------------------------------------------*/
 
509
      /* "-dc simple_context_list */
 
510
      if (!strcmp("-dc", *sp)) {
 
511
         lList *variable_list = NULL;
 
512
         lListElem* lep = NULL;
 
513
 
 
514
         /* next field is simple_context_list */
 
515
         sp++;
 
516
         if (!*sp) {
 
517
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
518
                                     MSG_PARSE_DCOPTIONMUSTHAVESIMPLECONTEXTLISTARGUMENT);
 
519
             DRETURN(answer);
 
520
         }
 
521
 
 
522
         DPRINTF(("\"-dc %s\"\n", *sp));
 
523
         i_ret = var_list_parse_from_string(&variable_list, *sp, 0);
 
524
         if (i_ret) {
 
525
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, 
 
526
                                     MSG_PARSE_WRONGCONTEXTLISTFORMATDC_S, *sp);
 
527
             DRETURN(answer);
 
528
         }
 
529
         ep_opt = sge_add_arg(pcmdline, dc_OPT, lListT, *(sp - 1), *sp);
 
530
         lep = lCreateElem(VA_Type);
 
531
         lSetString(lep, VA_variable, "-");
 
532
         lInsertElem(variable_list, NULL, lep);
 
533
         lSetList(ep_opt, SPA_argval_lListT, variable_list);
 
534
 
 
535
         sp++;
 
536
         continue;
 
537
      }
 
538
 
 
539
 
 
540
      
 
541
/*----------------------------------------------------------------------------*/
 
542
      /* "-display -- only for qsh " */
 
543
 
 
544
      if (!strcmp("-display", *sp)) {
 
545
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
546
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
547
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
548
         }
 
549
 
 
550
         /* next field is display to redirect interactive jobs to */
 
551
         sp++;
 
552
         if (!*sp) {
 
553
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
554
                                     MSG_PARSE_DISPLAYOPTIONMUSTHAVEARGUMENT);
 
555
             DRETURN(answer);
 
556
         }
 
557
 
 
558
         DPRINTF(("\"-display %s\"\n", *sp));
 
559
 
 
560
         ep_opt = sge_add_arg(pcmdline, display_OPT, lStringT, *(sp - 1), *sp);
 
561
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
562
 
 
563
         sp++;
 
564
         continue;
 
565
 
 
566
      }
 
567
 
 
568
/*----------------------------------------------------------------------------*/
 
569
      /* "-dl date_time */
 
570
 
 
571
      if (!strcmp("-dl", *sp)) {
 
572
         u_long32 timeval;
 
573
 
 
574
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
575
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING, 
 
576
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
577
         }
 
578
 
 
579
         /* next field(s) is "date_time" */
 
580
         sp++;
 
581
         if (!*sp) {
 
582
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
583
                                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S,"-dl");
 
584
            DRETURN(answer);
 
585
         }
 
586
 
 
587
         if (!ulong_parse_date_time_from_string(&timeval, NULL, *sp)) {
 
588
            answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
589
                                    MSG_PARSE_WRONGTIMEFORMATXSPECTODLOPTION_S, *sp);
 
590
            DRETURN(answer);
 
591
         }
 
592
 
 
593
         ep_opt = sge_add_arg(pcmdline, dl_OPT, lUlongT, *(sp - 1), *sp);
 
594
         lSetUlong(ep_opt, SPA_argval_lUlongT, timeval);
 
595
 
 
596
         sp++;
 
597
         continue;
 
598
      }
 
599
 
 
600
/*----------------------------------------------------------------------------*/
 
601
 
 
602
      /* "-e path_name" */
 
603
 
 
604
      if (!strcmp("-e", *sp)) {
 
605
         lList *path_list = NULL;
 
606
 
 
607
         if (prog_number == QRSUB) {
 
608
            if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
609
               answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
610
                                       MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
611
            }
 
612
         }
 
613
 
 
614
         sp++;
 
615
         if (!*sp) {
 
616
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, 
 
617
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-e");
 
618
             DRETURN(answer);
 
619
         }
 
620
 
 
621
         DPRINTF(("\"-e %s\"\n", *sp));
 
622
 
 
623
         if (prog_number == QRSUB) {
 
624
            u_long32 timeval;
 
625
            if (!ulong_parse_date_time_from_string(&timeval, NULL, *sp)) {
 
626
               answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
627
                                       MSG_ANSWER_WRONGTIMEFORMATEXSPECIFIEDTOAOPTION_S, *sp);
 
628
               DRETURN(answer);
 
629
            }
 
630
            ep_opt = sge_add_arg(pcmdline, e_OPT, lUlongT, *(sp-1), *sp);
 
631
            lSetUlong(ep_opt, SPA_argval_lUlongT, timeval);
 
632
         } else {
 
633
            /* next field is path_name */
 
634
            i_ret = cull_parse_path_list(&path_list, *sp);
 
635
            if (i_ret) {
 
636
                answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
637
                                        MSG_PARSE_WRONGPATHLISTFORMATXSPECTOEOPTION_S, *sp);
 
638
                DRETURN(answer);
 
639
            }
 
640
            ep_opt = sge_add_arg(pcmdline, e_OPT, lListT, *(sp-1), *sp);
 
641
            lSetList(ep_opt, SPA_argval_lListT, path_list);
 
642
         }
 
643
 
 
644
         sp++;
 
645
         continue;
 
646
      }
 
647
 
 
648
/*----------------------------------------------------------------------------*/
 
649
 
 
650
      /* "-i path_name" */
 
651
 
 
652
      if (!strcmp("-i", *sp)) {
 
653
         lList *path_list = NULL;
 
654
 
 
655
         /* next field is path_name */
 
656
         sp++;
 
657
         if (!*sp) {
 
658
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
659
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-i");
 
660
             DRETURN(answer);
 
661
         }
 
662
 
 
663
         DPRINTF(("\"-i %s\"\n", *sp));
 
664
 
 
665
         i_ret = cull_parse_path_list(&path_list, *sp);
 
666
         if (i_ret) {
 
667
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
668
                                     MSG_PARSE_WRONGPATHLISTFORMATXSPECTOEOPTION_S, *sp);
 
669
             DRETURN(answer);
 
670
         }
 
671
         ep_opt = sge_add_arg(pcmdline, i_OPT, lListT, *(sp - 1), *sp);
 
672
         lSetList(ep_opt, SPA_argval_lListT, path_list);
 
673
 
 
674
         /* Save it for later comparison */
 
675
         strcpy(i_opt, *sp);
 
676
 
 
677
         sp++;
 
678
         continue;
 
679
      }
 
680
 
 
681
/*-----------------------------------------------------------------------------*/
 
682
      /* "-h [hold_list]" */
 
683
 
 
684
      if (!strcmp("-h", *sp)) {
 
685
            int hold;
 
686
            char *cmd_switch;
 
687
            char *cmd_arg = "";
 
688
         is_hold_option = true;
 
689
         cmd_switch = *sp;
 
690
 
 
691
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
692
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
693
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
694
         }
 
695
 
 
696
         if (is_qalter) {
 
697
            /* next field is hold_list */
 
698
            sp++;
 
699
            if (!*sp) {
 
700
                answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, 
 
701
                                        MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S,"-h");
 
702
                DRETURN(answer);
 
703
            }
 
704
            hold = sge_parse_hold_list(*sp, prog_number);
 
705
            if (hold == -1) {
 
706
                answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
707
                                        MSG_PARSE_UNKNOWNHOLDLISTXSPECTOHOPTION_S, *sp);
 
708
                DRETURN(answer);
 
709
            }
 
710
            cmd_arg = *sp;
 
711
         }
 
712
         else {
 
713
            hold = MINUS_H_TGT_USER;
 
714
         }
 
715
         DPRINTF(("\"-h %s\"\n", *sp));
 
716
 
 
717
         ep_opt = sge_add_arg(pcmdline, h_OPT, lIntT, cmd_switch, cmd_arg);
 
718
         lSetInt(ep_opt, SPA_argval_lIntT, hold);
 
719
 
 
720
         sp++;
 
721
         continue;
 
722
      }
 
723
 
 
724
/*-----------------------------------------------------------------------------*/
 
725
      /* "-hard" */
 
726
 
 
727
      if (!strcmp("-hard", *sp)) {
 
728
 
 
729
         DPRINTF(("\"%s\"\n", *sp));
 
730
 
 
731
         hard_soft_flag = 1;
 
732
         ep_opt = sge_add_noarg(pcmdline, hard_OPT, *sp, NULL);
 
733
 
 
734
         sp++;
 
735
         continue;
 
736
      }
 
737
 
 
738
/*----------------------------------------------------------------------------*/
 
739
     /*  -he y[es]|n[o] */
 
740
 
 
741
      if(!strcmp("-he", *sp)) {
 
742
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
743
            sprintf(str,
 
744
               MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S,
 
745
               *sp);
 
746
            answer_list_add(&answer, str, STATUS_EEXIST, ANSWER_QUALITY_WARNING);
 
747
         }
 
748
         /* next field is yes/no switch */
 
749
         sp++;
 
750
         if(!*sp) {
 
751
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
752
                                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-he");
 
753
            DRETURN(answer);
 
754
         }
 
755
         
 
756
         DPRINTF(("\"-he %s\"\n", *sp));
 
757
         
 
758
         if (set_yn_option(pcmdline, he_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
759
            DRETURN(answer);
 
760
         }
 
761
 
 
762
         sp++;
 
763
         continue;
 
764
      }
 
765
/*-----------------------------------------------------------------------------*/
 
766
      /* "-help" */
 
767
 
 
768
      if (!strcmp("-help", *sp)) {
 
769
         DPRINTF(("\"%s\"\n", *sp));
 
770
 
 
771
         ep_opt = sge_add_noarg(pcmdline, help_OPT, *sp, NULL);
 
772
 
 
773
         sp++;
 
774
         continue;
 
775
 
 
776
      }
 
777
 
 
778
/*-----------------------------------------------------------------------------*/
 
779
      /* "-hold_jid jid[,jid,...]" */
 
780
 
 
781
      if (!strcmp("-hold_jid", *sp)) {
 
782
         lList *jid_hold_list = NULL;
 
783
 
 
784
         /* next field is hold_list */
 
785
         sp++;
 
786
         if (!*sp) {
 
787
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
788
                                      MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-hold_jid");
 
789
             DRETURN(answer);
 
790
         }
 
791
 
 
792
         DPRINTF(("\"-hold_jid %s\"\n", *sp));
 
793
         i_ret = cull_parse_jid_hold_list(&jid_hold_list, *sp);
 
794
         if (i_ret) {
 
795
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
796
                        MSG_PARSE_WRONGJIDHOLDLISTFORMATXSPECTOHOLDJIDOPTION_S, *sp);
 
797
             DRETURN(answer);
 
798
         }
 
799
         ep_opt = sge_add_arg(pcmdline, hold_jid_OPT, lListT, *(sp - 1), *sp);
 
800
         lSetList(ep_opt, SPA_argval_lListT, jid_hold_list);
 
801
 
 
802
         sp++;
 
803
         continue;
 
804
      }
 
805
 
 
806
/*-----------------------------------------------------------------------------*/
 
807
      /* "-hold_jid_ad jid[,jid,...]" */
 
808
 
 
809
      if (!strcmp("-hold_jid_ad", *sp)) {
 
810
         lList *jid_ad_hold_list = NULL;
 
811
 
 
812
         /* next field is hold_list */
 
813
         sp++;
 
814
         if (!*sp) {
 
815
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
816
                                      MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-hold_jid_ad");
 
817
             DRETURN(answer);
 
818
         }
 
819
 
 
820
         DPRINTF(("\"-hold_jid_ad %s\"\n", *sp));
 
821
         i_ret = cull_parse_jid_hold_list(&jid_ad_hold_list, *sp);
 
822
         if (i_ret) {
 
823
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
824
                        MSG_PARSE_WRONGJIDHOLDLISTFORMATXSPECTOHOLDJIDADOPTION_S, *sp);
 
825
             DRETURN(answer);
 
826
         }
 
827
         ep_opt = sge_add_arg(pcmdline, hold_jid_ad_OPT, lListT, *(sp - 1), *sp);
 
828
         lSetList(ep_opt, SPA_argval_lListT, jid_ad_hold_list);
 
829
 
 
830
         sp++;
 
831
         continue;
 
832
      }
 
833
 
 
834
/*-----------------------------------------------------------------------------*/
 
835
      /* "-j y|n" */
 
836
 
 
837
      if (!strcmp("-j", *sp)) {
 
838
 
 
839
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
840
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
841
                   MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
842
         }
 
843
 
 
844
         /* next field is "y|n" */
 
845
         sp++;
 
846
         if (!*sp) {
 
847
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
848
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-j");
 
849
             DRETURN(answer);
 
850
         }
 
851
 
 
852
         DPRINTF(("\"-j %s\"\n", *sp));
 
853
 
 
854
         if (set_yn_option(pcmdline, j_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
855
            DRETURN(answer);
 
856
         }
 
857
 
 
858
         sp++;
 
859
         continue;
 
860
      }
 
861
 
 
862
/*----------------------------------------------------------------------------*/
 
863
      /* "-js jobshare */
 
864
 
 
865
      if (!strcmp("-js", *sp)) {
 
866
         u_long32 jobshare;
 
867
         double jobshare_d;
 
868
 
 
869
         sp++;
 
870
         if (!*sp) {
 
871
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
872
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-js");
 
873
            DRETURN(answer);
 
874
         }
 
875
 
 
876
         if (!parse_ulong_val(&jobshare_d, NULL, TYPE_INT, *sp, NULL, 0)) {
 
877
            answer_list_add(&answer, MSG_PARSE_INVALIDJOBSHAREMUSTBEUINT,
 
878
                             STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
879
            DEXIT;
 
880
            return answer;
 
881
         }
 
882
 
 
883
 
 
884
         if (jobshare_d < 0) {
 
885
            answer_list_add(&answer, MSG_PARSE_INVALIDJOBSHAREMUSTBEUINT,
 
886
                             STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
887
            DEXIT;
 
888
            return answer;
 
889
         }
 
890
 
 
891
         jobshare = jobshare_d;
 
892
         
 
893
         ep_opt = sge_add_arg(pcmdline, js_OPT, lUlongT, *(sp - 1), *sp);
 
894
         lSetUlong(ep_opt, SPA_argval_lUlongT, jobshare);
 
895
 
 
896
         sp++;
 
897
         continue;
 
898
      }
 
899
 
 
900
/*---------------------------------------------------------------------------*/
 
901
      /* "-l resource_list" */
 
902
 
 
903
      if (!strcmp("-l", *sp)) {
 
904
         lList *resource_list = NULL;
 
905
 
 
906
         /* next field is resource_list */
 
907
         sp++;
 
908
         if (!*sp) {
 
909
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
910
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-l" );
 
911
             DRETURN(answer);
 
912
         }
 
913
 
 
914
         DPRINTF(("\"-l %s\"\n", *sp));
 
915
 
 
916
         resource_list = centry_list_parse_from_string(NULL, *sp, false);
 
917
         if (!resource_list) {
 
918
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
919
                     MSG_PARSE_WRONGRESOURCELISTFORMATXSPECTOLOPTION_S, *sp);
 
920
             DRETURN(answer);
 
921
         }
 
922
 
 
923
         ep_opt = sge_add_arg(pcmdline, l_OPT, lListT, *(sp - 1), *sp);
 
924
         lSetList(ep_opt, SPA_argval_lListT, resource_list);
 
925
         lSetInt(ep_opt, SPA_argval_lIntT, hard_soft_flag);
 
926
 
 
927
         sp++;
 
928
         continue;
 
929
      }
 
930
 
 
931
 
 
932
/*----------------------------------------------------------------------------*/
 
933
      /* "-m mail_options */
 
934
 
 
935
      if (!strcmp("-m", *sp)) {
 
936
         int mail_options;
 
937
 
 
938
         /* next field is mail_options */
 
939
         sp++;
 
940
         if (!*sp) {
 
941
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
942
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-m");
 
943
             DRETURN(answer);
 
944
         }
 
945
 
 
946
         DPRINTF(("\"-m %s\"\n", *sp));
 
947
         mail_options = sge_parse_mail_options(&answer, *sp, prog_number);
 
948
         if (!mail_options) {
 
949
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
950
                    MSG_PARSE_WRONGMAILOPTIONSLISTFORMATXSPECTOMOPTION_S, *sp);
 
951
             DRETURN(answer);
 
952
         }
 
953
 
 
954
         ep_opt = sge_add_arg(pcmdline, m_OPT, lIntT, *(sp - 1), *sp);
 
955
         lSetInt(ep_opt, SPA_argval_lIntT, mail_options);
 
956
 
 
957
         sp++;
 
958
         continue;
 
959
      }
 
960
 
 
961
/*-----------------------------------------------------------------------------*/
 
962
      /* "-masterq destination_identifier_list" */
 
963
 
 
964
      if (!strcmp("-masterq", *sp)) {
 
965
         lList *id_list = NULL;
 
966
 
 
967
         /* next field is destination_identifier */
 
968
         sp++;
 
969
         if (!*sp) {
 
970
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
971
                    MSG_PARSE_XOPTIONMUSTHAVEDESTIDLISTARGUMENT_S, "-masterq");
 
972
             DRETURN(answer);
 
973
         }
 
974
 
 
975
         DPRINTF(("\"-masterq %s\"\n", *sp));
 
976
         i_ret = cull_parse_destination_identifier_list(&id_list, *sp);
 
977
         if (i_ret) {
 
978
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
979
                     MSG_PARSE_WRONGDESTIDLISTFORMATXSPECTOXOPTION_SS, *sp, "-masterq");
 
980
             DRETURN(answer);
 
981
         }
 
982
         ep_opt = sge_add_arg(pcmdline, masterq_OPT, lListT, *(sp - 1), *sp);
 
983
         lSetList(ep_opt, SPA_argval_lListT, id_list);
 
984
         lSetInt(ep_opt, SPA_argval_lIntT, 0);
 
985
 
 
986
         sp++;
 
987
         continue;
 
988
      }
 
989
 
 
990
/*-----------------------------------------------------------------------------*/
 
991
      /* "-M mail_list" */
 
992
 
 
993
      if (!strcmp("-M", *sp)) {
 
994
         lList *mail_list = NULL;
 
995
 
 
996
         /* next field is mail_list */
 
997
         sp++;
 
998
         if (!*sp) {
 
999
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1000
                       MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-M" );
 
1001
             DRETURN(answer);
 
1002
         }
 
1003
 
 
1004
         DPRINTF(("\"-M %s\"\n", *sp));
 
1005
 
 
1006
         i_ret = mailrec_parse(&mail_list, *sp);
 
1007
          if (i_ret) {
 
1008
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1009
                    MSG_PARSE_WRONGMAILLISTFORMATXSPECTOMOPTION_S, *sp);
 
1010
             DRETURN(answer);
 
1011
         }
 
1012
         ep_opt = sge_add_arg(pcmdline, M_OPT, lListT, *(sp - 1), *sp);
 
1013
         lSetList(ep_opt, SPA_argval_lListT, mail_list);
 
1014
 
 
1015
         sp++;
 
1016
         continue;
 
1017
      }
 
1018
 
 
1019
/*----------------------------------------------------------------------------*/
 
1020
      /* "-N name" */
 
1021
 
 
1022
      if (!strcmp("-N", *sp)) {
 
1023
 
 
1024
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1025
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1026
               MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
1027
         }
 
1028
 
 
1029
         /* next field is name */
 
1030
         sp++;
 
1031
         if (!*sp) {
 
1032
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1033
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-N" );
 
1034
             DRETURN(answer);
 
1035
         }
 
1036
         if (strchr(*sp, '/')) {
 
1037
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1038
                 MSG_PARSE_ARGUMENTTONOPTIONMUSTNOTCONTAINBSL );
 
1039
             DRETURN(answer);
 
1040
         }
 
1041
 
 
1042
         if (*sp == '\0') {
 
1043
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1044
                    MSG_PARSE_EMPTYSTRINGARGUMENTTONOPTIONINVALID );
 
1045
             DRETURN(answer);
 
1046
         }
 
1047
 
 
1048
         DPRINTF(("\"-N %s\"\n", *sp));
 
1049
         ep_opt = sge_add_arg(pcmdline, N_OPT, lStringT, *(sp - 1), *sp);
 
1050
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1051
 
 
1052
         sp++;
 
1053
         continue;
 
1054
      }
 
1055
 
 
1056
/*----------------------------------------------------------------------------*/
 
1057
      /* "-notify" */
 
1058
 
 
1059
      if (!strcmp("-notify", *sp)) {
 
1060
 
 
1061
         DPRINTF(("\"-notify\"\n"));
 
1062
 
 
1063
         ep_opt = sge_add_noarg(pcmdline, notify_OPT, *sp, NULL);
 
1064
 
 
1065
         sp++;
 
1066
         continue;
 
1067
      }
 
1068
 
 
1069
/*----------------------------------------------------------------------------*/
 
1070
     /*  -now y[es]|n[o] */
 
1071
 
 
1072
      if(!strcmp("-now", *sp)) {
 
1073
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1074
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1075
                     MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp);
 
1076
         }
 
1077
         /* next field is yes/no switch */
 
1078
         sp++;
 
1079
         if(!*sp) {
 
1080
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1081
                      MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-now" );
 
1082
            DRETURN(answer);
 
1083
         }
 
1084
         
 
1085
         DPRINTF(("\"-now %s\"\n", *sp));
 
1086
         
 
1087
         if (set_yn_option(pcmdline, now_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
1088
            DRETURN(answer);
 
1089
         }
 
1090
 
 
1091
         sp++;
 
1092
         continue;
 
1093
      }
 
1094
            
 
1095
/*----------------------------------------------------------------------------*/
 
1096
      /* "-o path_name" */
 
1097
 
 
1098
      if (!strcmp("-o", *sp)) {
 
1099
         lList *stdout_path_list = NULL;
 
1100
 
 
1101
         /* next field is path_name */
 
1102
         sp++;
 
1103
         if (!*sp) {
 
1104
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1105
                       MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-o" );
 
1106
             DRETURN(answer);
 
1107
         }
 
1108
 
 
1109
         DPRINTF(("\"-o %s\"\n", *sp));
 
1110
         i_ret = cull_parse_path_list(&stdout_path_list, *sp);
 
1111
         if (i_ret) {
 
1112
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1113
                    MSG_PARSE_WRONGSTDOUTPATHLISTFORMATXSPECTOOOPTION_S, *sp );
 
1114
             DRETURN(answer);
 
1115
         }
 
1116
         ep_opt = sge_add_arg(pcmdline, o_OPT, lListT, *(sp - 1), *sp);
 
1117
         lSetList(ep_opt, SPA_argval_lListT, stdout_path_list);
 
1118
   
 
1119
         if (i_opt != NULL) {
 
1120
            if (strcmp(i_opt, *sp) == 0) {
 
1121
               answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1122
               MSG_PARSE_SAMEPATHFORINPUTANDOUTPUT_SS, i_opt, *sp );
 
1123
               DRETURN(answer);
 
1124
            }
 
1125
         }
 
1126
 
 
1127
         sp++;
 
1128
         continue;
 
1129
      }
 
1130
 
 
1131
/*----------------------------------------------------------------------------*/
 
1132
      /* "-ot override tickets */
 
1133
 
 
1134
      if (!strcmp("-ot", *sp)) {
 
1135
         int otickets;
 
1136
         double otickets_d;
 
1137
 
 
1138
         sp++;
 
1139
         if (!*sp) {
 
1140
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1141
                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-ot");
 
1142
             DRETURN(answer);
 
1143
         }
 
1144
 
 
1145
         if (!parse_ulong_val(&otickets_d, NULL, TYPE_INT, *sp, NULL, 0)) {
 
1146
            answer_list_add(&answer, MSG_PARSE_INVALIDOTICKETSMUSTBEUINT,
 
1147
                             STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1148
            DRETURN(answer);
 
1149
         }
 
1150
 
 
1151
 
 
1152
         if (otickets_d < 0) {
 
1153
            answer_list_add(&answer, MSG_PARSE_INVALIDOTICKETSMUSTBEUINT,
 
1154
                             STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1155
            DRETURN(answer);
 
1156
         }
 
1157
 
 
1158
         otickets = otickets_d;
 
1159
         
 
1160
         ep_opt = sge_add_arg(pcmdline, ot_OPT, lIntT, *(sp - 1), *sp);
 
1161
         lSetUlong(ep_opt, SPA_argval_lUlongT, otickets);
 
1162
 
 
1163
         sp++;
 
1164
         continue;
 
1165
      }
 
1166
 
 
1167
/*----------------------------------------------------------------------------*/
 
1168
      /* "-p priority */
 
1169
 
 
1170
      if (!strcmp("-p", *sp)) {
 
1171
         int priority;
 
1172
 
 
1173
         sp++;
 
1174
         if (!*sp) {
 
1175
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1176
                       MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-p" );
 
1177
             DRETURN(answer);
 
1178
         }
 
1179
 
 
1180
         if (sge_parse_priority(&answer, &priority, *sp)) {
 
1181
            DRETURN(answer);
 
1182
         }
 
1183
 
 
1184
         ep_opt = sge_add_arg(pcmdline, p_OPT, lIntT, *(sp - 1), *sp);
 
1185
         lSetInt(ep_opt, SPA_argval_lIntT, priority);
 
1186
 
 
1187
         sp++;
 
1188
         continue;
 
1189
      }
 
1190
 
 
1191
/*----------------------------------------------------------------------------*/
 
1192
 
 
1193
      /* "-P name" */
 
1194
 
 
1195
      if (!strcmp("-P", *sp)) {
 
1196
 
 
1197
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1198
            sprintf(str, MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S,
 
1199
               *sp);
 
1200
            answer_list_add(&answer, str, STATUS_EEXIST, ANSWER_QUALITY_WARNING);
 
1201
         }
 
1202
 
 
1203
         /* next field is the projects name */
 
1204
         sp++;
 
1205
         if (!*sp) {
 
1206
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1207
                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-P");
 
1208
             DRETURN(answer);
 
1209
         }
 
1210
 
 
1211
         DPRINTF(("\"-P %s\"\n", *sp));
 
1212
         ep_opt = sge_add_arg(pcmdline, P_OPT, lStringT, *(sp - 1), *sp);
 
1213
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1214
 
 
1215
         sp++;
 
1216
         continue;
 
1217
      }
 
1218
 
 
1219
/*----------------------------------------------------------------------------*/
 
1220
      if (!strcmp("-pe", *sp)) {
 
1221
         lList *pe_range = NULL;
 
1222
         dstring d_arg = DSTRING_INIT;
 
1223
 
 
1224
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1225
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1226
                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp );
 
1227
         }
 
1228
DTRACE;
 
1229
         /* next field must be the pe_name ... */
 
1230
         sp++;
 
1231
         if (!*sp) {
 
1232
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1233
                    MSG_PARSE_PEOPTIONMUSTHAVEPENAMEARGUMENT );
 
1234
             sge_dstring_free(&d_arg);
 
1235
             DRETURN(answer);
 
1236
         }
 
1237
 
 
1238
         /* ... followed by a range */
 
1239
         sp++;
 
1240
         if (!*sp) {
 
1241
             answer_list_add(&answer, MSG_PARSE_PEOPTIONMUSTHAVERANGEAS2NDARGUMENT, 
 
1242
                             STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1243
             sge_dstring_free(&d_arg);
 
1244
             DRETURN(answer);
 
1245
         }
 
1246
 
 
1247
         range_list_parse_from_string(&pe_range, &answer, *sp, 
 
1248
                                      false, false, INF_ALLOWED);
 
1249
 
 
1250
         if (!pe_range) {
 
1251
            sge_dstring_free(&d_arg);
 
1252
            DRETURN(answer);
 
1253
         }
 
1254
         sge_dstring_append(&d_arg, *(sp-1));
 
1255
         sge_dstring_append(&d_arg, " ");
 
1256
         sge_dstring_append(&d_arg, *sp);
 
1257
         ep_opt = sge_add_arg(pcmdline, pe_OPT, lStringT, *(sp - 2), sge_dstring_get_string(&d_arg));
 
1258
         lSetString(ep_opt, SPA_argval_lStringT, *(sp - 1));
 
1259
         lSetList(ep_opt, SPA_argval_lListT, pe_range);
 
1260
 
 
1261
         sp++;
 
1262
 
 
1263
         sge_dstring_free(&d_arg);
 
1264
 
 
1265
         continue;
 
1266
      }
 
1267
/*-----------------------------------------------------------------------------*/
 
1268
      /* "-q destination_identifier_list" */
 
1269
 
 
1270
      if (!strcmp("-q", *sp)) {
 
1271
         lList *id_list = NULL;
 
1272
 
 
1273
         /* next field is destination_identifier */
 
1274
         sp++;
 
1275
         if (!*sp) {
 
1276
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1277
                     MSG_PARSE_XOPTIONMUSTHAVEDESTIDLISTARGUMENT_S, "-q");
 
1278
             DRETURN(answer);
 
1279
         }
 
1280
 
 
1281
         DPRINTF(("\"-q %s\"\n", *sp));
 
1282
         i_ret = cull_parse_destination_identifier_list(&id_list, *sp);
 
1283
         if (i_ret) {
 
1284
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1285
                    MSG_PARSE_WRONGDESTIDLISTFORMATXSPECTOXOPTION_SS, *sp, "-q");
 
1286
             DRETURN(answer);
 
1287
         }
 
1288
         ep_opt = sge_add_arg(pcmdline, q_OPT, lListT, *(sp - 1), *sp);
 
1289
         lSetList(ep_opt, SPA_argval_lListT, id_list);
 
1290
         lSetInt(ep_opt, SPA_argval_lIntT, hard_soft_flag);
 
1291
 
 
1292
         sp++;
 
1293
         continue;
 
1294
      }
 
1295
 
 
1296
/*-----------------------------------------------------------------------------*/
 
1297
      /* "-r y|n" */
 
1298
 
 
1299
      if (!strcmp("-r", *sp)) {
 
1300
 
 
1301
 
 
1302
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1303
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1304
                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp );
 
1305
         }
 
1306
 
 
1307
         /* next field is "y|n" */
 
1308
         sp++;
 
1309
         if (!*sp) {
 
1310
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1311
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-r" );
 
1312
            DRETURN(answer);
 
1313
         }
 
1314
 
 
1315
         DPRINTF(("\"-r %s\"\n", *sp));
 
1316
 
 
1317
         if ((strcasecmp("y", *sp) == 0) || (strcasecmp("yes", *sp) == 0)) {
 
1318
            ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1319
            lSetInt(ep_opt, SPA_argval_lIntT, 1);
 
1320
         } else if ((strcasecmp ("n", *sp) == 0) || (strcasecmp ("no", *sp) == 0)) {
 
1321
            ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1322
            lSetInt(ep_opt, SPA_argval_lIntT, 2);
 
1323
         } else {
 
1324
            answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1325
                    MSG_PARSE_INVALIDOPTIONARGUMENTRX_S, *sp );
 
1326
            DRETURN(answer);
 
1327
         }
 
1328
 
 
1329
         sp++;
 
1330
         continue;
 
1331
 
 
1332
      }
 
1333
 
 
1334
/*-----------------------------------------------------------------------------*/
 
1335
      /* "-R y|n" */
 
1336
 
 
1337
      if (!strcmp("-R", *sp)) {
 
1338
 
 
1339
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1340
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1341
                 MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp );
 
1342
         }
 
1343
 
 
1344
         /* next field is "y|n" */
 
1345
         sp++;
 
1346
         if (!*sp) {
 
1347
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1348
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-R" );
 
1349
             DRETURN(answer);
 
1350
         }
 
1351
 
 
1352
         DPRINTF(("\"-R %s\"\n", *sp));
 
1353
 
 
1354
         if (set_yn_option(pcmdline, R_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
1355
            DRETURN(answer);
 
1356
         }
 
1357
 
 
1358
         sp++;
 
1359
         continue;
 
1360
      }
 
1361
 
 
1362
/*-----------------------------------------------------------------------------*/
 
1363
      /* "-sc variable_list" */
 
1364
      /* set context */
 
1365
 
 
1366
      if (!strcmp("-sc", *sp)) {
 
1367
         lList *variable_list = NULL;
 
1368
         lListElem* lep = NULL;
 
1369
 
 
1370
         /* next field is context_list  [ == variable_list ] */
 
1371
         sp++;
 
1372
         if (!*sp) {
 
1373
             answer_list_add(&answer, MSG_PARSE_SCOPTIONMUSTHAVECONTEXTLISTARGUMENT, 
 
1374
                     STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1375
             DRETURN(answer);
 
1376
         }
 
1377
 
 
1378
         DPRINTF(("\"-sc %s\"\n", *sp));
 
1379
         i_ret = var_list_parse_from_string(&variable_list, *sp, 0);
 
1380
         if (i_ret) {
 
1381
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1382
                          MSG_PARSE_WRONGCONTEXTLISTFORMATSCX_S, *sp );
 
1383
             DRETURN(answer);
 
1384
         }
 
1385
         ep_opt = sge_add_arg(pcmdline, sc_OPT, lListT, *(sp - 1), *sp);
 
1386
         lep = lCreateElem(VA_Type);
 
1387
         lSetString(lep, VA_variable, "=");
 
1388
         lInsertElem(variable_list, NULL, lep);
 
1389
         lSetList(ep_opt, SPA_argval_lListT, variable_list);
 
1390
 
 
1391
         sp++;
 
1392
         continue;
 
1393
      }
 
1394
 
 
1395
/*-----------------------------------------------------------------------------*/
 
1396
      /* "-soft" */
 
1397
 
 
1398
      if (!strcmp("-soft", *sp)) {
 
1399
 
 
1400
         DPRINTF(("\"%s\"\n", *sp));
 
1401
         hard_soft_flag = 2;
 
1402
         ep_opt = sge_add_noarg(pcmdline, soft_OPT, *sp, NULL);
 
1403
 
 
1404
         sp++;
 
1405
         continue;
 
1406
      }
 
1407
 
 
1408
/*----------------------------------------------------------------------------*/
 
1409
      /* "-shell y|n" */
 
1410
 
 
1411
      if (!is_qalter && !strcmp("-shell", *sp)) {
 
1412
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1413
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1414
                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp );
 
1415
         }
 
1416
 
 
1417
         /* next field is "y|n" */
 
1418
         sp++;
 
1419
         if (!*sp) {
 
1420
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1421
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-shell");
 
1422
             DRETURN(answer);
 
1423
         }
 
1424
 
 
1425
         DPRINTF(("\"-shell %s\"\n", *sp));
 
1426
 
 
1427
         if (set_yn_option (pcmdline, shell_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
1428
            DRETURN(answer);
 
1429
         }
 
1430
 
 
1431
         sp++;
 
1432
         continue;
 
1433
      }
 
1434
 
 
1435
 
 
1436
/*----------------------------------------------------------------------------*/
 
1437
     /*  -sync y[es]|n[o] */
 
1438
 
 
1439
      if(!strcmp("-sync", *sp)) {
 
1440
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1441
            answer_list_add_sprintf(&answer, STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1442
                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S, *sp );
 
1443
         }
 
1444
         /* next field is yes/no switch */
 
1445
         sp++;
 
1446
         if(!*sp) {
 
1447
            answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1448
                    MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-sync" );
 
1449
            DRETURN(answer);
 
1450
         }
 
1451
         
 
1452
         DPRINTF(("\"-sync %s\"\n", *sp));
 
1453
         
 
1454
         if (set_yn_option (pcmdline, sync_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
1455
            DRETURN(answer);
 
1456
         }
 
1457
 
 
1458
         sp++;
 
1459
         continue;
 
1460
      }
 
1461
            
 
1462
/*----------------------------------------------------------------------------*/
 
1463
      /* "-S path_name" */
 
1464
 
 
1465
      if (!strcmp("-S", *sp)) {
 
1466
         lList *shell_list = NULL;
 
1467
 
 
1468
         /* next field is path_name */
 
1469
         sp++;
 
1470
         if (!*sp) {
 
1471
             answer_list_add(&answer, MSG_PARSE_SOPTIONMUSTHAVEPATHNAMEARGUMENT, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1472
             DRETURN(answer);
 
1473
         }
 
1474
 
 
1475
         DPRINTF(("\"-S %s\"\n", *sp));
 
1476
 
 
1477
         i_ret = cull_parse_path_list(&shell_list, *sp);
 
1478
         if (i_ret) {
 
1479
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1480
                       MSG_PARSE_WRONGSHELLLISTFORMATXSPECTOSOPTION_S, *sp );
 
1481
             DRETURN(answer);
 
1482
         }
 
1483
         ep_opt = sge_add_arg(pcmdline, S_OPT, lListT, *(sp - 1), *sp);
 
1484
         lSetList(ep_opt, SPA_argval_lListT, shell_list);
 
1485
 
 
1486
         sp++;
 
1487
         continue;
 
1488
      }
 
1489
 
 
1490
/*----------------------------------------------------------------------------*/
 
1491
      /* -t <TaskIdRange>
 
1492
       */
 
1493
 
 
1494
      if (!strcmp("-t", *sp)) {
 
1495
         lList *task_id_range_list = NULL;
 
1496
 
 
1497
         /* next field is path_name */
 
1498
         sp++;
 
1499
         if (!*sp) {
 
1500
             answer_list_add(&answer, MSG_PARSE_TOPTIONMUSTHAVEALISTOFTASKIDRANGES, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1501
             DRETURN(answer);
 
1502
         }
 
1503
 
 
1504
         DPRINTF(("\"-t %s\"\n", *sp));
 
1505
 
 
1506
         range_list_parse_from_string(&task_id_range_list, &answer, *sp,
 
1507
                                      false, true, INF_NOT_ALLOWED);
 
1508
         if (!task_id_range_list) {
 
1509
            DRETURN(answer);
 
1510
         }
 
1511
 
 
1512
         range_list_sort_uniq_compress(task_id_range_list, &answer, false);
 
1513
         if (lGetNumberOfElem(task_id_range_list) > 1) {
 
1514
            answer_list_add(&answer, MSG_QCONF_ONLYONERANGE, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
 
1515
            lFreeList(&task_id_range_list);
 
1516
            DRETURN(answer);
 
1517
         }
 
1518
 
 
1519
 
 
1520
         ep_opt = sge_add_arg(pcmdline, t_OPT, lListT, *(sp - 1), *sp);
 
1521
         lSetList(ep_opt, SPA_argval_lListT, task_id_range_list);
 
1522
 
 
1523
         sp++;
 
1524
         continue;
 
1525
      }
 
1526
 
 
1527
/*-----------------------------------------------------------------------------*/
 
1528
      /* "-terse" */
 
1529
 
 
1530
      if(!strcmp("-terse", *sp)) {
 
1531
         ep_opt = sge_add_noarg(pcmdline, terse_OPT, *sp, NULL);
 
1532
         sp++;
 
1533
         continue;
 
1534
      }
 
1535
 
 
1536
/*-----------------------------------------------------------------------------*/
 
1537
      /* "-u" */
 
1538
      if (!strcmp("-u", *sp)) {
 
1539
         lList *user_list = NULL;
 
1540
 
 
1541
         /* next field is user_list */
 
1542
         sp++;
 
1543
         if (!*sp) {
 
1544
            answer_list_add(&answer, MSG_PARSE_UOPTMUSTHAVEALISTUSERNAMES,
 
1545
                  STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1546
            DRETURN(answer);
 
1547
         }
 
1548
 
 
1549
         DPRINTF(("\"-u %s\"\n", *sp));
 
1550
 
 
1551
         if (prog_number == QRSUB) {
 
1552
            int rule[] = {ARA_name, 0};
 
1553
            char **dest = NULL;
 
1554
            char *tmp;
 
1555
 
 
1556
            tmp = sge_strdup(NULL, *sp);
 
1557
            dest = string_list(tmp, ",", NULL);
 
1558
            cull_parse_string_list(dest, "user_list", ARA_Type, rule, &user_list);
 
1559
            FREE(tmp);
 
1560
            FREE(dest);
 
1561
         } else {
 
1562
            str_list_parse_from_string(&user_list, *sp, ",");
 
1563
         }
 
1564
 
 
1565
         ep_opt = sge_add_arg(pcmdline, u_OPT, lListT, *(sp - 1), *sp);
 
1566
         lSetList(ep_opt, SPA_argval_lListT, user_list);  
 
1567
         sp++;
 
1568
 
 
1569
         continue;
 
1570
      }
 
1571
 
 
1572
/*-----------------------------------------------------------------------------*/
 
1573
      /* "-uall " */
 
1574
      if (!strcmp("-uall", *sp)) {
 
1575
         ep_opt = sge_add_noarg(pcmdline, u_OPT, *sp, NULL);
 
1576
 
 
1577
         DPRINTF(("\"-uall \"\n"));
 
1578
         sp++;
 
1579
  
 
1580
         continue;
 
1581
      }           
 
1582
 
 
1583
/*-----------------------------------------------------------------------------*/
 
1584
      /* "-v variable_list" */
 
1585
 
 
1586
      if (!strcmp("-v", *sp)) {
 
1587
         lList *variable_list = NULL;
 
1588
 
 
1589
         /* next field is variable_list */
 
1590
         sp++;
 
1591
         if (!*sp) {
 
1592
             answer_list_add(&answer, MSG_PARSE_VOPTMUSTHAVEVARIABLELISTARGUMENT, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1593
             DRETURN(answer);
 
1594
         }
 
1595
 
 
1596
         DPRINTF(("\"-v %s\"\n", *sp));
 
1597
 
 
1598
         i_ret = var_list_parse_from_string(&variable_list, *sp, 1);
 
1599
         if (i_ret) {
 
1600
             answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1601
                  MSG_PARSE_WRONGVARIABLELISTFORMATVORENVIRONMENTVARIABLENOTSET_S, *sp );
 
1602
             DRETURN(answer);
 
1603
         }
 
1604
         ep_opt = sge_add_arg(pcmdline, v_OPT, lListT, *(sp - 1), *sp);
 
1605
         lSetList(ep_opt, SPA_argval_lListT, variable_list);
 
1606
 
 
1607
         sp++;
 
1608
         continue;
 
1609
      }
 
1610
 
 
1611
/*-----------------------------------------------------------------------------*/
 
1612
      /* "-verify" */
 
1613
 
 
1614
      if (!strcmp("-verify", *sp)) {
 
1615
 
 
1616
         DPRINTF(("\"%s\"\n", *sp));
 
1617
         ep_opt = sge_add_noarg(pcmdline, verify_OPT, *sp, NULL);
 
1618
 
 
1619
         sp++;
 
1620
         continue;
 
1621
      }
 
1622
 
 
1623
/*-----------------------------------------------------------------------------*/
 
1624
      /* "-V" */
 
1625
 
 
1626
      if (!strcmp("-V", *sp)) {
 
1627
         lList *env_list = NULL;
 
1628
 
 
1629
         DPRINTF(("\"%s\"\n", *sp));
 
1630
         i_ret = var_list_parse_from_environment(&env_list, envp);
 
1631
         if (i_ret) {
 
1632
             answer_list_add(&answer, MSG_PARSE_COULDNOTPARSEENVIRIONMENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
 
1633
             DRETURN(answer);
 
1634
         }
 
1635
         ep_opt = sge_add_arg(pcmdline, V_OPT, lListT, *sp, "");
 
1636
         lSetList(ep_opt, SPA_argval_lListT, env_list);
 
1637
 
 
1638
         sp++;
 
1639
         continue;
 
1640
      }
 
1641
 
 
1642
/*-----------------------------------------------------------------------------*/
 
1643
      /* "-w e|w|n|v" */
 
1644
 
 
1645
      if (!strcmp("-w", *sp)) {
 
1646
 
 
1647
 
 
1648
         if (lGetElemStr(*pcmdline, SPA_switch, *sp)) {
 
1649
            answer_list_add_sprintf(&answer,STATUS_EEXIST, ANSWER_QUALITY_WARNING,
 
1650
                                    MSG_PARSE_XOPTIONALREADYSETOVERWRITINGSETING_S,
 
1651
                                    *sp);
 
1652
         }
 
1653
 
 
1654
         /* next field is "e|w|n|v" */
 
1655
         sp++;
 
1656
         if (!*sp) {
 
1657
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1658
                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-w");
 
1659
             DRETURN(answer);
 
1660
         }
 
1661
 
 
1662
         DPRINTF(("\"-w %s\"\n", *sp));
 
1663
 
 
1664
         if (!strcmp("e", *sp)) {
 
1665
            ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1666
            if (prog_number == QRSUB) {
 
1667
               lSetInt(ep_opt, SPA_argval_lIntT, AR_ERROR_VERIFY);
 
1668
            } else {
 
1669
               lSetInt(ep_opt, SPA_argval_lIntT, ERROR_VERIFY);
 
1670
            }
 
1671
         }
 
1672
         else if (!strcmp("w", *sp)) {
 
1673
            if (prog_number == QRSUB) {
 
1674
               answer_list_add_sprintf(&answer,STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1675
                     MSG_PARSE_INVALIDOPTIONARGUMENTWX_S, *sp);
 
1676
               DRETURN(answer);
 
1677
            } else {
 
1678
               ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1679
            }
 
1680
            lSetInt(ep_opt, SPA_argval_lIntT, WARNING_VERIFY);
 
1681
         }
 
1682
         else if (!strcmp("n", *sp)) {
 
1683
            ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1684
            if (prog_number == QRSUB) {
 
1685
               answer_list_add_sprintf(&answer,STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1686
                     MSG_PARSE_INVALIDOPTIONARGUMENTWX_S, *sp);
 
1687
               DRETURN(answer);
 
1688
            } else {
 
1689
               lSetInt(ep_opt, SPA_argval_lIntT, SKIP_VERIFY);
 
1690
            }
 
1691
         }
 
1692
         else if (!strcmp("v", *sp)) {
 
1693
            ep_opt = sge_add_arg(pcmdline, r_OPT, lIntT, *(sp - 1), *sp);
 
1694
            if (prog_number == QRSUB) {
 
1695
               lSetInt(ep_opt, SPA_argval_lIntT, AR_JUST_VERIFY);
 
1696
            } else {
 
1697
               lSetInt(ep_opt, SPA_argval_lIntT, JUST_VERIFY);
 
1698
            }
 
1699
         } else {
 
1700
             answer_list_add_sprintf(&answer,STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1701
                     MSG_PARSE_INVALIDOPTIONARGUMENTWX_S, *sp);
 
1702
             DRETURN(answer);
 
1703
         }
 
1704
 
 
1705
         sp++;
 
1706
         continue;
 
1707
 
 
1708
      }
 
1709
/*-----------------------------------------------------------------------------*/
 
1710
      /* "-wd" */
 
1711
 
 
1712
      if (!strcmp("-wd", *sp)) {
 
1713
 
 
1714
         sp++;
 
1715
         if (!*sp) {
 
1716
            answer_list_add_sprintf(&answer,STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1717
                  MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, *(sp - 1));
 
1718
            DRETURN(answer);
 
1719
         }
 
1720
 
 
1721
         ep_opt = sge_add_arg(pcmdline, wd_OPT, lStringT, "-wd", *sp);
 
1722
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1723
 
 
1724
         sp++;
 
1725
         continue;
 
1726
      }
 
1727
 
 
1728
/*-----------------------------------------------------------------------------*/
 
1729
      /* "-@" */
 
1730
      /* reentrancy is built upon here */
 
1731
 
 
1732
      if (!strcmp("-@", *sp)) {
 
1733
         lList *alp;
 
1734
         lListElem *aep;
 
1735
         int do_exit = 0;
 
1736
 
 
1737
         sp++;
 
1738
         if (!*sp) {
 
1739
             sprintf(str, MSG_PARSE_ATSIGNOPTIONMUSTHAVEFILEARGUMENT);
 
1740
             answer_list_add(&answer, str, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1741
             DEXIT;
 
1742
             return answer;
 
1743
         }
 
1744
 
 
1745
         DPRINTF(("\"-@ %s\"\n", *sp));
 
1746
 
 
1747
         alp = parse_script_file(prog_number, *sp, "", pcmdline, envp, FLG_USE_NO_PSEUDOS); /* MT-NOTE: !!!! */
 
1748
         for_each(aep, alp) {
 
1749
            u_long32 quality;
 
1750
 
 
1751
            quality = lGetUlong(aep, AN_quality);
 
1752
            if (quality == ANSWER_QUALITY_ERROR) {
 
1753
               do_exit = 1;
 
1754
            }
 
1755
            lAppendElem(answer, lCopyElem(aep));
 
1756
         }
 
1757
 
 
1758
         lFreeList(&alp);
 
1759
         if (do_exit) {
 
1760
            DEXIT;
 
1761
            return answer;
 
1762
         }
 
1763
 
 
1764
         sp++;
 
1765
         continue;
 
1766
      }
 
1767
 
 
1768
/*-----------------------------------------------------------------------------*/
 
1769
      /* "-verbose" - accept, but do nothing, must be handled by caller */
 
1770
 
 
1771
      if(!strcmp("-verbose", *sp)) {
 
1772
         ep_opt = sge_add_noarg(pcmdline, verbose_OPT, *sp, NULL);
 
1773
         sp++;
 
1774
         continue;
 
1775
      }
 
1776
/*-----------------------------------------------------------------------------*/
 
1777
      /* "-inherit" - accept, but do nothing, must be handled by caller */
 
1778
 
 
1779
      if(!strcmp("-inherit", *sp)) {
 
1780
         ep_opt = sge_add_noarg(pcmdline, inherit_OPT, *sp, NULL);
 
1781
         sp++;
 
1782
         continue;
 
1783
      }
 
1784
/*-----------------------------------------------------------------------------*/
 
1785
      /* "-pty" - accept, but do nothing, must be handled by caller */
 
1786
 
 
1787
      if(!strcmp("-pty", *sp)) {
 
1788
         /* next field is "y|n" */
 
1789
         sp++;
 
1790
         if (!*sp) {
 
1791
             answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1792
                                     MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S,"-pty");
 
1793
             DRETURN(answer);
 
1794
         }
 
1795
 
 
1796
         DPRINTF(("\"-pty %s\"\n", *sp));
 
1797
 
 
1798
         if (set_yn_option(pcmdline, pty_OPT, *(sp - 1), *sp, &answer) != STATUS_OK) {
 
1799
            DRETURN(answer);
 
1800
         }
 
1801
 
 
1802
         sp++;
 
1803
         continue;
 
1804
      }
 
1805
/*-----------------------------------------------------------------------------*/
 
1806
      /* "-nostdin" - accept, but do nothing, must be handled by caller */
 
1807
 
 
1808
      if(!strcmp("-nostdin", *sp)) {
 
1809
         ep_opt = sge_add_noarg(pcmdline, nostdin_OPT, *sp, NULL);
 
1810
         sp++;
 
1811
         continue;
 
1812
      }
 
1813
/*-----------------------------------------------------------------------------*/
 
1814
      /* "-noshell" - accept, but do nothing, must be handled by caller */
 
1815
 
 
1816
      if(!strcmp("-noshell", *sp)) {
 
1817
         ep_opt = sge_add_noarg(pcmdline, noshell_OPT, *sp, NULL);
 
1818
         sp++;
 
1819
         continue;
 
1820
      }
 
1821
/*-----------------------------------------------------------------------------*/
 
1822
      /* "-huh?" */
 
1823
 
 
1824
      if (!strncmp("-", *sp, 1) && strcmp("--", *sp)) {
 
1825
         answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1826
              MSG_PARSE_INVALIDOPTIONARGUMENTX_S, *sp );
 
1827
         DRETURN(answer);
 
1828
      }
 
1829
 
 
1830
/*-----------------------------------------------------------------------------*/
 
1831
      /* - for read script from stdin */
 
1832
 
 
1833
      if (!strcmp("-", *sp)) {
 
1834
         DPRINTF(("\"%s\"\n", *sp));
 
1835
 
 
1836
         if ((flags & FLG_USE_PSEUDOS)) {
 
1837
            if (!is_qalter) {
 
1838
               ep_opt = sge_add_arg(pcmdline, 0, lStringT, STR_PSEUDO_SCRIPT, NULL);
 
1839
               lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1840
               for (sp++; *sp; sp++) {
 
1841
                  ep_opt = sge_add_arg(pcmdline, 0, lStringT, STR_PSEUDO_JOBARG, NULL);
 
1842
                  lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1843
               }
 
1844
            } else {
 
1845
               answer_list_add_sprintf(&answer, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
1846
                    MSG_PARSE_INVALIDOPTIONARGUMENTX_S, *sp);
 
1847
               DRETURN(answer);
 
1848
            }
 
1849
            continue;
 
1850
         }
 
1851
         else {
 
1852
            ep_opt = sge_add_noarg(pcmdline, 0, *sp, NULL);
 
1853
         }
 
1854
 
 
1855
         sp++;
 
1856
         continue;
 
1857
      }
 
1858
 
 
1859
/*-----------------------------------------------------------------------------*/
 
1860
      /* -- separator for qalter between job ids and job args */
 
1861
 
 
1862
      if (!strcmp("--", *sp)) {
 
1863
         DPRINTF(("\"%s\"\n", *sp));
 
1864
 
 
1865
         if ((flags & FLG_USE_PSEUDOS)) {
 
1866
            sp++;
 
1867
            if (!*sp) {
 
1868
               answer_list_add(&answer, MSG_PARSE_OPTIONMUSTBEFOLLOWEDBYJOBARGUMENTS, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR);
 
1869
               DRETURN(answer);
 
1870
            }
 
1871
            for (; *sp; sp++) {
 
1872
               ep_opt = sge_add_arg(pcmdline, 0, lStringT, STR_PSEUDO_JOBARG, NULL);
 
1873
               lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1874
            }
 
1875
            continue;
 
1876
         }
 
1877
         else {
 
1878
            ep_opt = sge_add_noarg(pcmdline, 0, *sp, NULL);
 
1879
         }
 
1880
 
 
1881
         sp++;
 
1882
         continue;
 
1883
      }
 
1884
 
 
1885
/*-----------------------------------------------------------------------------*/
 
1886
 
 
1887
      DPRINTF(("===%s===\n", *sp));
 
1888
 
 
1889
      /*
 
1890
      ** with qsub and qsh this can only
 
1891
      ** be a script file, remember this
 
1892
      ** in case of qalter we need jobids
 
1893
      */
 
1894
      if ((flags & FLG_USE_PSEUDOS)) {
 
1895
         if (!is_qalter) {
 
1896
            ep_opt = sge_add_arg(pcmdline, 0, lStringT, STR_PSEUDO_SCRIPT, NULL);
 
1897
            lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1898
            for (sp++; *sp; sp++) {
 
1899
               ep_opt = sge_add_arg(pcmdline, 0, lStringT, STR_PSEUDO_JOBARG, NULL);
 
1900
               lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1901
            }
 
1902
         } else {
 
1903
            lList *jid_list = NULL;
 
1904
 
 
1905
            if (!strcmp(*sp, "--")) {
 
1906
               ep_opt = sge_add_noarg(pcmdline, 0, *sp, NULL);
 
1907
               break;
 
1908
            }
 
1909
            i_ret = cull_parse_jid_hold_list(&jid_list, *sp);
 
1910
 
 
1911
            if (i_ret) {
 
1912
               answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR,
 
1913
                    MSG_PARSE_WRONGJOBIDLISTFORMATXSPECIFIED_S, *sp );
 
1914
               DRETURN(answer);
 
1915
            }
 
1916
            ep_opt = sge_add_arg(pcmdline, 0, lListT, STR_PSEUDO_JOBID, *sp);
 
1917
            lSetList(ep_opt, SPA_argval_lListT, jid_list);
 
1918
            sp++;
 
1919
         }
 
1920
         continue;
 
1921
      } else {
 
1922
         ep_opt = sge_add_arg(pcmdline, 0, lStringT, "", NULL);
 
1923
         lSetString(ep_opt, SPA_argval_lStringT, *sp);
 
1924
      }
 
1925
 
 
1926
      sp++;
 
1927
   }
 
1928
 
 
1929
   if (!is_hold_option) {
 
1930
      if (prog_number == QHOLD) { 
 
1931
         ep_opt = sge_add_arg(pcmdline, h_OPT, lIntT, "-h", "u");
 
1932
         lSetInt(ep_opt, SPA_argval_lIntT, MINUS_H_TGT_USER);
 
1933
 
 
1934
      } else if (prog_number == QRLS) {
 
1935
         ep_opt = sge_add_arg(pcmdline, h_OPT, lIntT, "-h", "u");
 
1936
         lSetInt(ep_opt, SPA_argval_lIntT, MINUS_H_CMD_SUB | MINUS_H_TGT_USER);
 
1937
      }
 
1938
   }
 
1939
 
 
1940
   DEXIT;
 
1941
   return answer;
 
1942
}
 
1943
 
 
1944
 
 
1945
/***********************************************************************/
 
1946
/* "-h [hold_list]" */
 
1947
/* MT-NOTE: sge_parse_hold_list() is MT safe */
 
1948
static int sge_parse_hold_list(
 
1949
char *hold_str,
 
1950
u_long32 prog_number
 
1951
) {
 
1952
   int i, j;
 
1953
   int target = 0;
 
1954
   int op_code = 0;
 
1955
 
 
1956
   DENTER(TOP_LAYER, "sge_parse_hold_list");
 
1957
 
 
1958
   i = strlen(hold_str);
 
1959
 
 
1960
   for (j = 0; j < i; j++) {
 
1961
      switch (hold_str[j]) {
 
1962
      case 'n':
 
1963
         if ((prog_number == QHOLD)  || 
 
1964
             (prog_number == QRLS) || 
 
1965
             (op_code && op_code != MINUS_H_CMD_SUB)) {
 
1966
            target = -1;
 
1967
            break;
 
1968
         }
 
1969
         op_code = MINUS_H_CMD_SUB;
 
1970
         target = MINUS_H_TGT_USER|MINUS_H_TGT_OPERATOR|MINUS_H_TGT_SYSTEM;
 
1971
         break;
 
1972
      case 's':
 
1973
         if (prog_number == QRLS) {
 
1974
            if (op_code && op_code != MINUS_H_CMD_SUB) {
 
1975
               target = -1;
 
1976
               break;
 
1977
            }
 
1978
            op_code = MINUS_H_CMD_SUB;
 
1979
            target = target|MINUS_H_TGT_SYSTEM;         
 
1980
         }
 
1981
         else {
 
1982
            if (op_code && op_code != MINUS_H_CMD_ADD) {
 
1983
               target = -1;
 
1984
               break;
 
1985
            }
 
1986
            op_code = MINUS_H_CMD_ADD;
 
1987
            target = target|MINUS_H_TGT_SYSTEM;
 
1988
         }   
 
1989
         break;
 
1990
      case 'o':
 
1991
         if (prog_number == QRLS) {
 
1992
            if (op_code && op_code != MINUS_H_CMD_SUB) {
 
1993
               target = -1;
 
1994
               break;
 
1995
            }
 
1996
            op_code = MINUS_H_CMD_SUB;
 
1997
            target = target|MINUS_H_TGT_OPERATOR;         
 
1998
         }
 
1999
         else {
 
2000
            if (op_code && op_code != MINUS_H_CMD_ADD) {
 
2001
               target = -1;
 
2002
               break;
 
2003
            }
 
2004
            op_code = MINUS_H_CMD_ADD;
 
2005
            target = target|MINUS_H_TGT_OPERATOR;
 
2006
         }
 
2007
         break;
 
2008
         
 
2009
      case 'u':
 
2010
         if (prog_number == QRLS) {
 
2011
            if (op_code && op_code != MINUS_H_CMD_SUB) {
 
2012
               target = -1;
 
2013
               break;
 
2014
            }
 
2015
            op_code = MINUS_H_CMD_SUB;
 
2016
            target = target|MINUS_H_TGT_USER;
 
2017
         }
 
2018
         else {
 
2019
            if (op_code && op_code != MINUS_H_CMD_ADD) {
 
2020
               target = -1;
 
2021
               break;
 
2022
            }
 
2023
            op_code = MINUS_H_CMD_ADD;
 
2024
            target = target|MINUS_H_TGT_USER;
 
2025
         }
 
2026
         break;
 
2027
      case 'S':
 
2028
         if ((prog_number == QHOLD)  || 
 
2029
             (prog_number == QRLS) || 
 
2030
             (op_code && op_code != MINUS_H_CMD_SUB)) {
 
2031
            target = -1;
 
2032
            break;
 
2033
         }
 
2034
         op_code = MINUS_H_CMD_SUB;
 
2035
         target = target|MINUS_H_TGT_SYSTEM;
 
2036
         break;
 
2037
      case 'U':
 
2038
         if ((prog_number == QHOLD)  || 
 
2039
             (prog_number == QRLS) || 
 
2040
             (op_code && op_code != MINUS_H_CMD_SUB)) {
 
2041
            target = -1;
 
2042
            break;
 
2043
         }
 
2044
         op_code = MINUS_H_CMD_SUB;
 
2045
         target = target|MINUS_H_TGT_USER;
 
2046
         break;
 
2047
      case 'O':
 
2048
         if ((prog_number == QHOLD)  || 
 
2049
             (prog_number == QRLS) || 
 
2050
             (op_code && op_code != MINUS_H_CMD_SUB)) {
 
2051
            target = -1;
 
2052
            break;
 
2053
         }
 
2054
         op_code = MINUS_H_CMD_SUB;
 
2055
         target = target|MINUS_H_TGT_OPERATOR;
 
2056
         break;
 
2057
      default:
 
2058
         target = -1;
 
2059
      }
 
2060
 
 
2061
      if (target == -1)
 
2062
         break;
 
2063
   }
 
2064
 
 
2065
   if (target != -1)
 
2066
      target |= op_code;
 
2067
 
 
2068
   DEXIT;
 
2069
   return target;
 
2070
}
 
2071
 
 
2072
/***********************************************************************/
 
2073
/* MT-NOTE: sge_parse_mail_options() is MT safe */
 
2074
static int sge_parse_mail_options(lList **alpp, char *mail_str, u_long32 prog_number) 
 
2075
{
 
2076
   int i, j;
 
2077
   int mail_opt = 0;
 
2078
 
 
2079
   DENTER(TOP_LAYER, "sge_parse_mail_options");
 
2080
 
 
2081
   i = strlen(mail_str);
 
2082
 
 
2083
   for (j = 0; j < i; j++) {
 
2084
      if ((char) mail_str[j] == 'a') {
 
2085
         mail_opt = mail_opt | MAIL_AT_ABORT;
 
2086
      } else if ((char) mail_str[j] == 'b') {
 
2087
         mail_opt = mail_opt | MAIL_AT_BEGINNING;
 
2088
      } else if ((char) mail_str[j] == 'e') {
 
2089
         mail_opt = mail_opt | MAIL_AT_EXIT;
 
2090
      } else if ((char) mail_str[j] == 'n') {
 
2091
         mail_opt = mail_opt | NO_MAIL;
 
2092
      } else if ((char) mail_str[j] == 's') {
 
2093
         if (prog_number == QRSUB) {
 
2094
            answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR,
 
2095
                   MSG_PARSE_XOPTIONMUSTHAVEARGUMENT_S, "-m");
 
2096
            DRETURN(0);
 
2097
         }
 
2098
         mail_opt = mail_opt | MAIL_AT_SUSPENSION;
 
2099
      } else {
 
2100
         DRETURN(0);
 
2101
      }
 
2102
   }
 
2103
 
 
2104
   DRETURN(mail_opt);
 
2105
 
 
2106
}
 
2107
 
 
2108
/***************************************************************************/
 
2109
static int sge_parse_checkpoint_interval(
 
2110
char *time_str 
 
2111
) {
 
2112
   u_long32 seconds;
 
2113
 
 
2114
   DENTER(TOP_LAYER, "sge_parse_checkpoint_interval");
 
2115
 
 
2116
   DPRINTF(("--------time_string: %s\n", time_str));
 
2117
   if (!parse_ulong_val(NULL, &seconds, TYPE_TIM, time_str, NULL, 0))
 
2118
      seconds = 0;
 
2119
 
 
2120
     DPRINTF(("-------- seconds: %d\n", (int) seconds));
 
2121
   DEXIT;
 
2122
   return seconds;
 
2123
}
 
2124
 
 
2125
/***************************************************************************/
 
2126
 
 
2127
 
 
2128
/****** parse_qsub/cull_parse_path_list() **************************************
 
2129
*  NAME
 
2130
*     cull_parse_path_list() -- ??? 
 
2131
*
 
2132
*  SYNOPSIS
 
2133
*     int cull_parse_path_list(lList **lpp, char *path_str) 
 
2134
*
 
2135
*  FUNCTION
 
2136
*     ??? 
 
2137
*
 
2138
*  INPUTS
 
2139
*     lList **lpp    - ??? 
 
2140
*     char *path_str - ??? 
 
2141
*
 
2142
*  RESULT
 
2143
*     int - error code 
 
2144
*        0 = okay
 
2145
*        1 = error 
 
2146
*
 
2147
*  NOTES
 
2148
*     MT-NOTE: cull_parse_path_list() is MT safe
 
2149
*******************************************************************************/
 
2150
int cull_parse_path_list(
 
2151
lList **lpp,
 
2152
char *path_str 
 
2153
 
 
2154
/*
 
2155
   [[host]:]path[,[[host]:]path...]
 
2156
 
 
2157
   str0 - path
 
2158
   str1 - host
 
2159
   str3 - temporary
 
2160
   int  - temporary
 
2161
 */
 
2162
 
 
2163
) {
 
2164
   char *path = NULL;
 
2165
   char *cell = NULL;
 
2166
   char **str_str = NULL;
 
2167
   char **pstr = NULL;
 
2168
   lListElem *ep = NULL;
 
2169
   char *path_string = NULL;
 
2170
   bool ret_error = false;
 
2171
 
 
2172
   DENTER(TOP_LAYER, "cull_parse_path_list");
 
2173
 
 
2174
   ret_error = (lpp == NULL) ? true : false;
 
2175
/*
 
2176
   if (!lpp) {
 
2177
      DEXIT;
 
2178
      return 1;
 
2179
   }
 
2180
*/
 
2181
 
 
2182
   if(!ret_error){
 
2183
      path_string = sge_strdup(NULL, path_str);
 
2184
      ret_error = (path_string == NULL) ? true : false;
 
2185
   }
 
2186
/*
 
2187
   if (!path_string) {
 
2188
      *lpp = NULL;
 
2189
      DEXIT;
 
2190
      return 2;
 
2191
   }
 
2192
*/
 
2193
   if(!ret_error){
 
2194
      str_str = string_list(path_string, ",", NULL);
 
2195
      ret_error = (str_str == NULL || *str_str == NULL) ? true : false;
 
2196
   }
 
2197
/*
 
2198
   if (!str_str || !*str_str) {
 
2199
      *lpp = NULL;
 
2200
      FREE(path_string);
 
2201
      DEXIT;
 
2202
      return 3;
 
2203
   }
 
2204
*/
 
2205
   if ( (!ret_error) && (!*lpp)) {
 
2206
      *lpp = lCreateList("path_list", PN_Type);
 
2207
      ret_error = (*lpp == NULL) ? true : false;
 
2208
/*
 
2209
      if (!*lpp) {
 
2210
         FREE(path_string);
 
2211
         FREE(str_str);
 
2212
         DEXIT;
 
2213
         return 4;
 
2214
      }
 
2215
*/
 
2216
   }
 
2217
 
 
2218
   if(!ret_error){
 
2219
      for (pstr = str_str; *pstr; pstr++) {
 
2220
      /* cell given ? */
 
2221
         if (*pstr[0] == ':') {  /* :path */
 
2222
            cell = NULL;
 
2223
            path = *pstr+1;
 
2224
         } else if ((path = strstr(*pstr, ":"))){ /* host:path */
 
2225
            path[0] = '\0';
 
2226
            cell = strdup(*pstr);
 
2227
            path[0] = ':';
 
2228
            path += 1;
 
2229
         } else { /* path */
 
2230
            cell = NULL;
 
2231
            path = *pstr;
 
2232
         }
 
2233
 
 
2234
         SGE_ASSERT((path));
 
2235
         ep = lCreateElem(PN_Type);
 
2236
         /* SGE_ASSERT(ep); */
 
2237
         lAppendElem(*lpp, ep);
 
2238
 
 
2239
         lSetString(ep, PN_path, path);
 
2240
        if (cell) {
 
2241
            lSetHost(ep, PN_host, cell);
 
2242
            FREE(cell);
 
2243
         }
 
2244
      }
 
2245
   }
 
2246
   if(path_string)
 
2247
      FREE(path_string);
 
2248
   if(str_str)
 
2249
      FREE(str_str);
 
2250
   DEXIT;
 
2251
   if(ret_error)
 
2252
      return 1;
 
2253
   else
 
2254
      return 0;
 
2255
}
 
2256
 
 
2257
 
 
2258
/***************************************************************************/
 
2259
/* MT-NOTE: sge_parse_priority() is MT safe */
 
2260
static int sge_parse_priority(
 
2261
lList **alpp,
 
2262
int *valp,
 
2263
char *priority_str 
 
2264
) {
 
2265
   char *s;
 
2266
 
 
2267
   DENTER(TOP_LAYER, "sge_parse_priority");
 
2268
 
 
2269
   *valp = strtol(priority_str, &s, 10);
 
2270
   if (priority_str==s || *valp > 1024 || *valp < -1023) {
 
2271
       SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_PARSE_INVALIDPRIORITYMUSTBEINNEG1023TO1024));
 
2272
       answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
 
2273
       DEXIT;
 
2274
       return -1;
 
2275
   }
 
2276
   DEXIT;
 
2277
   return 0;
 
2278
}
 
2279
 
 
2280
/****** client/var/var_list_parse_from_environment() **************************
 
2281
*  NAME
 
2282
*     var_list_parse_from_environment() -- create var list from env 
 
2283
*
 
2284
*  SYNOPSIS
 
2285
*     static int var_list_parse_from_environment(lList **lpp, char **envp) 
 
2286
*
 
2287
*  FUNCTION
 
2288
*     Create a list of variables from the given environment. 
 
2289
*
 
2290
*  INPUTS
 
2291
*     lList **lpp - VA_Type list 
 
2292
*     char **envp - environment pointer 
 
2293
*
 
2294
*  RESULT
 
2295
*     static int - error state
 
2296
*         0 - OK
 
2297
*        >0 - Error   
 
2298
*
 
2299
*  NOTES
 
2300
*     MT-NOTES: var_list_parse_from_environment() is MT safe
 
2301
*******************************************************************************/
 
2302
static int var_list_parse_from_environment(lList **lpp, char **envp) 
 
2303
{
 
2304
   DENTER(TOP_LAYER, "var_list_parse_from_environment");
 
2305
 
 
2306
   if (!lpp || !envp) {
 
2307
      DEXIT;
 
2308
      return 1;
 
2309
   }
 
2310
 
 
2311
   if (!*lpp) {
 
2312
      *lpp = lCreateList("env list", VA_Type);
 
2313
      if (!*lpp) {
 
2314
         DEXIT;
 
2315
         return 3;
 
2316
      }
 
2317
   }
 
2318
 
 
2319
   for (; *envp; envp++) {
 
2320
      char *env_name;
 
2321
      char *env_description;
 
2322
      char *env_entry;
 
2323
      lListElem *ep;
 
2324
      struct saved_vars_s *context = NULL;
 
2325
 
 
2326
      ep = lCreateElem(VA_Type);
 
2327
      lAppendElem(*lpp, ep);
 
2328
 
 
2329
      env_entry = sge_strdup(NULL, *envp);
 
2330
      SGE_ASSERT((env_entry));
 
2331
 
 
2332
      env_name = sge_strtok_r(env_entry, "=", &context);
 
2333
      SGE_ASSERT((env_name));
 
2334
      lSetString(ep, VA_variable, env_name);
 
2335
 
 
2336
      env_description = sge_strtok_r((char *) 0, "\n", &context);
 
2337
      if (env_description)
 
2338
         lSetString(ep, VA_value, env_description);
 
2339
      FREE(env_entry);
 
2340
      sge_free_saved_vars(context);
 
2341
   }
 
2342
 
 
2343
   DEXIT;
 
2344
   return 0;
 
2345
}
 
2346
 
 
2347
/***************************************************************************/
 
2348
/* MT-NOTE: cull_parse_destination_identifier_list() is MT safe */
 
2349
static int cull_parse_destination_identifier_list(
 
2350
lList **lpp, /* QR_Type */
 
2351
char *dest_str 
 
2352
) {
 
2353
   int rule[] = {QR_name, 0};
 
2354
   char **str_str = NULL;
 
2355
   int i_ret;
 
2356
   char *s;
 
2357
 
 
2358
   DENTER(TOP_LAYER, "cull_parse_destination_identifier_list");
 
2359
 
 
2360
   if (!lpp) {
 
2361
      DEXIT;
 
2362
      return 1;
 
2363
   }
 
2364
 
 
2365
   s = sge_strdup(NULL, dest_str);
 
2366
   if (!s) {
 
2367
      *lpp = NULL;
 
2368
      DEXIT;
 
2369
      return 3;
 
2370
   }
 
2371
   str_str = string_list(s, ",", NULL);
 
2372
   if (!str_str || !*str_str) {
 
2373
      *lpp = NULL;
 
2374
      FREE(s);
 
2375
      DEXIT;
 
2376
      return 2;
 
2377
   }
 
2378
 
 
2379
   i_ret = cull_parse_string_list(str_str, "destin_ident_list", QR_Type, rule, lpp);
 
2380
   if (i_ret) {
 
2381
      FREE(s);
 
2382
      FREE(str_str);
 
2383
      DEXIT;
 
2384
      return 3;
 
2385
   }
 
2386
 
 
2387
   FREE(s);
 
2388
   FREE(str_str);
 
2389
   DEXIT;
 
2390
   return 0;
 
2391
}
 
2392
 
 
2393
/***************************************************************************/
 
2394
/*   MT-NOTE: cull_parse_jid_hold_list() is MT safe */
 
2395
int cull_parse_jid_hold_list(
 
2396
lList **lpp,
 
2397
char *str 
 
2398
 
 
2399
/*   jid[,jid,...]
 
2400
 
 
2401
   int0 - jid
 
2402
 
 
2403
 */
 
2404
 
 
2405
) {
 
2406
   int rule[] = {ST_name, 0};
 
2407
   char **str_str = NULL;
 
2408
   int i_ret;
 
2409
   char *s;
 
2410
 
 
2411
   DENTER(TOP_LAYER, "cull_parse_jid_hold_list");
 
2412
 
 
2413
   if (!lpp) {
 
2414
      DEXIT;
 
2415
      return 1;
 
2416
   }
 
2417
 
 
2418
   s = sge_strdup(NULL, str);
 
2419
   if (!s) {
 
2420
      *lpp = NULL;
 
2421
      DEXIT;
 
2422
      return 3;
 
2423
   }
 
2424
   str_str = string_list(s, ",", NULL);
 
2425
   if (!str_str || !*str_str) {
 
2426
      *lpp = NULL;
 
2427
      FREE(s);
 
2428
      DEXIT;
 
2429
      return 2;
 
2430
   }
 
2431
   i_ret = cull_parse_string_list(str_str, "jid_hold list", ST_Type, rule, lpp);
 
2432
   
 
2433
   if (i_ret) {
 
2434
      FREE(s);
 
2435
      FREE(str_str);
 
2436
      DEXIT;
 
2437
      return 3;
 
2438
   }
 
2439
 
 
2440
   FREE(s);
 
2441
   FREE(str_str);
 
2442
   DEXIT;
 
2443
   return 0;
 
2444
}
 
2445
 
 
2446
/****** client/var/var_list_parse_from_string() *******************************
 
2447
*  NAME
 
2448
*     var_list_parse_from_string() -- parse vars from string list 
 
2449
*
 
2450
*  SYNOPSIS
 
2451
*     int var_list_parse_from_string(lList **lpp, 
 
2452
*                                    const char *variable_str, 
 
2453
*                                    int check_environment) 
 
2454
*
 
2455
*  FUNCTION
 
2456
*     Parse a list of variables ("lpp") from a comma separated 
 
2457
*     string list ("variable_str"). The boolean "check_environment"
 
2458
*     defined wether the current value of a variable is taken from
 
2459
*     the environment of the calling process.
 
2460
*
 
2461
*  INPUTS
 
2462
*     lList **lpp              - VA_Type list 
 
2463
*     const char *variable_str - source string 
 
2464
*     int check_environment    - boolean
 
2465
*
 
2466
*  RESULT
 
2467
*     int - error state
 
2468
*         0 - OK
 
2469
*        >0 - Error
 
2470
*
 
2471
*  NOTES
 
2472
*     MT-NOTE: var_list_parse_from_string() is MT safe
 
2473
*******************************************************************************/
 
2474
int var_list_parse_from_string(lList **lpp, const char *variable_str,
 
2475
                               int check_environment)
 
2476
{
 
2477
   char *variable;
 
2478
   char *val_str;
 
2479
   int var_len;
 
2480
   char **str_str;
 
2481
   char **pstr;
 
2482
   lListElem *ep;
 
2483
   char *va_string;
 
2484
 
 
2485
   DENTER(TOP_LAYER, "var_list_parse_from_string");
 
2486
 
 
2487
   if (!lpp) {
 
2488
      DEXIT;
 
2489
      return 1;
 
2490
   }
 
2491
 
 
2492
   va_string = sge_strdup(NULL, variable_str);
 
2493
   if (!va_string) {
 
2494
      *lpp = NULL;
 
2495
      DEXIT;
 
2496
      return 2;
 
2497
   }
 
2498
   str_str = string_list(va_string, ",", NULL);
 
2499
   if (!str_str || !*str_str) {
 
2500
      *lpp = NULL;
 
2501
      FREE(va_string);
 
2502
      DEXIT;
 
2503
      return 3;
 
2504
   }
 
2505
 
 
2506
   if (!*lpp) {
 
2507
      *lpp = lCreateList("variable list", VA_Type);
 
2508
      if (!*lpp) {
 
2509
         FREE(va_string);
 
2510
         FREE(str_str);
 
2511
         DEXIT;
 
2512
         return 4;
 
2513
      }
 
2514
   }
 
2515
 
 
2516
   for (pstr = str_str; *pstr; pstr++) {
 
2517
      struct saved_vars_s *context;
 
2518
      ep = lCreateElem(VA_Type);
 
2519
      /* SGE_ASSERT(ep); */
 
2520
      lAppendElem(*lpp, ep);
 
2521
      
 
2522
      context = NULL;
 
2523
      variable = sge_strtok_r(*pstr, "=", &context);
 
2524
      SGE_ASSERT((variable));
 
2525
      var_len=strlen(variable);
 
2526
      lSetString(ep, VA_variable, variable);
 
2527
      val_str=*pstr;
 
2528
 
 
2529
      /* The character at the end of the first token must be either '=' or '\0'.
 
2530
       * If it's a '=' then we treat the following string as the value */
 
2531
      if (val_str[var_len] == '=') {
 
2532
          lSetString(ep, VA_value, &val_str[var_len+1]);
 
2533
      }
 
2534
      /* If it's a '\0' and check_environment is set, then we get the value from
 
2535
       * the environment variable value. */
 
2536
      else if(check_environment) {
 
2537
         lSetString(ep, VA_value, sge_getenv(variable));
 
2538
      }
 
2539
      /* If it's a '\0' and check_environment is not set, then we set the value
 
2540
       * to NULL. */
 
2541
      else {
 
2542
         lSetString(ep, VA_value, NULL);
 
2543
      }
 
2544
      sge_free_saved_vars(context);
 
2545
   }
 
2546
 
 
2547
   FREE(va_string);
 
2548
   FREE(str_str);
 
2549
   DEXIT;
 
2550
   return 0;
 
2551
}
 
2552
 
 
2553
/****** set_yn_option() ********************************************************
 
2554
*  NAME
 
2555
*     set_yn_option() -- Sets the value of a y|n option
 
2556
*
 
2557
*  SYNOPSIS
 
2558
*     static int set_yn_option (lList **opts, u_long32 opt, char *arg,
 
2559
*                               char *value, lList **alpp)
 
2560
*
 
2561
*  FUNCTION
 
2562
*     Sets the value of the option element to TRUE or FALSE depending on whether
 
2563
*     the option value is y[es] or n[o].
 
2564
*
 
2565
*  INPUT
 
2566
*     lList **opts - The list of options to which to append the option element
 
2567
*     u_long32 opt - The option code of the option
 
2568
*     char *arg    - The option text
 
2569
*     char *value  - The option value
 
2570
*     lList **alpp - The answer list
 
2571
*
 
2572
*  RESULT
 
2573
*     int - STATUS_OK if success, STATUS_ERROR1 otherwise
 
2574
*
 
2575
*  NOTES
 
2576
*     MT-NOTES: set_yn_option() is MT safe
 
2577
*******************************************************************************/
 
2578
static int set_yn_option (lList **opts, u_long32 opt, char *arg, char *value,
 
2579
                          lList **alpp)
 
2580
{
 
2581
   lListElem *ep_opt = NULL;
 
2582
   
 
2583
   if ((strcasecmp("y", value) == 0) || (strcasecmp("yes", value) == 0)) {
 
2584
      ep_opt = sge_add_arg(opts, opt, lIntT, arg, value);
 
2585
      lSetInt(ep_opt, SPA_argval_lIntT, TRUE);
 
2586
      lSetUlong(ep_opt,SPA_argval_lUlongT, TRUE);
 
2587
   }
 
2588
   else if ((strcasecmp ("n", value) == 0) || (strcasecmp ("no", value) == 0)) {
 
2589
      ep_opt = sge_add_arg(opts, opt, lIntT, arg, value);
 
2590
      lSetInt(ep_opt, SPA_argval_lIntT, FALSE);
 
2591
      lSetUlong(ep_opt,SPA_argval_lUlongT, FALSE);
 
2592
    }
 
2593
   else {
 
2594
       sprintf(SGE_EVENT, MSG_PARSE_INVALIDOPTIONARGUMENT_SS, arg, value);
 
2595
       answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
 
2596
       
 
2597
       return STATUS_ERROR1;
 
2598
   }
 
2599
   
 
2600
   return STATUS_OK;
 
2601
}
 
2602
 
 
2603
/* This method is not thread safe.  Fortunately, it is only used by the
 
2604
 * -cwd switch which can be forbidden in DRMAA. */
 
2605
char *reroot_path(lListElem* pjob, const char *path, lList **alpp) {
 
2606
   const char *home = NULL;
 
2607
   char tmp_str[SGE_PATH_MAX + 1];
 
2608
   char tmp_str2[SGE_PATH_MAX + 1];
 
2609
   char tmp_str3[SGE_PATH_MAX + 1];
 
2610
   
 
2611
   DENTER (TOP_LAYER, "reroot_path");
 
2612
   
 
2613
   home = job_get_env_string(pjob, VAR_PREFIX "O_HOME");
 
2614
   strcpy (tmp_str, path);
 
2615
   
 
2616
   if (!chdir(home)) {
 
2617
      /* If chdir() succeeds... */
 
2618
      if (!getcwd(tmp_str2, sizeof(tmp_str2))) {
 
2619
         /* If getcwd() fails... */
 
2620
         answer_list_add(alpp, MSG_ANSWER_GETCWDFAILED, 
 
2621
                         STATUS_EDISK, ANSWER_QUALITY_ERROR);
 
2622
         DRETURN(NULL);
 
2623
      }
 
2624
 
 
2625
      chdir(tmp_str);
 
2626
 
 
2627
      if (strncmp(tmp_str2, tmp_str, strlen(tmp_str2)) == 0) {
 
2628
         /* If they are equal, build a new CWD using the value of the HOME
 
2629
          * as the root instead of whatever that directory is called by
 
2630
          * the -(c)wd path. */
 
2631
         sprintf(tmp_str3, "%s%s", home, (char *) tmp_str + strlen(tmp_str2));
 
2632
         strcpy(tmp_str, tmp_str3);
 
2633
      }
 
2634
   }
 
2635
   
 
2636
   DRETURN(strdup(tmp_str));
 
2637
}
 
2638