Re: Command-line argument capture

On Dec 13, 4:40 pm, Terence <tbwri...@xxxxxxxxx> wrote:
Is there an "approved" or commonly-use way of capturing command-line
arguments?
I have my own versions that work for DOS and Windows, but I wanted to
ensure my call corresponded to "normal" usage.

 I do
  CALL GETARG(parameter number, character string input, max leng
desired/actual length returned )

 I actually get the whole line once, and index the start points and
lengths, then any further calls just transfer the existing text and
length. I assume comma or blank separators and eliminate additional
blanks; I hope that's enough

!-
!-THERE IS A STANDARD, BUT IT NEEDS CLARIFIED OR CHANGED:
!-=======================================================
!-
!-Well, there is a standard way to get the command line with a
procedure
!-called GET_COMMAND() starting with Fortran 2003; very widely
available
!-in f90+ compilers (g95, gfortran, ifort, ...) already. Or, you can
use
!-the F2KCLI package to add it if your compiler does not have it; or
you
!-can make something very much like it using the often-available
GETARGS()
!-and IARG() procedures or their equivalent (I don't know of a Fortran
!-/FORTRAN compiler that doesn't have one anymore).
!-
!-The GET_COMMAND() routine is clarified in the most recent Fortran
2008
!-proposal; but there's still a flaw in making what GET_COMMAND()
returns
!-determinent; and different compilers seem to have solved the
"problem"
!-differently. G95 seems to do the most reasonable thing -- leave the
!-command "verb" out of the "complete command string" and let you get
the
!-"verb" with GET_COMMAND_ARGUMENT(0) if you can. But the standard
seems
!-to imply the "verb" should be returned in GET_COMMAND() (and
gfortran,
!-ifort, and IBM include it). Yet the description of
GET_COMMAND_ARGUMENT()
!-clearly states that GET_COMMAND_ARGUMENT(0) may not exit.
!-
!-IN ENGLISH:
!-===========
!-
!-Lets say you say the verb should be part of what GET_COMMAND()
returns:
!-
!-A related procedure (GET_COMMAND_ARGUMENT()) makes it clear the
command
!-verb may legally not be defined. And so if you use GET_COMMAND()
you
!-don't know if the returned value includes the pathname to the
command
!-or not; and some systems allow filenames with blank characters; and
you
!-are going to have to make sure the returned value is big enough for
any
!-pathname plus the actual arguments.
!-
!-Lets say you say the verb is not part of what GET_COMMAND() returns:
!-
!-You can still get it with GET_COMMAND_ARGUMENT(0,VERB,STATUS) as one
!-string, so things like blanks in the filename are not confusing.
!-
!-So I say that the G95 interpretation ends up with a better routine.
In
!-fact, GET_COMMAND() is better off replaced with a routine that
!-concatenates the strings returned by GET_COMMAND_ARGUMENT() if the
!-"everybody I tried except g95" interpretation is used.
!-
!-AGAIN WITH EXAMPLES AND DOCUMENTATION EXTRACTS:
!-===============================================

!---------------------------------------------------------------------------------------------------------------------
! ISSUE:
! ifort(1) and gfortran(1) return get_command_argument(0) at beginning
of
! string returned by get_command(3f). g95(1) return string that
begins
! with get_command_argument(1)
!---------------------------------------------------------------------------------------------------------------------
! pros and cons:
! get_command_argument implies there may not be a meaningful
! get_command_argument(0); so you can't tell if the "verb"
! is there or not. Could resolve that by letting you control if
! get_command_argument(0) is present in COMMAND or not; or less
desirably
! STATUS could have values assigned that mean returned-OK-with-arg(0)
and
! returned-OK-without-arg(0). That is, STATUS=0 means OK with;
STATUS=1
! means OK without. Using STATUS means the current command does not
change,
! but means you would have to conditionally parse arg(0) if present.
! But is get_command_argument(0) "exactly as typed" or the full path
or
! the path leaf? What about spaces and non-alphameric characters like
\ and
! such in the command?
!
! Something else that is not clear to me
! is the only delimiter for get_command_argument(3F) a space? What
about tab,
! comma, colon, and so on?
!
! the other problem is that the length of the COMMAND variable would
have
! to be able to hold all the parameters plus the longest possible arg
(0)
! option; which is typically a system pathname.
!---------------------------------------------------------------------------------------------------------------------

! ------------------------------------------------------------------
! TEST PROGRAM:
! -------------

Program echo
integer :: i
integer :: ierr
character :: command*256
call get_command_argument(0,command,i,ier)
write (*,*) "get_command_argument(0) is "//command(:len_trim
(command))
call get_command(command,i,ier)
write (*,*) "get_command is " //command(:len_trim(command))
do i10=1,command_argument_count()
call get_command_argument(i10,command)
write (*,*) i10, "th argument="//command(:len_trim(command))
enddo
end program echo

!--------------------------------------------------------------------
!GFORTRAN RUN:
!-------------
!
!gfortran-4 --version
! GNU Fortran (GCC) 4.3.2 20080827 (alpha-testing) 1
! Copyright (C) 2008 Free Software Foundation, Inc.
! :
!
!gfortran-4 bug1.f90
!./a
! get_command_argument(0) is ./a
! get_command is ./a <--- arg(0) is in COMMAND
!
!--------------------------------------------------------------------
!G95 RUN:
!--------
!
!g95 --version
!G95 (GCC 4.0.3 (g95 0.92!) Aug 21 2008)
!Copyright (C) 2002-2005 Free Software Foundation, Inc.
! :
!
!g95 bug1.f90
!./a
! get_command_argument(0) is ./a
! get_command is <--- arg(0) is not in COMMAND
!--------------------------------------------------------------------

!---------------------------------------------------------------------------------------------------------------------
! DESCRIPTIONS FROM J3'S RECENT PROPOSAL FOR FORTRAN 2008:
!---------------------------------------------------------------------------------------------------------------------
! Page 348 Intrinsic procedures and
modules 13.7.62
! 08-007r2:2008/03/11 CD
1539-1 ISO/IEC SC22/WG5/N1723
!
!
!6 Example. GAMMA (1.0) has the value 1.000 (approximately).
!
! 13.7.65 GET_COMMAND ([COMMAND, LENGTH, STATUS])
!1 Description. Get the entire command by which the program was
invoked.
!
!2 Class. Subroutine.
!
!3 Arguments.
! COMMAND (optional) shall be a default character scalar. It is an
INTENT (OUT) argument. It is assigned
! the entire command by which the program was invoked. If
the command cannot be determined,
! COMMAND is assigned all blanks.
! LENGTH (optional) shall be a default integer scalar. It is an
INTENT (OUT) argument. It is assigned the
! significant length of the command by which the program
was invoked. The significant length may
! include trailing blanks if the processor allows commands
with significant trailing blanks. This length
! does not consider any possible truncation or padding in
assigning the command to the COMMAND
! argument; in fact the COMMAND argument need not even be
present. If the command length
! cannot be determined, a length of 0 is assigned.
! STATUS (optional) shall be a default integer scalar. It is an
INTENT (OUT) argument. It is assigned the
! value -1 if the COMMAND argument is present and has a
length less than the significant length
! of the command. It is assigned a processor-dependent
positive value if the command retrieval fails.
! Otherwise it is assigned the value 0.
!---------------------------------------------------------------------------------------------------------------------
!---------------------------------------------------------------------------------------------------------------------
! 13.7.66 GET_COMMAND_ARGUMENT (NUMBER [, VALUE, LENGTH,
! STATUS])
!1 Description. Get an argument from the command by which the program
was invoked.
!
!2 Class. Subroutine.
!
!3 Arguments.
! NUMBER shall be a default integer scalar. It is an INTENT (IN)
argument.
! It specifies the number of the command argument that the
other arguments give information about.
! Useful values of NUMBER are those between 0 and the
argument count returned by the intrinsic
! function COMMAND_ARGUMENT_COUNT. Other values are
allowed, but will result in error
! status return (see below).
! Command argument 0 is defined to be the command name by
which the program was invoked if
! the processor has such a concept. NUMBER is allowed to
be zero even if the processor does not
! define command names or other command arguments.
! The remaining command arguments are numbered
consecutively from 1 to the argument count in
! an order determined by the processor.
! VALUE (optional) shall be a default character scalar. It is an
INTENT (OUT) argument. It is assigned the
! value of the command argument specified by NUMBER. If
the command argument value cannot be
! determined, VALUE is assigned all blanks.
! LENGTH (optional) shall be a default integer scalar. It is an
INTENT (OUT) argument. It is assigned the
! significant length of the command argument specified by
NUMBER. The significant length may
! include trailing blanks if the processor allows command
arguments with significant trailing blanks.
! This length does not consider any possible truncation or
padding in assigning the command argument
! value to the VALUE argument; in fact the VALUE argument
need not even be present. If the
! command argument length cannot be determined, a length
of 0 is assigned.
! STATUS (optional) shall be a default integer scalar. It is an
INTENT (OUT) argument. It is assigned the
! value -1 if the VALUE argument is present and has a
length less than the significant length of the
! command argument specified by NUMBER. It is assigned a
processor-dependent positive value if
! the argument retrieval fails. Otherwise it is assigned
the value 0.
!---------------------------------------------------------------------------------------------------------------------
.

Relevant Pages

  • Re: keyboard shortcut to edit cell contents
    ... Edit Mode itself isn't a command - it's a state. ... Edit Mode is also different for cells, in that the result of the entry ... Does assigning a key command to "Edit Text..." ...
    (microsoft.public.mac.office.excel)
  • Re: Python and Flaming Thunder
    ... Dave Parker a écrit: ... If command is "quit" ... ... for assigning and checking types. ...
    (comp.lang.python)
  • Re: Python and Flaming Thunder
    ... If command is "quit" ... ... Or when assigning a type to an identifier: ... years of wasted debugging time spent on languages that accept ...
    (comp.lang.python)
  • Re: Not Responding .AddNew Record ADP
    ... adding the Set command before assigning the ActiveConnection to the command ... Connection object is a string and that a string is also the default argument ... >> Dim cmd As ADODB.Command ...
    (microsoft.public.access.adp.sqlserver)
  • [PATCH v1] sata_mv: conversion to new EH
    ... initiate EH from interrupt handler. ... static inline void __msleep(unsigned int msec, ... * Intent is to clear all pending error conditions, ... * This routine holds the host lock while failing the command. ...
    (Linux-Kernel)