Homework 4 - Semantic

Information

Deadline: 5th of May, 23:55
Points: 2 points out of the final grade
Upload the homework: vmchecker.cs.pub.ro
Late upload: 0.1 points / day (maximum 4 days)

What do you have to do

The purpose of the homework is to write the semantic analysis, the intermediate language for the Alf language.

You will receive an AST from the parser that parses correctly a Alf language source and have to write:

  1. the symbol table
  2. add to every AST node an attribute symbol with the context id and determine the types for the nodes that return (expression, value, id, element_of_array, element_of_struct elements, value_of_function)
  3. the semantic error list

All the three requirements are verified and graded separately. Examples that produce no errors will receive erroor points only if the symbol table and the ast are correct.

The program will receive two parameters from the command line:

  • the source file
  • the output file
node main.js source.alf.ast.json source.alf.json

The AST files

Use the ast given here.

Hints for solving the homework

  • Make the symbol table
  • Determine all the variable types in the symbol table
  • Determine the types for all the instructions that return a result
  • While determining the types, write the errors

Output file

The format of the output file is the following

{
    symbol_table: [...], // the symbol_table
    ast: {...}, // the ast with the type for very node that returns a value
    error_list [] // the error list
}

Symbol table

The symbol table is an array of context objects.

[
   // context object id 0 - the context of the main script
   {
      ...
   },
   // context object id 1 - the context object of a function
   {
      ...
   },
   ...
]

While determining the symbol table, add to each AST node a parameter symbol with the value of the its context id.

Context Object

The context object stores

  • the variable declared in that context
  • the function declared in that context
  • the struct declared in that context
  • the parent context id (position in the symbol_table array)
  • the type of the context (module or message)
  • the name of the function which context it is (unless this is not the module)
  • the name of the struct which context it is (unless this is not the module)
  • the type of the return value of the message which context it is (unless this is not the module)

Context objects are generated by

  • the main module
  • a function definition
  • a struct

The object looks like

{
   "variables": { // a dictionary of variables
      "variable_name": {
         "type": // type of the variable
         "line": // the line where the variable was declared
         "value": // the expression that the variable initially has (optional, if the define was with an assignment)
      }
   },
   "functions": { // a dictionary of functions
      "function_name": {
         "type": // the return type of the function
         "parameters": [] // the list of parameters the function takes (the parameters node from the AST)
         "line": // the line where the function was declared
         "symbol": // the context object id that the function creates
 
      }
   }, 
   "types": {  // a dictionary of types
      "type": {
               "type":  // the type of the new type class or array
               "line":  // the line where the type was declared
               // for array
               "elements_type":  // the type of each array element
               "from":  // the first index
               "to": // the last index
               // for struct
               "elements": [ // a list of array elements (the node form the AST)
                  {
                     "type": 
                     "id": 
                     "line": 
                  },
                  ...
               ]
            }
   },
   "parent": 0, // the parent context position in the symbol_table (except of the main script that has no parent), usually 0, 
   "type": // the type of the 
   "function": // the function name if this is a function context
   "struct": // the struct name if the context is in a function that is in a struct
   "return_value": // the return type of the function if this is a function context
}

Exemple

{
   "variables": {
      "s": {
         "type": "school",
         "line": 8
      }
   },
   "functions": {},
   "types": {
      "school": {
         "type": "class",
         "line": 6,
         "elements": [
            {
               "type": "int",
               "id": "type",
               "line": 5
            },
            {
               "type": "logic",
               "id": "private",
               "line": 4
            },
            {
               "type": "string",
               "id": "name",
               "line": 3
            }
         ]
      }
   }
}

Verify Types in the AST

Expression return type

For each of the following nodes, determine the return type

  • exp
  • value
  • identifier
  • return
  • element
  • property
  • dispatch

Set type the by adding a parameter type in the node.

When searching for a variable, the algorithm is:

  • if it is a function context, search the local variables
  • if not found, search the parameters
  • if not found, search the struct context local variables
  • if it is the module context, search the global variables

Example

{   
   "id": "exp",
   "op": "=",
   "left": {
      "id": "exp",
      "op": "mod",
      "left": {
         "id": "id",
         "value": "n",
         "line": 8,
         "symbol": 1,
         "type": "int"
      },
      "right": {
         "id": "id",
         "value": "i",
         "line": 8,
         "symbol": 1,
         "type": "int"
      },
      "line": 8,
      "symbol": 1,
      "t": "int"
   },
   "right": {
      "id": "value",
      "type": "int",
      "value": 0,
      "line": 8,
      "symbol": 1
   },
   "line": 8,
   "symbol": 1,
   "type": "logic"
}

Verify types

For all the AST nodes, verify that the types match:

  • attributions work
  • expressions can be calculated
  • the if/loop/loop when aslongas expression is a logic value
  • the for variable is a number
  • that variables are defined before being used
  • functions are defined before being used
  • array indexes are numbers
  • struct properties exist
  • the variable for element_of_array is an array
  • the variable for a property is a struct
  • variables are not redefined
  • functions are not redefined
  • types are not redefined

This is where most of the errors appear from.

Error List

The error list is an array that contains error objects. The order in which these errors are in the list is up to you.

Error Object Format

Each error has the following format:

{
    type: //  string with the error type
    line: // the line number in the source (starting at 1)
    elements: // items for the error, each type of error has different items
    text: // the error text message
}

Error type

The error type is a string with one of the following titles

VARIABLE_ALREADY_DEFINED

The error occurs when a variable definition is repeated.

Elements
{
    variable: // variable name
}

FUNCTION_ALREADY_DEFINED

The error occurs when a function definition is repeated.

Elements
{
    function: // function name
}

TYPE_ALREADY_DEFINED

The error occurs when a type definition is repeated (array or struct).

Elements
{
    type: // type name
}

STRUCT_ELEMENT_ALREADY_DEFINED

The error occurs when a struct element definition is repeated.

Elements

{

  struct: // struct type name
  element: // element name

}

ARRAY_INDEX_VALUE

The error occurs when the array lower index is higher than the higher index

Elements
{
    array: // array type name
    low_index: // the lower index value
    high_index: // the higher index value
}

TYPE_RESOLUTION

The error occurs when the type of a variable is not determinable (bonus only).

Elements
// variable
{
    variable: // the name of the variable with the unresolved type
}
// struct element
{
    struct: // name of struct type
    element: // name of struct element with the unresolved type
}

UNDEFINED_MESSAGE

The error occurs when a function call is made to a function that is not defned.

Elements
{
   id: // message name
}

UNDEFINED_VARIABLE

The error occurs when a variable that is not defined is used.

Elements
{
   variable: // variable name
}

UNDEFINED_TYPE

The error occurs when a type that is not defined is used.

Elements

{

  variable: // the variable that has that type
  type: // the type that is undefined

}

NOT_STRUCT_PROPERTY

The error occurs when an element is not part of that struct.

Elements
{
   struct: // struct name
   property: // element name
}

NOT_STRUCT

The error occurs when a property is requested for a variable that is not a struct type

Elements
{
   type: // actual type that the variable is (instead of a struct type)
}

NOT_ARRAY

The error occurs when an index is requested for a variable that is not an array

Elements
{
   type: // actual type that the variable is (instead of an array type)
}

ARRAY_INDEX_TYPE

The error occurs when an index for an array is not a number or symbol

Elements
{
   array: // array type
   index: // supplied index type
}

RETURN_OUTSIDE_FUNCTION

The error occurs when a value statement (return node) is used outside a function

Elements
{
   // empty
}

TYPE_EXPRESSION

The error occurs when an expression has incompatible types

Elements
// left op right
{
    left:
    right:
    op:
}
// op value
{
    value:
    op:
}
// if, while or repeat - aslongas
{
    expression: // expression type
    op: // if, while, repeat
}
// for
{
    expression: // expression type
    op: "for"
    element: // variable, from, to or step
}
// value_of_function
{
    op: "value"
    to: // return type
    from: // provided type
}
// is
{
    op: "is"
    to: // to type
    from: // from type
}
// struct element type is undefined
{
    struct: // struct type,
    element: // name of struct element
}
// variable type is undefined
{
    variable: // name of the variable
}

LEXICAL

This is a lexical error

Elements
{
    line: // the line number
    text: // the text of the error
}

SYNTAX

This is a syntax error

Elements
{
    line: // the line number
    text: // the text of the error
    token: // the token it got
    expected: [] / the list of expected tokens
}

Bonus

For an additional 0.5p, implement find the type of variables that are declared using just an attribution.

Bonus will be awarded only if all other tests pass.

Copying

The homework is individual. Any attempt of copying will result in 0p for the homework. Automated anti copying system will be used.

Questions

If you have any questions related to the homework, please ask them by posting an issue on the github repository with the title format [calculator] <your question title>. You will need a github account for that.

DO NO POST ANY CODE. This is considered copying and will result in a 0p homework for you.

If you want to receive an email when issues are posted or when there are new messages, got to the github repository and click Watch.

Testing

The homework will be tested automatically using a set of public and private tests.

Public Tests

You can download the public tests from the GitHub repository.

To run the tests, download the contents of the repository in the folder with the homework. Enter the verify folder and run ./run_all.sh.

cd verify
./run_all.sh

You will need bash for that. You can use either Linux or Windows Linux Subsystem.

To install nodejs in Linux or Windows Linux Subsystem, do the following:

wget https://nodejs.org/dist/v8.9.4/node-v8.9.4-linux-x64.tar.xz
tar xvfJ node-v8.9.4-linux-x64.tar.xz
cd node-v8.9.4-linux-x64
sudo cp -R * /usr

Private Tests

When uploading the homework, we might have some private tests that it needs to pass. vmchecker will run them.

You may always upload the homework as many times you want until the deadline. This will run all the tests for you and display the result.

Upload the homework

The homework needs to be uploaded to vmchecker. Login with your moodle user name, select the Automates et Langages Formelles (FILS) course and upload the homework archive.

Readme

The readme file has the following format:

Your full name
Group

An explanation how you wrote your homework, what did you use, what are the main ideas.

Homework Archive

To upload your homework, please follow the following:

  1. Create a zip (not rar, ace, 7zip or anything else) archive containing:
    • your main file
    • your javascript files (*.js)
    • the package.json file
    • the Readme file
  2. sign in with vmchecker
  3. select the Automates et Langages Formelles (FILS) course
  4. select 4. Semantic
  5. upload the archive

The archive needs to contain the files in its root, not in a folder. DO NOT archive a folder with those file, archive DIRECTLY those files.

DO NOT include node_modules.

When the archive is uploaded, vmchecker will run:

unzip archive.zip homework
cd homework
npm install
echo '{ "node":true, "esnext":true }' > .jshintrc
jshint *.js
alf/teme/tema4_en.txt · Last modified: 2019/04/29 13:22 by teodor.deaconu
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0