BabyCobol: The Language Reference — Features per Level

If you’re following Software Evolution at UTwente, you are implementing BabyCobol in phases called “levels”. This page sorts features of BabyCobol into those levels.

All the videos can be found in the playlist on YouTube.

Level 1: Core Features

• ACCEPT
  • implement a BabyCobol statement that triggers user input and stores the entered value in a field
  • supporting sophisticated data types or even more than one data type is not required
• ADD
  • implement a BabyCobol statement that adds two values together
  • if the second argument is a literal, the third argument is mandatory
• DISPLAY
  • implement a BabyCobol statement for printing a literal or a value of a field
  • WITH NO ADVANCING clause is mandatory
  • DELIMITED BY clause is not required
• DIVIDE
  • implement a BabyCobol statement that divides two values together
  • if the first argument is a literal, the third argument is mandatory
• EVALUATE
  • implement a BabyCobol statement for evaluating infix expressions with –, +, * and / and branching conditionally based on the result
• IF
  • implement a BabyCobol conditional statement
  • supporting contracted expressions is not yet required
  • END can be made mandatory at this point
• MOVE
  • implement a BabyCobol assignment statement
  • supporting multiple targets is necessary
  • no special clauses are required yet
  • just literal-to-field and field-to-field assignment is enough
• MULTIPLY
  • implement a BabyCobol statement that multiplies two values
  • if the second argument is a literal, the third argument is mandatory
• PERFORM
  • implement a BabyCobol statement for calling a different paragraph with the intention to return
  • TIMES clause is necessary to support
  • THROUGH clauses is not required
• STOP
  • implement a BabyCobol statement to terminate the execution of a program prematurely
• SUBTRACT
  • implement a BabyCobol statement that subtracts a value from another value
  • if the second argument is a literal, the third argument is mandatory

Level 2 Features: Lexical Analysis

• position-based parsing and line continuations
  • in the past, each physical line of code must fit on a punched card
  • as a (legacy) consequence, each BabyCobol line is parsed as follows:
    • the first six columns is the sequence number, and can be ignored
    • the seventh column is the line status indicator
      • space for a normal code line (the rest of the line must be parsed)
      • asterisk for a comment line (the entire line can be ignored)
      • hyphen for the line continuation (the marked line continue the previous line)
      • any other symbol must yield a parse error
    • divisions and paragraphs start on the eighth column
    • statements in the procedure division and clauses in the identification division start on the twelfth column
    • columns 73rd and beyond are the identification area, and can be ignored
  • when in doubt, ask a question and/or google up how it all works in COBOL
• case insensitivity
  • implement BabyCobol's insensitivity to symbol cases in keyword, symbol names, etc
  • case sensitivity remains in quoted strings, PICTUREs, comment lines, identification division clause values
  • in case of ambiguity, keywords written in uppercase are resolved as keywords
• keywords
  • in most modern languages keywords (if, void, etc) are reserved, which means they cannot be used as variable names
  • in BabyCobol, fields can have keyword names
  • in the face of ambiguity, words written in uppercase resolve to keywords, otherwise to field names
    
    • supposing that A, B, C, D, E and F are declared fields, so are ADD and TO, the following are correct parses with keywords in bold:
    • ADD A TO B ADD C TO D ADD E TO F. (three statements, no ambiguity)
    • ADD A to B ADD C TO D ADD E TO F. (two statements, lowercase potential keyword resolves to a part of an identifier)
    • ADD A TO B ADD C to D ADD E TO F. (two statements, same reason)
    • ADD A TO B ADD C TO D ADD E to F. (three statements, the last lowercase potential keyword does not lead to ambiguity)
    • ADD A to B ADD C to D ADD E TO F. (one statement, two lowercase potential keywords resolve to identifier parts)
    • ADD A to B ADD C TO D ADD E to F. (two statements, the last lowercase potential keyword does not lead to ambiguity)
    • The following two sentences cannot be parsed and should yield an error because several equally valid parses exist:
    • ADD A TO B ADD C to D ADD E to F.
      • could be ADD A TO B ADD C to D ADD E to F. (one "fix": the last lowercase potential keyword upgraded to a keyword)
      • could be ADD A TO B ADD C to D ADD E to F. (also one fix because upgrading the first lowercase potential keyword leaves no choices for the last one)
    • ADD A to B ADD C to D ADD E to F.
      • could be ADD A to B ADD C to D ADD E to F. (the last lowercase potential keyword upgraded to a keyword)
      • could be ADD A to B ADD C to D ADD E to F. (the second lowercase potential keyword upgraded to a keyword; the third one auto-coevolves)
      • could be ADD A to B ADD C to D ADD E to F. (the first one and the last one are upgraded, if this was the only alternative we could have potentially resolved it claiming that this is two fixes and the other path takes one)
      • could be ADD A to B ADD C to D ADD E to F. (also two fixes: the first and the second lowercase potential keywords get upgraded, the third one coevolves)
• whitespace insignificance
  • most modern languages use whitespace as delimiters, but BabyCobol does not use it at all, following old versions of FORTRAN
  • whitespace characters in the input are preserved, if they occur inside quoted strings, comment line or identification division clause values
  • all other whitespace characters in code columns are ignored, even those breaking a keyword or field name in half
  • in the face of ambiguity, the original whitespace is used for resolution
  • assuming that ACCOUNTNUMBER, ACCOUNT-NUMBER, ACCOUNT and NUMBER are all defined fields:
  • IF ACCOUNT-NUMBER = 0 THEN STOP. (uses the ACCOUNT-NUMBER field)
  • IF ACCOUNT - NUMBER = 0 THEN STOP. (uses the difference between fields called ACCOUNT and NUMBER)
  • MOVE 42 TO ACCOUNTNUMBER. (assigns the value to the ACCOUNTNUMBER field)
  • MOVE 42 TO ACCOUNT NUMBER. (assigns the value to both fields ACCOUNT and NUMBER)
  • MOVE 42 TO ACCOUNT NUM BER. (invalid since whitespace information is not clear enough to disambiguate)
  • whitespace is the literal space symbol, tab, newline, CR/LF, etc

Level 3 Features: Syntactic Analysis

• DATA DIVISION
  • Implement three divisions that can be a part of a BabyCobol program
  • Parsing the IDENTIFICATION DIVISION contents is trivial
  • Parsing the PROCEDURE DIVISION comes down to parsing statements implemented at level 1.
  • Parsing the data division is the core of this task. In particular, pay attention to:
    • nesting data structures with layer numbers
    • nested data structures that should be possible to refer to from the procedure division with OF
      • e.g., MOVE 42 TO A OF B OF C.
    • the possibility of data entries being malformed (in which case your compiler or interpreter should refuse them)
  • It is enough to support only sufficient qualification (full paths with OFs from the top to the leaf) and only data types number(9) and number(X).
• OCCURS clauses
  • Basically list/array support
  • Adds cardinality/multiplicity to a field.
• LIKE clauses
  • Lets a field inherit type information (but not values or cardinality) of another field.
• NEXT SENTENCE
  
  • Support BabyCobol sentences in your language processor. Support them in your AST and/or IR as you see fit.
  • When executed, NEXT SENTENCE should take the computation to the beginning of the next sentence, and cleanly exit any IFs and LOOPs that stand in the way
  • NB: It is valid to use the NEXT SENTENCE from the last sentence of a paragraph, in which case the execution continues in the next paragraph or terminates the program if there are no more statements to execute
• LOOP
  • Implement the universal loop in BabyCobol
  • Having a VARYING clause present without sufficient information from other clause, makes use of default ranges
  • All clauses of the loop construct are detachable, which means they don't have to occur in the beginning or the end of the block, and their effect (such as exiting the loop for the WHILE clause) depends on the place they are used
• contracted expressions
  • Composite expressions in arguments of IF, EVALUATE and WHEN, can be contracted, for example:
    • IF X = 10 OR X = 20 THEN … can be written as IF X = 10 OR 20 THEN …
      
    • IF X > 10 AND X < 20 THEN … can be written as IF X > 10 AND < 20 THEN …
    • IF X > 10 AND X < 20 OR X < 100 AND X > 80 THEN … can be written as IF X > 10 AND < 20 OR 100 AND > 80 THEN …

Level 4 Features: Control Static Semantics

• CALL
  • Let BabyCobol programs call other BabyCobol programs.
  • Includes passing parameters, meaning that the PROCEDURE DIVISION also needs its USING clause implemented.
• COPY
  • Implement the file inclusion directive of BabyCobol, including the REPLACING clause.
• GO TO
  • Implement the “normal” GO TO statement of BabyCobol, with the statically resolvable paragraph name as the argument.
  • GO TO terminates all currently executing LOOP statements
  • GO TO terminates the currently executing PERFORM THROUGH directive if its target is outside of the executing scope
    • see a special example program
• PERFORM THROUGH
  • Add the THROUGH clause to the PERFORM statement implemented at Level 1

Level 5 Features: Data Static Semantics

• sufficient qualification
  
  • Implement the possibility to refer to fields without explicitly listing the entire path to it
  • This should work in all statements that can refer to fields, as well as in LIKE clauses
  • Any ambiguous cases should lead to a compilation error
  • Suppose the data division contains the following entries:
    • 01 A.
    •  03 B.
    •   05 C.
    •    07 D PICTURE IS 999.
    •   05 E.
    •    07 D PICTURE IS 999.
    •    07 F PICTURE IS 999.
  • There are the following options:
    
    • D is illegal since it is insufficient
    • D OF B and D OF A are also illegal because neither is insufficient
    • D OF C OF B OF A and D OF E OF B OF A are valid references to fields with full qualification
    • D OF C is sufficient to refer to D OF C OF B OF A
    • D OF C OF B is sufficient to refer to D OF C OF B OF A
    • D OF C OF A is sufficient to refer to D OF C OF B OF A
    • D OF E is sufficient to refer to D OF E OF B OF A
    • D OF E OF B is sufficient to refer to D OF E OF B OF A
    • D OF E OF A is sufficient to refer to D OF E OF B OF A
  • The declarations above can be followed by something like 01 G LIKE C. — which would define a new top-level record named G having the same structure as sufficiently qualified C OF B OF A.
• PICTURE clause
  
  • Fully support PICTURE clauses in BabyCobol's DATA DIVISION
  • To qualify, the solution must work with ACCEPT and DISPLAY statements
  • MOVE and other statements must not break the picture-consistency of values
• Figurative constants
  • MOVE should be extended to cover three figurative constants as a value being assigned:
    • SPACES: moving it to a field gives it its default value (0 for a 9-position, space for A/X/Z/S, and dot for V)
    • HIGH-VALUES: moving it to a field gives it its highest possible value (9 for a 9/Z-position, small z for A, character #255 for X, plus for S, dot for V)
    • LOW-VALUES: moving it to a field gives it its lowest possible value (0 for a 9-position, space for A/Z, character #0 for X, minus for S, dot for V)
  • NB: MOVE SPACES TO A B C can mean three very different assignments
• MOVE
  • Finish the full implementation of the assignment statement, supporting partial assignment of records by assigning nominally corresponding fields and keeping the rest untouched.
    
    • For example, for the data entries used in the example above, MOVE E TO C and MOVE C TO E will only reassign the field D and will never change the value of F
  • The name matching is not using sufficient qualification, so MOVE E TO B will cause no assignments.
• NB: adding new features should keep old features functioning.
  • In particular, ADD, MOVE and SUBTRACT should work on composite data structures now a-la COBOL's CORRESPONDING

Level 6 Features: Control Dynamic Semantics

• computable GO TO
  • You probably already have a "GO TO <label>" from level 4.
  • Now let's implement "GO TO <field>".
  • This variant accepts an identifier as a target of a GO TO, and the actual control flow depends on the runtime value of this named field.
  • If there is no paragraph with the name corresponding to the current value of the field, a runtime error occurs.
• ALTER
  • If there is a paragraph named X, which contains a single sentence with a single statement GO TO Y, then it is possible to alter the target of that statement to Z, by writing ALTER X TO PROCEED TO Z.
  • GO TO statements that are not single statements in their paragraph, cannot be ALTERed.
  • ALTERed computable GO TO becomes a normal GO TO after alteration.
  • The new target must be a valid paragraph name.
  • Any acceptable GO TO statement can be ALTERed any number of times, and each change is "permanent" until another change happens.
• SIGNAL
  • This statement can be used for global exception handling: if a paragraph name is specified (e.g., SIGNAL X ON ERROR), then from that point on, any fatal error (division by zero, aborted input, wrong computable GO TO, anything) causes the transfer of control to the designated paragraph X instead of program termination.
  • Activation of a SIGNAL paragraph acts more like a GO TO than a PERFORM, so it terminates any ongoing LOOPs and PERFORMs, and does not return automatically to the point of failure.
  • If another fatal error happens during the execution of the SIGNAL paragraph, it causes abnormal termination normally.
  • If execution continues beyond the SIGNAL paragraph, any fatal errors trigger another execution of the SIGNAL paragraph.
  • Normal error handling by program termination can be resumed with SIGNAL OFF ON ERROR
    • If the program contains a paragraph called OFF, the statement above is ambiguous and should result in a compilation error.

BabyCobol is a project by Dr. Vadim Zaytsev a.k.a. @grammarware. Page last updated in May 2026.