NAMING CONVENTION SPECS
Programming is essentially an exercise in
naming. If only the computer can do the
naming itself, it could do the programming
itself also. This is where naming
convention comes in.
So, in a way, naming convention is aimed
at making the computing environment
nameless -- no files and no variables!
This is the criteria for full automation
and natural-language programming.
But, before we make computer follow the
naming convention, we must ourselves
follow it.
I. NAME STRUCTURE
* All names for files
and variables are 6 lettered.
* Each name is divided into two
3-letter parts, except for single-word
name, which can use its first 6 letters.
II. PROGRAM FILE NAMES
1. The first 3-letter part describes
the program, and the last 3-letter part
describes the data.
2. Program Description
(1)Each program is identified
with 2-letter unique prefix. It will be
chosen from the first 2 letters
of the program name, on a first come
first use basis, and also special
priority may be given to important
programs to use their first
2 letters (see file, namrec).
(2)The type of processors for
all programs are identified in the third
letter as follows:
* i = input processor
* e = execution processor
* o = output processor
* 1 = generator of preprocessor
* 0 = postprocessor generator
* l = library source
* m = menu of menu(not robot)
files for processors possessing robots
* r = reserved for hardwired menus
3. Data Description
* The file type is identified
in the fourth letter by:
* r = robot file(rob) (robcod=list
of code robots)
* i = input file
* e = execution file
* o = output file
* u = update source listing of processor
* s = schematic boxes representing
components in a model that processing can
be skipped to
* f = figure schematics of components
* g = graphics data
* m = menu file(men)(mencod=list
of code menus)
* h = how files
* a = absolute module
of machine instructions
* l = library or base module
of machine instructions
* p = plot data file
* b = box data file for selection
* t = tabulated data
file or tree structure
* d = data files summary listing out all
the linking data files named with the
4th letter, d, replace by 0 thru 9 and
their respective data argument list and
any format(if not binary).
(1)The last two letters are used to
uniquely identified the problem model,
which is formed by the 1st letter of the
1st 2 keywords of the model description,
unless conflict with other models occur.
(2)Listings of identifiers (to avoid
conflicts for files
files are automatically kept in files:
* namrec = names of programs
and their prefixes
* menrec = menu names and descriptions
structure(updated manually)
* rob*** = names of robots for
a prefix(***) for duplication check
* men*** = names of menus with prefix(***) of processors possessing ro
* ***nam = code subroutine
names and description
* **dvar = code variable names(
only available for generated programs)
* mailog = names of current file being
editted or diagnosed,etc.
* namlog = name of file being processed
* roblog = robot name file
* autlog = automation gntrol
file for demonstration
* collog = color identification
numbers for menu display
* ibmlog = 0 if IBM
workstation, 1 if SUN
(4)VARIABLE NAMES and UTILITY FILES
* Two key words are to be picked
from the description of the
file or variable. When picked
automatically by the computer,
either the first 2 words or words
preceded by an extra blank
are considered key words.
* Names are formed with the first
3 letters of the first key
word and first 3 letters of the
second key word. If only one key
word is available, use it as is
or truncate it to 6 letters if
longer than 6.
* Temporary or local names have
repeated letters such as "nnn",
instead of "num"ber or "vvv",
instead of "var"iable.
* Temporary, dummy indices use
"i", "j", "k", "l", "m" or "n".
* Temporary, dummy real variables
use "x", "y", "z", "u", "v" or "w".
5. MAJOR SOFTWARE LIBRARIES AND FILES
* iolupd = i/o library source
routines in c-language and Xwindows
* useupd = user interface fortran source
* edeupd = editor fortran source
* dieupd = diagnoser fortran source
* ge1upd = code generator fortran source
* na1upd = natural-language programming
program fortran source
* pauupd = to pause the user interface by
showing the background output
* ???lin = the linking file where ??? are
use, ede, die, na1 and pau.
* anrmen = the main menu menu
* edev?? = hardwired editor's robots where
"?" typically represents the basic command,
but can be easily expanded to include
combination or vanpool of commands.
6. FORTRAN GRAMMAR
* limit statement length to 40 columns
* use statement numbers ending in '0' for
DO loops
* use statement numbers ending in '5' for
GOTO/CONTINUE statements
* the rest(1 to 4 and 6 to 9) are used for
FORMAT statements
* for debugging statement's formats, use
4 digits starting with '9'
* dont use any fortran rules that are not
specified in file forrul.html
7. FILE UNIT NUMBERS
* 1 = for the major output generated, such
as the generated fortran program,
the input data deck from preprocessor,
or debugging source files, etc
* 2 = the major input file
* 50 = the input robot file
* 60 = the output robot file
* 70 = the debugging output, normally at
the start and end of subroutines executed
8. QUESTION/ANSWER routines with robot
-reading and -writing capabilities
* QUEREA/QUEINT/QUEALP/QUESTA/QUESTC/QUEMST
...
are, respectively, for answers in
real, integer,
alphanumerical, statement, capital-letter
statament, multiple statements...
9. Menu selection routines(calling c
routine, selop?):
* MODSEL = select from an menu
* SELMEN = select from internally described
options
* MENPR? = menu processing used in the
user interface
10. Writing out statements:
* WRIMEG = writing out long messages in one
or multiple windows
* WRISTA = writing out direct onto
terminal screen
11. Debugging considerations
* The following statement are placed,
respectively, at beginning and end of
a subroutine:
IF(LOGBUG.GE.1)WRITE(LOGDEB,9001)...
CALL BUGFLU
9001 FORMAT('$$$ ENTERING SUBROU')
IF(LOGBUG.GE.1)WRITE(LOGDEB,9999)...
CALL BUGFLU
9999 FORMAT('$$$ ENTERING SUBROU')
along with the COMMON/AUTDAT/ in which
contains the control variables, LOGBUG
and LOGDEB. The BUGFLU routine is used
to flush out the debugging statement
right after they are written, in case
the code bombs out unexpectedly.
* Other normal debugging write are done
with such statement as:
IF(LOGBUG.GE.2)WRITE(LOGDEB,9911)...
And for long output, use
IF(LOGBUG.GE.3)...
* When debugging the editor, the output
unit should be the same as the editor
robot, or 60.
DEVELOPEMENT LOOP
ALIAS FOR UNIX COMMANDS
8.4
USER INTERFACE HOW-TO
back to homepage