![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to puman3.n CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 04.pascal|
Return to puman3.n CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 04.pascal |
1.1 root 1: .\" Copyright (c) 1980 Regents of the University of California.
2: .\" All rights reserved. The Berkeley software License Agreement
3: .\" specifies the terms and conditions for redistribution.
4: .\"
5: .\" @(#)puman3.n 6.2 (Berkeley) 5/7/86
6: .\"
7: .if !\n(xx \{\
8: .so tmac.p \}
9: .if n 'ND
10: .nr H1 2
11: .NH
12: Error diagnostics
13: .PP
14: This section of the
15: .UM
16: discusses the error diagnostics of the programs
17: .PI ,
18: .PC
19: and
20: .X .
21: .I Pix
22: is a simple but useful program which invokes
23: .PI
24: and
25: .X
26: to do all the real processing.
27: See its manual section
28: .IX
29: (1)
30: and section 5.2 below for more details.
31: All the diagnostics given by
32: .PI
33: will also be given by
34: .PC .
35: .NH 2
36: Translator syntax errors
37: .PP
38: A few comments on the general nature of the syntax errors usually
39: made by Pascal programmers
40: and the recovery mechanisms of the current translator may help in using
41: the system.
42: .SH
43: Illegal characters
44: .PP
45: Characters such as `$', `!', and `@' are not part of the language Pascal.
46: If they are found in the source program,
47: and are not part of a constant string, a constant character, or a comment,
48: they are considered to be
49: `illegal characters'.
50: This can happen if you leave off an opening string quote `\(aa'.
51: Note that the character `"', although used in English to quote strings,
52: is not used to quote strings in Pascal.
53: Most non-printing characters in your input are also illegal except
54: in character constants and character strings.
55: Except for the tab and form feed characters,
56: which are used to ease formatting of the program,
57: non-printing characters in the input file print as the character `?'
58: so that they will show in your listing.
59: .SH
60: String errors
61: .PP
62: There is no character string of length 0 in Pascal.
63: Consequently the input `\(aa\(aa' is not acceptable.
64: Similarly, encountering an end-of-line after an opening string quote `\(aa'
65: without encountering the matching closing quote yields the diagnostic
66: ``Unmatched \(aa for string''.
67: It is permissible to use the character `#'
68: instead of `\''
69: to delimit character and constant strings for portability reasons.
70: For this reason, a spuriously placed `#' sometimes causes the diagnostic
71: about unbalanced quotes.
72: Similarly, a `#' in column one is used when preparing programs which are to
73: be kept in multiple files.
74: See section 5.11 for details.
75: .SH
76: Comments in a comment, non-terminated comments
77: .PP
78: As we saw above, these errors are usually caused by leaving off a comment
79: delimiter.
80: You can convert parts of your program to comments
81: without generating this diagnostic
82: since there are two different kinds of comments \- those delimited by
83: `{' and `}', and those delimited by `(*' and `*)'.
84: Thus consider:
85: .LS
86: { This is a comment enclosing a piece of program
87: a := functioncall; (* comment within comment *)
88: procedurecall;
89: lhs := rhs; (* another comment *)
90: }
91: .LE
92: .PP
93: By using one kind of comment exclusively in your program you can use
94: the other delimiters when you need to
95: ``comment out''
96: parts of your program\*(dg.
97: .FS
98: \*(dgIf you wish to transport your program,
99: especially to the 6000-3.4 implementation,
100: you should use the character sequence `(*' to delimit comments.
101: For transportation over the
102: .I rcslink
103: to Pascal 6000-3.4, the character `#' should be used to delimit characters
104: and constant strings.
105: .FE
106: In this way you will also allow the translator to help by detecting
107: statements accidentally placed within comments.
108: .PP
109: If a comment does not terminate before the end of the input file,
110: the translator will point to the beginning of the comment,
111: indicating that the comment is not terminated.
112: In this case processing will terminate immediately.
113: See the discussion of ``QUIT'' below.
114: .SH
115: Digits in numbers
116: .PP
117: This part of the language is a minor nuisance.
118: Pascal requires digits in real numbers both before and after the decimal
119: point.
120: Thus the following statements, which look quite reasonable to
121: .SM
122: FORTRAN
123: .NL
124: users, generate diagnostics in Pascal:
125: .LS
126: .so digitsout
127: .LE
128: These same constructs are also illegal as input to the Pascal interpreter
129: .I px .
130: .SH
131: Replacements, insertions, and deletions
132: .PP
133: When a syntax error is encountered in the input text,
134: the parser invokes an error recovery procedure.
135: This procedure examines the input text immediately after the point
136: of error and considers a set of simple corrections to see whether they
137: will allow the analysis to continue.
138: These corrections involve replacing an input token with a different
139: token,
140: inserting a token,
141: or replacing an input token with a different token.
142: Most of these changes will not cause fatal syntax errors.
143: The exception is the insertion of or replacement with a symbol
144: such as an identifier or a number;
145: in this case the recovery makes no attempt to determine
146: .I which
147: identifier or
148: .I what
149: number should be inserted,
150: hence these are considered fatal syntax errors.
151: .PP
152: Consider the following example.
153: .LS
154: % \*bpix -l synerr.p\fR
155: .tr --
156: .so synerrout
157: %
158: .LE
159: The only surprise here may be that Pascal does not have an exponentiation
160: operator, hence the complaint about `**'.
161: This error illustrates that, if you assume that the language has a feature
162: which it does not, the translator diagnostic may not indicate this,
163: as the translator is unlikely to recognize the construct you supply.
164: .SH
165: Undefined or improper identifiers
166: .PP
167: If an identifier is encountered in the input but is undefined,
168: the error recovery will replace it with an identifier of the
169: appropriate class.
170: Further references to this identifier will be summarized at the
171: end of the containing
172: .B procedure
173: or
174: .B function
175: or at the end of the
176: .B program
177: if the reference occurred in the main program.
178: Similarly,
179: if an identifier is used in an inappropriate way,
180: e.g. if a
181: .B type
182: identifier is used in an assignment statement,
183: or if a simple variable
184: is used where a
185: .B record
186: variable is required,
187: a diagnostic will be produced and an identifier of the appropriate
188: type inserted.
189: Further incorrect references to this identifier will be flagged only
190: if they involve incorrect use in a different way,
191: with all incorrect uses being summarized in the same way as undefined
192: variable uses are.
193: .SH
194: Expected symbols, malformed constructs
195: .PP
196: If none of the above mentioned corrections appear reasonable, the
197: error recovery will examine the input
198: to the left of the point of error to see if there is only one symbol
199: which can follow this input.
200: If this is the case, the recovery will print a diagnostic which
201: indicates that the given symbol was `Expected'.
202: .PP
203: In cases where none of these corrections resolve the problems
204: in the input,
205: the recovery may issue a diagnostic that indicates that the
206: input is ``malformed''.
207: If necessary, the translator may then skip forward in the input to
208: a place where analysis can continue.
209: This process may cause some errors in the text to be missed.
210: .PP
211: Consider the following example:
212: .LS
213: % \*bpix -l synerr2.p\fR
214: .so synerr2out
215: %
216: .LE
217: Here we misspelled
218: .I output
219: and gave a
220: .SM FORTRAN
221: style variable declaration
222: which the translator diagnosed as a `Malformed declaration'.
223: When, on line 6, we used `(' and `)' for subscripting
224: (as in
225: .SM FORTRAN )
226: rather than the `[' and `]' which are used in Pascal,
227: the translator noted that
228: .I a
229: was not defined as a
230: .B procedure .
231: This occurred because
232: .B procedure
233: and
234: .B function
235: argument lists are delimited by parentheses in Pascal.
236: As it is not permissible to assign to procedure calls the translator
237: diagnosed a malformed statement at the point of assignment.
238: .SH
239: Expected and unexpected end-of-file, ``QUIT''
240: .PP
241: If the translator finds a complete program, but there is more non-comment text
242: in the input file, then it will indicate that an end-of-file was expected.
243: This situation may occur after a bracketing error, or if too many
244: .B end s
245: are present in the input.
246: The message may appear
247: after the recovery says that it
248: ``Expected \`.\'\|''
249: since `.' is the symbol that terminates a program.
250: .PP
251: If severe errors in the input prohibit further processing
252: the translator may produce a diagnostic followed by ``QUIT''.
253: One example of this was given above \-
254: a non-terminated comment;
255: another example is a line which is longer than 160
256: characters.
257: Consider also the following example.
258: .LS
259: % \*bpix -l mism.p\fR
260: .so mismout
261: %
262: .LE
263: .NH 2
264: Translator semantic errors
265: .PP
266: The extremely large number of semantic diagnostic messages which the translator
267: produces make it unreasonable to discuss each message or group of messages
268: in detail.
269: The messages are, however, very informative.
270: We will here explain the typical formats and the terminology used in the error
271: messages so that you will be able to make sense out of them.
272: In any case in which a diagnostic is not completely comprehensible you can
273: refer to the
274: .I "User Manual"
275: by Jensen and Wirth for examples.
276: .SH
277: Format of the error diagnostics
278: .PP
279: As we saw in the example program above, the error diagnostics from
280: the Pascal translator include the number of a line in the text of the program
281: as well as the text of the error message.
282: While this number is most often the line where the error occurred, it
283: is occasionally the number of a line containing a bracketing keyword
284: like
285: .B end
286: or
287: .B until .
288: In this case, the diagnostic may refer to the previous statement.
289: This occurs because of the method the translator uses for sampling line
290: numbers.
291: The absence of a trailing `;' in the previous statement causes the line
292: number corresponding to the
293: .B end
294: or
295: .B until .
296: to become associated with the statement.
297: As Pascal is a free-format language, the line number associations
298: can only be approximate and may seem arbitrary to some users.
299: This is the only notable exception, however, to reasonable associations.
300: .SH
301: Incompatible types
302: .PP
303: Since Pascal is a strongly typed language, many semantic errors manifest
304: themselves as type errors.
305: These are called `type clashes' by the translator.
306: The types allowed for various operators in the language are summarized on page
307: 108 of the
308: Jensen-Wirth
309: .I "User Manual" .
310: It is important to know that the Pascal translator, in its diagnostics,
311: distinguishes between the following type `classes':
312: .br
313: .ne 8
314: .TS
315: center;
316: lew(10) le le le le.
317: array Boolean char file integer
318: pointer real record scalar string
319: .TE
320: These words are plugged into a great number of error messages.
321: Thus, if you tried to assign an
322: .I integer
323: value to a
324: .I char
325: variable you would receive a diagnostic like the following:
326: .LS
327: .so clashout
328: .LE
329: In this case, one error produced a two line error message.
330: If the same error occurs more than once, the same explanatory
331: diagnostic will be given each time.
332: .SH
333: Scalar
334: .PP
335: The only class whose meaning is not self-explanatory is
336: `scalar'.
337: Scalar has a precise meaning in the
338: Jensen-Wirth
339: .I "User Manual"
340: where, in fact, it refers to
341: .I char ,
342: .I integer ,
343: .I real ,
344: and
345: .I Boolean
346: types as well as the enumerated types.
347: For the purposes of the Pascal translator,
348: scalar
349: in an error message refers to a user-defined, enumerated
350: type, such as
351: .I ops
352: in the example above or
353: .I color
354: in
355: .LS
356: \*btype\fP color = (red, green, blue)
357: .LE
358: For integers, the more explicit denotation
359: .I integer
360: is used.
361: Although it would be correct, in the context of the
362: .I "User Manual"
363: to refer to an integer variable as a
364: .I scalar
365: variable
366: .PI
367: prefers the more specific identification.
368: .SH
369: Function and procedure type errors
370: .PP
371: For built-in procedures and functions, two kinds of errors occur.
372: If the routines are called with the wrong number of arguments a message similar to:
373: .LS
374: .so sinout1
375: .LE
376: is given.
377: If the type of the argument is wrong, a message like
378: .LS
379: .so sinout2
380: .LE
381: is produced.
382: A few functions and procedures implemented in Pascal 6000-3.4 are
383: diagnosed as unimplemented in
384: Berkeley
385: Pascal, notably those related to
386: .B segmented
387: files.
388: .SH
389: Can't read and write scalars, etc.
390: .PP
391: The messages which state that scalar (user-defined) types
392: cannot be written to and from files are often mysterious.
393: It is in fact the case that if you define
394: .LS
395: \*btype\fP color = (red, green, blue)
396: .LE
397: ``standard'' Pascal does not associate these constants with the strings
398: `red', `green', and `blue' in any way.
399: An extension has been added which allows enumerated types
400: to be read and written,
401: however if the program is to be portable,
402: you will have to write your own routines to perform these functions.
403: Standard Pascal only allows the reading of characters, integers and real
404: numbers from text files.
405: You cannot read strings or Booleans.
406: It is possible to make a
407: .LS
408: \*bfile of\fP color
409: .LE
410: but the representation is binary rather than string.
411: .SH
412: Expression diagnostics
413: .PP
414: The diagnostics for semantically ill-formed expressions are very explicit.
415: Consider this sample translation:
416: .LS
417: % \*bpi -l expr.p\fP
418: .so exprout
419: %
420: .LE
421: This example is admittedly far-fetched, but illustrates that the error
422: messages are sufficiently clear to allow easy determination of the
423: problem in the expressions.
424: .SH
425: Type equivalence
426: .PP
427: Several diagnostics produced by the Pascal translator complain about
428: `non-equivalent types'.
429: In general,
430: Berkeley
431: Pascal considers variables to have the same type only if they were
432: declared with the same constructed type or with the same type identifier.
433: Thus, the variables
434: .I x
435: and
436: .I y
437: declared as
438: .LS
439: \*bvar\fP
440: x: ^ integer;
441: y: ^ integer;
442: .LE
443: do not have the same type.
444: The assignment
445: .LS
446: x := y
447: .LE
448: thus produces the diagnostics:
449: .LS
450: .so typequout
451: .LE
452: Thus it is always necessary to declare a type such as
453: .LS
454: \*btype\fP intptr = ^ integer;
455: .LE
456: and use it to declare
457: .LS
458: \*bvar\fP x: intptr; y: intptr;
459: .LE
460: Note that if we had initially declared
461: .LS
462: \*bvar\fP x, y: ^ integer;
463: .LE
464: then the assignment statement would have worked.
465: The statement
466: .LS
467: x^ := y^
468: .LE
469: is allowed in either case.
470: Since the parameter to a
471: .B procedure
472: or
473: .B function
474: must be declared with a
475: type identifier rather than a constructed type,
476: it is always necessary, in practice,
477: to declare any type which will be used in this way.
478: .SH
479: Unreachable statements
480: .PP
481: Berkeley
482: Pascal flags unreachable statements.
483: Such statements usually correspond to errors in the program logic.
484: Note that a statement is considered to be reachable
485: if there is a potential path of control,
486: even if it can never be taken.
487: Thus, no diagnostic is produced for the statement:
488: .LS
489: \*bif\fP false \*bthen\fP
490: writeln('impossible!')
491: .LE
492: .SH
493: Goto's into structured statements
494: .PP
495: The translator detects and complains about
496: .B goto
497: statements which transfer control into structured statements (\c
498: .B for ,
499: .B while ,
500: etc.)
501: It does not allow such jumps, nor does it allow branching from the
502: .B then
503: part of an
504: .B if
505: statement into the
506: .B else
507: part.
508: Such checks are made only within the body of a single procedure or
509: function.
510: .SH
511: Unused variables, never set variables
512: .PP
513: Although
514: .PI
515: always clears variables to 0 at
516: .B procedure
517: and
518: .B function
519: entry,
520: .PC
521: does not unless runtime checking is enabled using the
522: .B C
523: option.
524: It is
525: .B not
526: good programming practice to rely on this initialization.
527: To discourage this practice, and to help detect errors in program logic,
528: .PI
529: flags as a `w' warning error:
530: .IP
531: .RS
532: .HP 1)
533: Use of a variable which is never assigned a value.
534: .IP 2)
535: A variable which is declared but never used, distinguishing
536: between those variables for which values are computed but which are never
537: used, and those completely unused.
538: .RE
539: .LP
540: In fact, these diagnostics are applied to all declared items.
541: Thus a
542: .B const
543: or a
544: .B procedure
545: which is declared but never used is flagged.
546: The
547: .B w
548: option of
549: .PI
550: may be used to suppress these warnings;
551: see sections 5.1 and 5.2.
552: .NH 2
553: Translator panics, i/o errors
554: .SH
555: Panics
556: .PP
557: One class of error which rarely occurs, but which causes termination
558: of all processing when it does is a panic.
559: A panic indicates a translator-detected internal inconsistency.
560: A typical panic message is:
561: .LS
562: snark (rvalue) line=110 yyline=109
563: Snark in pi
564: .LE
565: If you receive such a message, the translation will be quickly and perhaps
566: ungracefully terminated.
567: You should contact a teaching assistant or a member of the system staff,
568: after saving a copy of your program for later inspection.
569: If you were making changes to an existing program when the problem
570: occurred, you may
571: be able to work around the problem by ascertaining which change caused the
572: .I snark
573: and making a different change or correcting an error in the program.
574: A small number of panics are possible in
575: .X .
576: All panics should be reported to a teaching assistant or systems
577: staff so that they can be fixed.
578: .SH
579: Out of memory
580: .PP
581: The only other error which will abort translation when no errors are
582: detected is running out of memory.
583: All tables in the translator, with the exception of the parse stack,
584: are dynamically allocated, and can grow to take up the full available
585: process space of 64000 bytes on the \s-2PDP\s0-11. On the \s-2VAX\s0-11,
586: table sizes are extremely generous and very large (25000) line programs
587: have been easily accommodated. For the \s-2PDP\s0\-11, it is
588: generally true that
589: the size of the largest translatable program is directly related to
590: .B procedure
591: and
592: .B function
593: size.
594: A number of non-trivial Pascal programs, including
595: some with more than 2000 lines and 2500 statements
596: have been translated and interpreted using
597: Berkeley
598: Pascal on \s-2PDP\s0-11's.
599: Notable among these are the Pascal-S
600: interpreter,
601: a large set of programs for automated generation of
602: code generators,
603: and a general context-free parsing program which has been used to
604: parse sentences with a grammar for a superset of English.
605: In general,
606: very large programs should be translated using
607: .PC
608: and the separate compilation facility.
609: .PP
610: If you receive an out of space message from the translator
611: during translation of a large
612: .B procedure
613: or
614: .B function
615: or one containing a large number of string constants
616: you may yet be able
617: to translate your program if you break this one
618: .B procedure
619: or
620: .B function
621: into several routines.
622: .SH
623: I/O errors
624: .PP
625: Other errors which you may encounter when running
626: .PI
627: relate to input-output.
628: If
629: .PI
630: cannot open the file you specify,
631: or if the file is empty,
632: you will be so informed.
633: .NH 2
634: Run-time errors
635: .PP
636: We saw, in our second example, a run-time error.
637: We here give the general description of run-time errors.
638: The more unusual interpreter error messages are explained
639: briefly in the manual section for
640: .I px
641: (1).
642: .SH
643: Start-up errors
644: .PP
645: These errors occur when the object file to be executed is not available
646: or appropriate.
647: Typical errors here are caused by the specified object file not existing,
648: not being a Pascal object, or being inaccessible to the user.
649: .SH
650: Program execution errors
651: .PP
652: These errors occur when the program interacts with the Pascal runtime
653: environment in an inappropriate way.
654: Typical errors are values or subscripts out of range,
655: bad arguments to built-in functions,
656: exceeding the statement limit because of an infinite loop,
657: or running out of memory\*(dd.
658: .FS
659: \*(ddThe checks for running out of memory are not foolproof and there
660: is a chance that the interpreter will fault, producing a core image
661: when it runs out of memory.
662: This situation occurs very rarely.
663: .FE
664: The interpreter will produce a backtrace after the error occurs,
665: showing all the active routine calls,
666: unless the
667: .B p
668: option was disabled when the program was translated.
669: Unfortunately, no variable values are given and no way of extracting them
670: is available.*
671: .FS
672: * On the \s-2VAX\s0-11, each variable
673: is restricted to allocate at most 65000 bytes of storage (this is a
674: \s-2PDP\s0-11ism that has survived to the \s-2VAX\s0.)
675: .FE
676: .PP
677: As an example of such an error, assume that we have accidentally
678: declared the constant
679: .I n1
680: to be 6, instead of 7
681: on line 2 of the program primes as given in section 2.6 above.
682: If we run this program we get the following response.
683: .LS
684: % \*bpix primes.p\fP
685: .so primeout3
686: %
687: .LE
688: .PP
689: Here the interpreter indicates that the program terminated
690: abnormally due to a subscript out of range near line 14,
691: which is eight lines into the body of the program primes.
692: .SH
693: Interrupts
694: .PP
695: If the program is interrupted while executing
696: and the
697: .B p
698: option was not specified,
699: then a backtrace will be printed.\*(dg
700: .FS
701: \*(dgOccasionally, the Pascal system will be in an inconsistent
702: state when this occurs,
703: e.g. when an interrupt terminates a
704: .B procedure
705: or
706: .B function
707: entry or exit.
708: In this case, the backtrace will only contain the current line.
709: A reverse call order list of procedures will not be given.
710: .FE
711: The file
712: .I pmon.out
713: of profile information will be written if the program was translated
714: with the
715: .B z
716: option enabled to
717: .PI
718: or
719: .IX .
720: .SH
721: I/O interaction errors
722: .PP
723: The final class of interpreter errors results from inappropriate
724: interactions with files, including the user's terminal.
725: Included here are bad formats for integer and real numbers (such as
726: no digits after the decimal point) when reading.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.