Awk#

Status

Authors

Purpose

Awk# is a language that was created for our CSUSB CS320 Programming Languages class. This language was derived from a language given to our project group, Small Awk.

smalltalk

awk

Awk# expands the Small Awk language with new statements, arrays, and functions. This gives a programmer much more flexibility and allows a programmer to create more complex scripts quickly.

Awk# programs cannot be tested currently because there is no available interpreter.

Like awk, Awk# is designed for processing data files. It works with simpler files than awk however. Awk# assumes that it will read a single file and each line in the file is a list of "fields" of data separated by one or more spaces or tabs. Smallawk reads the input file and produces a single stream of output by processing the input. Notice that a Awk# program does not start until it is given some data, and doesn't stop until it gets the usual end-of-file. Here is a traditional simple program in Awk#:

 		END{ print "hello, world"; }

 		{ print NR, $0; }

The next program prints outs lines that contain the string "AWK":

 		/AWK/{ print ;}

The next program Assumes that each line has one number, and at the end of the file outputs the total of these nunmbers:

 		{sum = sum + $0;}

 		END{print sum;}

This one checks the input and only adds a line if it is a valid integer, with one or more decimal digits:

 		/^[0-9][0-9]*$/{sum = sum + $0;}

 		END{print sum;}

This reads in a file of names, student_ids, and scores and calculates the mean score. It assume input with data separated by spaces like this:

 ShortName 9999 3.2

 AnotherName 1234 17

 		{sum = sum + $3; count=count+1;}

 		END{print sum/count;}

Syntax

Lexemes

reserved_words::= "END" | "NF" | "NR" | "BEGIN" | "print" | "if" | "else" | "function" | "return" | "const" | "goto" | "switch" | "case" | "default" | "for" | "while" | "forever" | "break" | "continue" | "exit" | "true" | "false".
dollar::="$".
comma::=",".
Programs
A program is a number of global declarations, a number of function definitions, and a sequence of pieces. Each piece has two parts: a pattern and an action. The pattern states when the action is to be applied. When awk# is running it takes each line and tries each piece of the program in turn and carries out the actions with patterns that match the line.

program::=global_declarations #( function_definition | comment ) #( piece |comment ).

 		/*  Global declarations  */
		a = 3;
		const c = 5;

		/*  Function definitions */
		function func1()
		{
			return (5 + a);
		}

		/* Program Pieces- Activated when the pattern is matched within a line in the file. */
		BEGIN
		{
		 	print func1();
		}

global_declarations::= #(assignment | constant_declaration | comment ).
comment::= "/*" chars "*/".
piece::= O( pattern ) "{" action "}". The pattern is used to recognize the lines of data that the action applies to.
Patterns
pattern::= disjunction .
disjunction::= conjunction #( "||" conjunction).
```
 		/Botting/||/Dick/
```
conjunction::= possible_complement #( "&&" possible_complement).
```
 		/Botting/ && /Richard/
```
possible_complement::= "!" elementary_pattern | elementary_pattern.
```
 		!/Blotting/
```
elementary_pattern::= "END" | "BEGIN" | "/" regular_expression "/".
```
 		/Banana/
```
```
 		/[bB]anana/
```
```
 		/^\.As_is/
```
```
 		/^[0-9]*$/
```
regular_expression::= left_most | rightmost | exact | contained.
leftmost::= "^" contained.
```
 		^.As_is
```
rightmost::= contained "$".
```
 		two part:$
```
exact::= "^" contained "$".
```
 		^Dick.*Botting$
```
contained::= #possibly_repeated_set_of_chars .
possibly_repeated_set_of_chars::= possible_set "*" | possible_set.
```
 		pos*ibil*ity
```
The "*" means "zero or more of". The above matches "posssibity" for example.
possible_set::= normal_character | escaped_character | set_of_characters.
normal_character::= letter | digit | symbol ~ special_character.
escaped_character::= "\" special_character.
special_character::= "[" | "]" | "\" | "." | "*".
set_of_characters::= "[" chars "]" | "[^" chars "]".
chars::= # character | character "-" character .
character::= normal_character | escaped_character.
Actions
An action is a series of at least one statement. These are executed one after another.
action::= statement # statement.
Statements
Awk# includes a number if statements to allow the programmer flexibility in writing code.
statement::= N( O(label ":") O(assignment | print | selection | constant_declaration | switch | do_nothing | goto | return | for_loop | while_loop | forever_loop | continue | break | exit ) O(comment ) ).
assignment::= (variable "=" expression ";") | (array "=" expression ";").
```
 		sum = sum + $0;
```
```
 		a[5] = a[3] - 1; 
```
constant_declaration::= "const" variable "=" expression.
```
 		const Sunday = 1;
```
print::= "print" ";"| "print" expression ";".
```
 		print sum;
```
goto::= "goto" label ";".
```
 		goto Lbl1;
```
label::= letter #(letter|digit).
selection::= "if(" condition ")" if_body O("else" else ).
```
 		if ( sum > 0 ) print "greater";
```
condition::= expression.
if_body::= "{" action "}" | statement.
else::= "{" action "}" | statement.

switch::= "switch(" expression ")" switch_body .

 		switch(val)
		{
			case 1: 
				print "This is Case 1; 
				break;
			case 2: 
				print "This is Case 2; 
				break;
			default: 
				print "EMPTY"; 
				break;
		}

switch_body::= "{" #(case ) O(default ) "}".
case::= "case" expression ":" action .
default::= "default:" action .

for_loop::= "for(" statement condition statement ")" for_body .

		for(count=0; count<=100; count=count+1)
		{
			print count;
		}

for_body::= "{"action "}"|statement.
while_loop::= "while(" condition ")" while_body .

while_body::= "{"action "}"|statement.

		while( EndOfFile!=true )
		{
			print fileValue;
		}

forever_loop::= "forever" forever_body.

		forever
		{
			x=x+2;
			if(x>50) break;
		}

forever_body::= "{"action "}"| statement.
break::="break;".
continue::="continue;".
exit::="exit;".
do_nothing::= ";".
Operations
Awk# contains operation precedence so there is no confusion of which operation should be evaluated first. The operations with highest precedence to the lowest precedence are: !, *, /, %, +, -, <, <=, >, >=, ==, !=, &&, ||.
operation::= "+" | "-" | "*" | "/" | "%" | "&&" | "||" | "!" | "<" | "<=" | ">" | ">=" | "==" | "!=".
arithmetic_expression::= arithmetic_expression #("||" and_expression ).
and_expression::= and_expression #("&&" not_equal_expression ).
not_equal_expression::= not_equal_expression #("!=" equal_expression ).
equal_expression::= equal_expression #("==" greater_equal_expression ).
greater_equal_expression::= (greater_equal_expression #( ">=" greater_expression )) | ((greater_expression ">=") greater_equal_expression ).
greater_expression::= (greater_expression #( ">" less_equal_expression )) | ((less_equal_expression ">") greater_expression ).
less_equal_expression::= (less_equal_expression #( "<="less_expression )) | ((less_expression "<=")less_equal_expression ).
less_expression::= (less_expression #( "<"subtraction_term )) | ((subtraction_term "<") less_expression ).
subtraction_term::= (subtraction_term #("-" addition_term )) | (#(addition_term "-") subtraction_term ).
addition_term::= addition_term #("+" modulus_term ).
modulus_term::= (modulus_term #("%" division_factor )) | (#( division_factor "%") modulus_term ).
division_factor::= (division_factor #("/" multiplication_term )) | (#( multiplication_term "/") division_factor ).
multiplication_term::= multiplication_term #("*" not_expression ).

not_expression::= simple_expression | "!" simple_expression.

		x = 5 + 2 < 12 && 8 == 4;  /* x = false */
		In the example, x will equal the value false.  First the + is evaluated,
		making the equation, 7 < 12 && 8 == 4.  Then the < is evaluated, making
		the equation, true && 8 == 4.  Then == is evaluated, making the equation, 
		true && false.  Lastly, the && is evaluated, returning the value false.

Expressions

expression::= concatenation.
concatenation::= arithmetic_expression # arithmetic_expression.
simple_expression::= function_call | variable | constant | parenthesized_expression | array.
parenthesized_expression::= "(" expression ")".
Functions
function_call::= function_name "(" O(expression #( comma expression )) ")".
```
		exp(5,3);
```

function_definition::= "function" function_name "(" O(parameter_list) ")" function_body.

		function Func1(a,b)
		{
			c= a + b;
			return c;
		}
		function Func2()
		{
			print "Hello";
			return;
		}

function_name::= letter #(letter|digit) | "sin" | "cos" | "log" | "exp" | "sqrt" | "IsInt" | "IsFloat" | "IsBool" | "IsString" | "IsChar" | "IsLong" | "CInt" | "CFloat" | "CBool" | "CString" | "CChar" | "CLong" | "GetChar" | "GetInput".
parameter_list::= variable #( comma variable ).
function_body::= "{" action return "}".
return::= "return;" | "return" expression ";".
Variables and Arrays
array::= array_name "[" index "]".
```
		stats[3]
```
array_name::= letter #(letter|digit).
```
		stats
```
index::= digit #(digit).
variable::= whole_line | field | user_defined_variable.
whole_line::= dollar "0".
```
 		$0
```
field::= dollar expression.
```
 		$5
```
user_defined_variable::=letter #(letter|digit).
```
 		sum
```
Constants
constant:= true | false.
true::= 1.
false::= 0.

. . . . . . . . . ( end of section Syntax.)

Semantics

Here are the informal operational semantics of a Awk# program. The following are diagrams of the language:

Program Diagram:

To Code Example

Pattern Diagram:

Character Diagram:

Statement Diagram:

Loop Diagram:

Expression Diagram:

Pieces

A program P will consist of a sequence of n pieces p[1]..p[n]. Each piece 'p'['i'] has two parts a pattern 'p'['i'].pattern and an action 'p'['i'].action. Here is a C++ like description of what the program P does.

	if( p[i].pattern is "BEGIN" )

		apply p[i].action;

 	NR=1;

 	while( get next line until end of input )

 		for(i = 1; i<=n; i++)

 			if( line matches p[i].pattern )

 				apply p[i].action to line;

 		NR++;

	//after end of file

 	for(i = 1; i<=n; i++)

 		if( p[i].pattern is "END" )

 			apply p[i].action;

A line matches a pattern according to the rules of regular expressions on Unix systems. You can find the rules of regular expressions at: http://www.csci.csusb.edu/dick/samples/regular_expressions.html

Applying an action to the line starts by assigning the whole line to variable $0. Then each field in the line (separated by one or more spaces) is assigned to $1 thru to NF where NF is set to the number of fields. An action is a sequence of one or more instructions and these are executed in turn. If an instruction is an assignment then the expression on the right hand side is evaluated and the resulting value is placed in the variable on the left hand side of the '=' sign. This may change the whole line or any field in the line if the variable is '$0' or 'i' for some other i. If the action is a print command with an expression then the expression is evaluated and output plus a new line. If it is a print with no expression then the whole line (with any changes) is printed. Expressions are evaluated in the usual way: constants become their values, variables return their current value.

Comments

Awk# has the ability of quoting strings of sentences without the compiler parsing the phrase as an expression. This ability will allow the developer to add descriptions of programs between his statements that will describe the behavior of his expressions. Comments can also be added between functions and pieces as well. These comments can be single or multi line and the compiler will ignore anything between the symbols /* and */ :

Example:
/* The start of the program */
BEGIN
{
	/*
	  an instance of a scalar type	
	*/

	i = 5;
}

Our example demonstrates the usage of comments that are defined in the XBNF. We have a /* */, and everything defined between those two symbols will be ignored by the compiler.

Functions

Awk# comes with several predefined mathematical functions that it inherited from Smallawk: sin, cos, log, exp, sqrt. Because there is no way to explicitly declare a certain type of variable, Awk# provides several functions to convert a variable to a specific type: CInt, CFloat, CBool, Cstring, CChar, CLong. A variable's type is determined when it first is assigned a value. When a variable is assigned a value with a type different than its original, the variable type will change. Since a variable can hold any type, the following functions can be used to see what type the variable holds: IsInt, IsFloat, IsBool, IsString, IsChar, IsLong. Two other helpful predefined functions that are not in Smallawk, but are in Awk#, are GetChar and GetInput. GetChar returns one char from keyboard input. GetInput returns a string of input from the keyboard. Keyboard input for GetInput ends when the enter button is pressed.

Example using some predefined type functions:
BEGIN{  
	x=  23.4;
	if (IsFloat(x)) print "X is a float";
	x = CString(x);
	if (IsString(x)) print "X is now a string";
}

In this example, x is assigned a float value, making it a float type. X is then tested with the function IsFloat, which returns true because x is a float. Then CString is used on x and returns the string value "23.4" which is then assigned x. IsString is then used to test to see if x is a string. Since x was assigned the string value of "23.4", x is now a string variable, meaning that IsString will return true.

Another example using predefined input functions:
BEGIN{  
	print "What is your name?";
	name =  GetInput();
	print name + " do you like ice cream? (y/n)";
	answer = GetChar();
	if ((answer == "y") || (answer == "Y"))
		print  "That's great!";
	else
		print "That's too bad";
}

In this example, the program asks for a person's name. Once entered, the program asks whether the person likes ice cream. If the y key is pressed, the "That's great!" message will be displayed. If any other key is pressed the "That's too bad" message will be shown.

Awk# allows a programmer to define their own functions. Because there are no explicitly declared variable types in Awk#, it is not necessary to put the return type in the function definition. A function definition consists of a function name, a list of parameters, a block of statements, and a return statement within the block. Currently, variables can only be passed by value. If the function acts like a procedure, it is not necessary for the return statement to contain a value.

Within an Awk# program, all function definitions should be first, then any other statements can follow. Once a BEGIN, an END, or normal program piece occurs in the code, there can be no other functions definitions or an error will occur. Functions can also not be defined in other functions or within any other blocks.

Examples of function definitions:
function Func1(a,b)
{
	c= a + b;
	return c;
}
function Func2()
{
	print "Hello";
	return;
}

Func1 is an example of a typical function definition. Func1 contains the parameters a and b, passed in by value. The function returns the value of a and b added together. Func2 is an example of a function that does not contain any parameters. Func2 is also an example of a procedure. Func2 does not need to return a value, because it only prints "Hello" to the screen, so an expression is not included within the return statement.

Variables, Arrays, Constants

Awk# gives developers the ability to declare constants. Constants are useful because they are bound to a value and the value cannot be changed by assignment or by an input statement. The also help with program readability and program reliability.

Example of a constant in Awk#:
BEGIN{
	const MAX = 512;
	print MAX;
}

This program declares a constant called MAX and sets it to the value 512. The value of MAX is then printed out to screen. If the code tried to change the value of MAX, an error would occur.

Awk# uses Boolean Data Types, perhaps the smallest of all types. Their range of values has only two elements, zero and one. For the convince of the developer, the constant true is predefined as 1 and the constant false is predefined as 0. Awk# uses these numeric expressions as the return values for conditions. This allows numeric expressions to be used as if they were Boolean.

Example of Boolean Data Constants:
BEGIN{
	x = 0;
	if ( x == true ) print "true"; 
	if ( x == false ) print "false"; 
}

This program will print false because x is declared and initialized to 0. X is then tested to see if the left value is equal to the right value for both the values of true and false. Because false has the value of 0, false is printed.

Awk# supports the use of arrays. Arrays, like variable types, cannot be declared explicitly. They are initialized when they are used with an index. If an index is used beyond the initialized size of an array, an array is automatically increased to that size. Arrays also begin at index 0.

Here is an example using an array:
BEGIN{  
	for (i = 0; i <= 5; i = i + 1)
	{
		ar[i] = i
		print i;
	}
}

In this example, the array ar is assigned a value for indexes 0 to 5. Each time through the loop, the array expands in size by one memory cell because an index is used beyond its original size.

Arrays also have an interesting function in Awk# in that they can be used as simple structure instance. This is because an array does not have to be constrained to one data type. For example, if you wanted use a shape structure that includes the number of sides, its color, and its size, you could use the following code:

BEGIN{  
	const sides = 0;
	const color = 1;
	const size = 2;

	shape1[sides] = 4;
	shape1[color] = "blue";
	shape1[size] = 5.5;
}

In this example, an instance of a shape type structure is formed named shape1.

Awk# only has two kinds of variables and arrays, local and global. Because there are no formal type declarations, excluding constants, in Awk#, variables are declared when they are first used. Local variables are therefore created when they are used within a function or a piece, and can only be used in the function or program piece they are created in. Global variables, although not explicitly declared with types, have to be used within the global declaration area. They take the form of assignments or constants in the first part of the program, before any functions or program pieces are declared. Any global variable used in an assignment or constant declaration in the beginning part of the program can be used anywhere in the program.

Here is a code example of an entire program:

/*  Global declarations  */
a = 3;
const c = 5;

/*  Function definitions */
function proc1()
{
	b = 4;
	print a;
	print b;
	return;
}
function proc2()
{
	print a;
	print b;
	return;
}

/* Program Pieces- Activated when the pattern is matched within a line in the file. */
BEGIN
{
 	proc1();
	proc2();
}

In this example, a is declared as a global variable and c is declared as a global constant. The program will start in the BEGIN program piece with its first line, calling proc1. Proc1 will then print out the values of the global variable a and the local variable b. Then proc2 will be called. The global variable a will then be printed, but the next line will cause an error. Because the variable b was never given a value in proc2, it was not created and there fore will cause an error when the function tries to print its value. Back to Program Diagram

Selection and Branching

Awk# has the ability of stating conditional statements using an if-else clause. The clause test a condition and if the condition returns 1, then the if statement is evaluated. If the condition returns 0, then the else statement is evaluated. When multiple conditions are needed to satisfy a statement we use a nested ladder of else conditional clauses. At the most basic foundation an if statement allows for sub-branching based upon a conditional boolean expression.

Example of a Conditional if-else statement:
BEGIN{
	bool = true;
	
	if( bool )
	  print "Hello, World.";
	else
	  print "Program failure.";
 	}

Awk# has the ability of describing a switch-case conditional statement. A switch-case will perform, the case action if the case's expression matches the switch expression. This satisfies the need of having a very long if-else clause instead. If no cases match the expression of the switch statement being tested, an optional default case can be used to deal with such cases.

Example of a Conditional Switch-Case statement:
BEGIN{
	selection = 1;
	
	switch(selection)
	{
		case 1: 
			print "This is Case 1; 
			break;
		case 0: 
			print "This is Case 2; 
			break;
		default: 
			print "EMPTY"; 
			break;
	}
}

According to which case that will be chosen the above represents conditional branching in a switch-case statement. The above will print out a specified string if the expression of the switch statement matches the case containing the string.

Awk# has the ability to branch to any line in the program by using labels and the goto statement. Each statement can contain a label as its first portion. The label is separated from the rest of the statement by a colon. A goto statement allows the program to be redirected to a different line, indicated by the label in the goto statement.

Example of Goto and Labels:
BEGIN{
	print "Hello World ";
	goto Lbl1;
	print "This will not be printed";
	Lbl1: print "Done";
}

This program will only print "Hello World" and "Done". When the program reaches the line containing the goto statement, it skips to the line containing the label Lbl1, meaning the string "This will not be printed" will not be shown on the screen.

Loops

Awk# has three different loops that can be used. Awk# gives developers the ability to repeatedly execute a segment of code using For Loops. The For loop is counter controlled in which a count value is maintained. The code segment is executed from an initial value until a terminal value is reached.

Example of a For Loop in Awk#:
BEGIN { 
		for(count=0; count<=100; count=count+1)
		{
			print count;
		}
}

This program uses a for loop to print out values of the count. The for loop first initializes a count and sets the value to zero. The code segment is repeated until count reaches above the value 100 while incrementing the count with each pass. The code prints out the values from zero until 100.

Awk# gives developers the ability to repeat a segment of code using a repetition control based on a boolean expression rather then a counter controlled loop.

Example of a While Loop in Awk#:
BEGIN {
		while( EndOfFile!=true )
		{
			print fileValue;
		}
	 }

This program uses a while loop to print file values as long as it does not reach the end of the file.

Awk# gives developers the ability to repeat a segment of code indefinitely using a forever loop. If used in conjunction with the break and continue statements, the forever loop can create a loop where the conditional test occurs in the middle of the loop.

Example of a forever loop in Awk#:
BEGIN {
		forever
		{
			x=x+2;
			if(x>50)
			{
				break;
			}
		}
	 }

This program uses a forever loop to increment the value of x by two then print the value. In the middle of the loop the x value is checked, and if above the value fifty it breaks out of the forever loop.

Awk# comes with several statements to help manage the flow of loops. Awk# has the ability to jump to the end of the current repetitive statement. The code between the break call and the end of the repetitive statement is skipped. The condition of the repetitive statement is NOT evaluated.

Example of the Break statement:
/*Program to demonstrate the Break Statement.*/
BEGIN {
		I = 0;
		while (I < 10)
		{
			I = I + 1;
			if (I > 5) break;
			print (I);
		}
}/* end begin*/

This program will print "12345". When the program reaches the line containing the break statement in each of the repetitive statements, it exits the current statement.

Awk# has the ability to jump to the end of the current repetitive statement. The code between the continue statement and the end of the repetitive statement is skipped. The condition of the repetitive statement is then checked again.

Example of the continue statement:
/*Program to demonstrate the continue statement.*/
BEGIN{
	I = 0;
	while (I < 10)
	{
		I = I + 1;
		if ( I < 5) continue;
			print (I);
	}
}/*end*/

The above program will print "6789." For each loop, type the program will increment a counter variable or each pass. If the value of the counter variable is less than five in each loop, the loop will stop at that point and continue from the beginning of the loop.

Awk # has the ability to exit the current subroutine, and return control to the calling routine with the exit statement. If the exit statement is invoked in the main program routine, exit stops the program.

Example of the Exit statement:
/*Program to demonstrate the Exit Statement.*/
BEGIN{
	yes = true
	print "Hello this is a normal exit";
	if ( yes ) 
	{
		print "Bailing out early";
		exit;
	}	
	print " continuing to the end";
}

The above program will always print "Bailing out early" and exit the program. The exit statement will cause the program to terminate and never reach the "continuing to the end" output statement.

Glossary

TBA::="To Be Announced".

TBD::="To Be Done".

For X, O(X)::= (X | ), Optional X.

. . . . . . . . . ( end of section Small Awk) <<Contents | Index>>

Formulae and Definitions in Alphabetical Order

action (Definition)
addition_term (Definition)
and_expression (Definition)
arithmetic_expression (Definition)
array (Definition)
array_name (Definition)
assignment (Definition)
awk (Definition)
break (Definition)
case (Definition)
character (Definition)
chars (Definition)
comma (Definition)
comment (Definition)
concatenation (Definition)
condition (Definition)
conjunction (Definition)
constant_declaration (Definition)
contained (Definition)
continue (Definition)
default (Definition)
disjunction (Definition)
do_nothing (Definition)
dollar (Definition)
elementary_pattern (Definition)
else (Definition)
escaped_character (Definition)
constant_declaration (Definition)
equal_expression (Definition)
exact (Definition)
exit (Definition)
expression (Definition)
false (Definition)
field (Definition)
for_body (Definition)
for_loop (Definition)
forever_loop (Definition)
function_body (Definition)
function_call (Definition)
function_definition (Definition)
function_name (Definition)
global_declarations (Definition)
goto (Definition)
greater_expression (Definition)
greater_equal_expression (Definition)
if_body (Definition)
index (Definition)
label (Definition)
leftmost (Definition)
less_expression (Definition)
less_equal_expression (Definition)
modulus_term (Definition)
multiplication_term (Definition)
normal_character (Definition)
not_expression (Definition)
not_equal_expression (Definition)
O (Function definition)
operation (Definition)
parameter_list (Definition)
parenthesized_expression (Definition)
pattern (Definition)
piece (Definition)
possible_complement (Definition)
possible_set (Definition)
possibly_repeated_set_of_chars (Definition)
print (Definition)
program (Definition)
regular_expression (Definition)
reserved_words (Definition)
return (Definition)
rightmost (Definition)
selection (Definition)
set_of_characters (Definition)
simple_expression (Definition)
smalltalk (Definition)
special_character (Definition)
statement (Definition)
subtraction_term (Definition)
switch (Definition)
switch_body (Definition)
TBA (Definition)
TBD (Definition)
true (Definition)
user_defined_variable (Definition)
variable (Definition)
while_body (Definition)
while_loop (Definition)
whole_line (Definition)

Contents

Awk#

Status

Authors

Purpose

Syntax

Lexemes

Programs

Patterns

Actions

Statements

Operations

Expressions

Functions

Variables and Arrays

Constants

Semantics

Pieces

Comments

Functions

Variables, Arrays, Constants

Selection and Branching

Loops

See Also

Glossary

Formulae and Definitions in Alphabetical Order