// Input: nothing for default test cases, // copy some comments on this code and paste // into the prompt for some existing tests, // or code a program in my language. // Created for this challenge: // https://www.sololearn.com/post/425935 // Design and Implement a Language // Your task is to design a programming // language. It must support the syntax // needed to create a factorial function // and its call for one to five displaying // the results. You may pick the syntax. // You must parse the user input with // useful error messages on syntax and // semantic issues or, when there was no // input, provide a hard coded factorial // example. If error free, you must // interpret the code to perform the // objective. You must document the // language sufficiently so that I can // write programs and run them to test // your language and its implementation. // I had originally planned on asking // your language be Lisp based like // mine. However, this post convinced // me to open it up to any. // https://www.sololearn.com/post/422640 // Please consider naming your language // and answering this question even if // you decide my request is too difficult. // This is the language I am providing. // In honor of Md Sahil's post, I'm // calling it Welisp. It is loosely based // on Lisp with a '( function arguments // )' syntax. For example: ( var x ( tim // 5 6 ) ) becomes the following in some // common languages: // C, C++, or Java: int x = 5 * 6; // Kotlin: var x = 5 * 6 // Python: x = 5 * 6 // Uppercase is converted to lowercase. // Whitespace is ignored though one is // require to separate two identical tokens. // Program: Statements EOF // Statements: Statement | ( Statements // Statement ) // Statement: '(' Function ')' // Function: ( Predefines | Name ) List // List: Expression | ( List Expression ) // Expression: ( Name | Constant | // Statement ) // Names: Name | ( Names Name ) // Parameters: Name | ( '(' 'prm' Names // ')' ) // Name: [ 'a' - 'z' ] | ( Name // [ 'a' - 'z' ] ) // Predefines: ( 'add' | 'div' | 'equ' | // 'for' | 'fun' | 'grp' | 'grt' | 'gte' | // 'if' | 'lse' | 'lss' | 'neq' | 'nul' | // 'prm' | 'prt' | 'rem' | 'sub' | 'tim' | // 'whl' | 'var' ) // Constant: [ '0' - '9' ] | ( Constant // [ '0' - '9' ] ) // Predefined Syntax: // (add Expression Expression) // Calculate both expressions and return // their sum. // (div Expression Expression) // Calculate both expressions, divide // first expression by second, and // return the result. Abort execution // on divide by zero. // (equ Expression Expression) // Solve both expressions, test both // results for matching and return true // as 1 or false as 0. // (for Name Expression Expression // Statements) // Test name for being a variable, // aborting execution if not, declare // a new nested local scope variable // for name, solve the two expressions, // make a range of them, for all values // in the range, store into name plus // execute all the statements, and // return result of the last. // (fun Name Parameters Statements) // Declare local scope name, execute // parameters, store the statements as // its value, and return 0. // (grp Statements) // Group of statements for if true so // execute statements and return result // of last. // (grt Expression Expression) // Solve both expressions, test first // result for greater than second and // return true as 1 or false as 0. // (gte Expression Expression) // Solve both expressions, test first // result for greater or equal than // second and return true as 1 or false // as 0. // (if Expression Expression Statements) // Execute first expression, if result // is zero, execute the statement, else // execute second expression, and after // executing return the result of the // last expression. // (lse Expression Expression) // Solve both expressions, test first // result for less or equal than second // and return true as 1 or false as 0. // (lss Expression Expression) // Solve both expressions, test first // result for less than second and return // true as 1 or false as 0. // (neq Expression Expression) // Solve both expressions, test both // results for matching and return true // as 0 or false as 1. // (nul) // Return 0. // (prm Names) // Declare names as nested local scope // and return 0. // (prt List) // Display each of the results of the // expressions in the list space separated // followed by a new line and return 0. // (rem Expression Expression) // Calculate both expressions, modulo // first expressions by second and return // the result. // (sub Expression Expression) // Calculate both expressions, subtract // second expressions from first and // return the result. // (tim, Expression, Expression) // Calculate both expressions, times // first expressions by second and return // the result. // (val Name) // Return name's value. // (var Name Expression) // Declare local name, evalulate // expression, assign to name, and return // its value. // (whl Expression Statements) // Calculate the expression & test it for // non zero, if true, execute statements, // repeat until false, and return 0. // Function Call: // (Name List) // Lookup name as function, save the // existing parameter value, store list // of expressions into nested local // parameters, execute the function's // statements value, restore the original // parameter's value, and return the last // expression result. // Factorial code as require by my language: // (fun fac (prm x) // (if (lse x 1) // 1 // (tim x (fac (sub x 1))) // ) // ) // (for x 1 5 // (prt x (fac x)) // ) // Condensed to minimum whitespace: // (fun fac(prm x)(if(equ x1)1(tim x(fac(sub x1)))))(for x1 5(prt x(fac x))) // Enumerate class to specify the type // of token being processed: a name, a // numeric constant, an open parentheses, // a close parentheses, the end of input // or file, or an invalid character that // does not belong to any token so an // error. enum class Token { Name, Constant, Open, Close, EndFile, Error } // Enumerate class to specify the type // of function parameter expected: a // symbolic variable name, a single // expression, a varable list of // expressions, a function name, a // single statement, a variable list // of statements, a single parameter, // or a variable list of parameters. enum class Type { Symbol, Expression, Expressions, Function, Statement, Statements, Parameter, Parameters } // Data class for a function call. // Properties are the symbol name // information of the function and the // list of arguments it was called with. data class Call(val function: Name, val arguments: List) { // Method to generate the display string // of the call for debugging information. override fun toString() = "Call($function"+( if (arguments.size == 0) "" else arguments.joinToString(", ", ", ", transform = { "$it" }))+")" } // Call // Data class for the parameters of a // function. Used to check semantics of // calls. Properties are the name to // declare the local paramter by and // the type expected for it. data class Parameter(val name: String, val type: Type) // Data class to hold the variable to // for the local parameter and its // value before our new call. This // allows recursive calls to update // the same variable. Once the call // exits, the value gets put back. data class Stack( val parameter: Name.Variable, val saved: Int) // Data class to hold the symbol // information for the token returned // by the lexical parsing. Properties are // the token found, the line it was found // on, the column it was found on, and // the actual characters that make it up. data class Symbol(val token: Token, val line: Int, val column: Int, val data: String) // Sealed class to hold a function argument. // There are three possibilities: a // numeric constant, an expression as a // function call, or a variable symbol. sealed class Argument { // Data class to hold the value of the // constant. data class Constant(val value: Int) : Argument() { // Method to generate the display // string of the constant. override fun toString() = "$value" } // Constant // Data class to hold the call of the // expression. data class Expression(val expression: Call) : Argument() { // Method to generate the display // string of the expression. override fun toString() = "$expression" } // Expression // Data class to hold the variable of the // symbol. data class Symbol(val variable: Name) : Argument() { // Method to generate the display // string of the symbol. override fun toString() = "$variable" } // Symbol } // Argument // Sealed class to hold the two name symbol // types: functions and variables. The both // share properties of a name and nesting // scope. sealed class Name(val name: String, val scope: Int) { // Class for the function adding the // unique properties for the list of // parameters to declare and the list // of calls to execute. class Function(name: String, scope: Int, var parameters: List = listOf(), var calls: List = listOf()) : Name(name, scope) // Class for the variable adding the // unique property of its value. class Variable(name: String, scope: Int, var value: Int) : Name(name, scope) // Method to generate the display string // of the name. override fun toString() = "$name" } // Name //========================================== // Class to execute the program. Properties // are the function calls to execute and // debug state (0 for none, 1 for display // each call and its result.) class Execute(val calls: List) { val debug = 0 // Method to handle the add predefine. // (add Expression Expression) // Calculate both expressions and return // their sum. fun add(arguments: List) = value(arguments[0])+value(arguments[1]) // Method to handle the var predefine. // (var Name Expression) // Declare local name, evalulate // expression, assign to name, and return // its value. Abort execution when the // first argument is not a variable. fun declare(arguments: List): Int { val result = value(arguments[1]) val variable = arguments[0] if (variable is Argument.Symbol && variable.variable is Name.Variable) variable.variable.value = result else throw IllegalStateException( "Inconsistant variable!") return result } // declare // Method to handle the div predefine. // (div Expression Expression) // Calculate both expressions, divide // first expression by second, and // return the result. Abort execution // on divide by zero. fun div(arguments: List): Int { val divisor = value(arguments[1]) return ( if (divisor == 0) throw IllegalStateException( "Division by Zero!") else value(arguments[0])/divisor) } // div // Method to handle the equ predefine. // (equ Expression Expression) // Solve both expressions, test both // results for matching and return true // as 1 or false as 0. fun equ(arguments: List) = if (value(arguments[0]) == value(arguments[1])) 1 else 0 // Method to handle the for predefine. // (for Name Expression Expression // Statements) // Test name for being a variable, // aborting execution if not, declare // a new nested local scope variable // for name, solve the two expressions, // make a range of them, for all values // in the range, store into name plus // execute all the statements, and // return result of the last. fun foreach(arguments: List): Int { if (arguments[0] !is Argument.Symbol || (arguments[0] as Argument.Symbol). variable !is Name.Variable) throw IllegalStateException( "Inconsistant variable!") val variable = (arguments[0] as Argument.Symbol).variable as Name.Variable var result = 0 for (index in value(arguments[1]).. value(arguments[2])) { variable.value = index for (call in 3 until arguments.size) result = value(arguments[call]) } // for return result } // foreach // Method to handle the grp predefine. // (grp Statements) // Group of statements for if true so // execute statements and return result // of last. fun grp(arguments: List): Int { var result = 0 for (call in arguments.indices) result = value(arguments[call]) return result } // grp // Method to handle the grt predefine. // (grt Expression Expression) // Solve both expressions, test first // result for greater than second and // return true as 1 or false as 0. fun grt(arguments: List) = if (value(arguments[0]) > value(arguments[1])) 1 else 0 // Method to handle the gte predefine. // (gte Expression Expression) // Solve both expressions, test first // result for greater or equal than // second and return true as 1 or false // as 0. fun gte(arguments: List) = if (value(arguments[0]) >= value(arguments[1])) 1 else 0 // Method to handle the lse predefine. // (lse Expression Expression) // Solve both expressions, test first // result for less or equal than second // and return true as 1 or false as 0. fun lse(arguments: List) = if (value(arguments[0]) <= value(arguments[1])) 1 else 0 // Method to handle the lss predefine. // (lss Expression Expression) // Solve both expressions, test first // result for less than second and return // true as 1 or false as 0. fun lss(arguments: List) = if (value(arguments[0]) < value(arguments[1])) 1 else 0 // Method to handle the neq predefine. // (neq Expression Expression) // Solve both expressions, test both // results for matching and return true // as 0 or false as 1. fun neq(arguments: List) = if (value(arguments[0]) != value(arguments[1])) 1 else 0 // Method to execute a statement. If the // call is for a predefine, call the // method to handle it. Three do not // execute so just return their result // of zero. Otherwise, if the call is // for a user defined function, they // all get treated the same. To create a // new predefined, it must be added here // and in the parser class. fun process(call: Call): Int { with (call) { val result = when (function.name) { "add" -> add(arguments) "div" -> div(arguments) "equ" -> equ(arguments) "for" -> foreach(arguments) "fun" -> 0 "grp" -> grp(arguments) "grt" -> grt(arguments) "gte" -> gte(arguments) "if" -> test(arguments) "lse" -> lse(arguments) "lss" -> lss(arguments) "neq" -> neq(arguments) "nul" -> 0 "prm" -> 0 "prt" -> prt(arguments) "rem" -> rem(arguments) "sub" -> sub(arguments) "tim" -> tim(arguments) "val" -> value(arguments[0]) "var" -> declare(arguments) "whl" -> whl(arguments) else -> user(function, arguments) } // when if (debug == 1) println("${function.name} -> $result") return result } // with } // process // Method to handle the prt predefine. // (prt List) // Display each of the results of the // expressions in the list space separated // followed by a new line and return 0. fun prt(arguments: List): Int { var result = "" for (argument in arguments) result += "${value(argument)} " println(result) return 0 } // prt // Method to handle the rem predefine. // (rem Expression Expression) // Calculate both expressions, modulo // first expression by second, and // return the result. Abort execution // on divide by zero. fun rem(arguments: List): Int { val divisor = value(arguments[1]) return ( if (divisor == 0) throw IllegalStateException( "Division by Zero!") else value(arguments[0])%divisor) } // rem // Method to execute the program. Process // each call and display our sucessful // completion. On exception, abort the // execution and complain about our crash. fun run() { try { for (call in calls) process(call) println( "Program Completed Successfully!") } catch (error: Throwable) { error.printStackTrace() println("Program Crashed!") } } // run // Method to handle the sub predefine. // (sub Expression Expression) // Calculate both expressions, subtract // second expressions from first and // return the result. fun sub(arguments: List) = value(arguments[0])-value(arguments[1]) // Method to handle the if predefine. // (if Expression Expression Statements) // Execute first expression, if result // is zero, execute the statements, else // execute second expression, and after // executing return the result of the // last expression. fun test(arguments: List): Int { var result = 0 if (value(arguments[0]) == 0) for (call in 2 until arguments.size) result = value(arguments[call]) else result = value(arguments[1]) return result } // test // Method to handle the tim predefine. // (tim, Expression, Expression) // Calculate both expressions, times // first expressions by second and // return the result. fun tim(arguments: List) = value(arguments[0])*value(arguments[1]) // Method to handle user defined functions. fun user(called: Name, arguments: List): Int { var stack = mutableListOf() var result = 0 // Function to save our existing // parameter's value and update it // to our argument's. Abort our // execution on mismatch of parameter // verus argument or functions being // used instead of variables. fun save(call: Call) { val args = call.arguments for (index in args.indices) if (index !in arguments.indices) throw IllegalStateException( "Inconsistant function!") else if (args[index] is Argument.Symbol) { val variable = (args[index] as Argument.Symbol).variable if (variable is Name.Variable) { stack.add(Stack(variable, variable.value)) variable.value = value(arguments[index]) } else throw IllegalStateException( "Inconsistant function!") } else throw IllegalStateException( "Inconsistant function!") } // save // Function to return our original // parameter's value. fun restore() { for (element in stack) element.parameter.value = element.saved } // restore // If we got a function, save the old // parameter values, update them to our // arguments, call all of the statements // of our function, and restore our // original parameter's value. Abort // execution on finding a variable // instead of a function. if (called is Name.Function) { val calls = called.calls save(calls[0]) for (call in 1 until calls.size) result = process(calls[call]) restore() } else throw IllegalStateException( "Inconsistant function!") return result } // user // Method to evalulate an argument. // Return the constant's value, the // variable's valuem or the result // from processing the call. Abort // execution, if a function was used // as a variable. fun value(argument: Argument) = when (argument) { is Argument.Constant -> argument.value is Argument.Symbol -> { val value = argument.variable if (value is Name.Variable) value.value else throw IllegalStateException( "Inconsistant variable!") } // Symbol is Argument.Expression -> { val call = argument.expression process(call) } // Expression } // when // Method to handle the whl predefine. // (whl Expression Statements) // Calculate the expression & test it for // non zero, if true, execute statements, // repeat until false, and return 0. fun whl(arguments: List): Int { while (value(arguments[0]) != 0) for (call in 1 until arguments.size) value(arguments[call]) return 0 } // whl } // Execute //========================================== // Class to parse the program, generate the // function calls, and, if the program is // valid, execute it. Properties are // broken up internally. class Parser { // Declare the current line number, // column number, and line. var lineNumber = 0 var columnNumber = 0 var currentLine = "" // Declare the current symbol and previous // one. var symbol = Symbol(Token.EndFile, lineNumber, columnNumber, "") var previous = Symbol(Token.EndFile, lineNumber, columnNumber, "") // Declare the current nesting scope // and the list of accessible names. // Once the scope ends the names are // removed, but calls will still // have references to them. var scope = 0 val names = mutableListOf() // The input is from the console or // that was not valid so use the fixed // code. Display debugging information. // 1 enables lexical debugging. 2 // enables expression debugging. 4 // enables statement debugging. 8 // enables program calls debugging. // 15 enables everything, but timeout // is likely. Add those you want // together. The program has generated // an error due to syntax or semantic // error so abort parsing. var console = true val debug = 0 var badSyntax = false // Constructor to declare the predefines. // See language definition for more // details. To create a new one, it // must be added here and in the execute // class. init { names.add(Name.Function("add", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("div", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("equ", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("for", scope, listOf( Parameter("index", Type.Symbol), Parameter("start", Type.Expression), Parameter("end", Type.Expression), Parameter("statements", Type.Statements)))) names.add(Name.Function("fun", scope, listOf( Parameter("name", Type.Function), Parameter("parameters", Type.Parameter), Parameter("statements", Type.Statements)))) names.add(Name.Function("grp", scope, listOf( Parameter("statements", Type.Statements)))) names.add(Name.Function("grt", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("gte", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("if", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression), Parameter("statements", Type.Statements)))) names.add(Name.Function("lse", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("lss", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("neq", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("nul", scope, listOf())) names.add(Name.Function("prm", scope, listOf( Parameter("parameters", Type.Parameters)))) names.add(Name.Function("prt", scope, listOf( Parameter("arguments", Type.Expressions)))) names.add(Name.Function("rem", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("sub", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("tim", scope, listOf( Parameter("first", Type.Expression), Parameter("second", Type.Expression)))) names.add(Name.Function("whl", scope, listOf( Parameter("condition", Type.Expression), Parameter("statements", Type.Statements)))) names.add(Name.Function("val", scope, listOf( Parameter("name", Type.Symbol)))) names.add(Name.Function("var", scope, listOf( Parameter("name", Type.Symbol), Parameter("value", Type.Expression)))) } // init // Method to return the next line of // input. fun getNextLine() { // Increment to the next line and zero // our column. If we are performing // console input, get the next line. lineNumber++ columnNumber = 0 if (console) // If this is the first line, we want // to allow the user to select our // fixed test program. If you don't // type anything to the input prompt // and hit the submit button, you get // a zero length string for the first // line and null in place of the // second. The skipping white space // will recall this method generating // an exception on seeing the null. // We will catch it so the fixed test // can be used. Reset the state // information so it is as if the code // never read anything by turning off // the console, putting the first // fixed line into the current line, // and update the line & column // numbers. As a side effect, you may // put as many spaces or lines in at // the prompt and still get the fixed // code. if (lineNumber == 1) try { currentLine = readLine()!! skipWhiteSpace() } catch (error: Throwable) { console = false currentLine = "(fun fac (prm x)" lineNumber = 1 columnNumber = 0 } // try else currentLine = readLine()!! // Otherwise, read the next line. // Note, this is where the null // exception is generated to be // caught in the above code. If we // actually get our code from the // console, the exception will be // turned into the end of input // token. else when (lineNumber) { 1 -> currentLine = "(fun fac (prm x)" 2 -> currentLine = " (if (lse x 1)" 3 -> currentLine = " 1" 4 -> currentLine = " (tim x (fac (sub x1)))" 5 -> currentLine = " )" 6 -> currentLine = ")" 7 -> currentLine = "(for x 1 5" 8 -> currentLine = " (prt x (fac x))" 9 -> currentLine = ")" else -> throw NullPointerException( "End of file!") } // when } // getNextLine // Method to skip any white space, fun skipWhiteSpace() { // While we found a space, keep reading // lines to find the first non-space // character. var char = ' ' do { // If we haven't read a line as yet // or we finished the current line, // get the next line. Otherwise, get // the next column. if (lineNumber == 0 || columnNumber > currentLine.length) getNextLine() else columnNumber++ // If the column number minus one is // valid for the line, get it's // character. Otherwise, just use a // space. This allows empty lines // to be returned without causing an // exception. char = if (columnNumber > 0 && columnNumber <= currentLine.length) currentLine[columnNumber-1] else ' ' } while (char == ' ') } // skipWhiteSpace // Method to generate our tokens. fun getNextSymbol(): Symbol { // Save the previous symbol so it can // be used for error reporting. Set // up to catch the null exception for // end of input. previous = symbol try { // Skip any white space (spaces or // end of lines) to get the first // character of the next symbol. // Based on that character, process // the symbol. skipWhiteSpace() when (currentLine[columnNumber-1]) { // When the character is alphabetic, // get the variable, function, or // predefined name. Save the start // and move over all alphabetic // characters. Don't really need // the end variable, but it makes // the code fit the phone screen // better. The important part is // moving the column number pass // the name. Grab the name and // lowercase it, set the token to // a name. in 'a'..'z', in 'A'..'Z' -> { val start = columnNumber-1 var end = start while (end != currentLine.length && (currentLine[end] in 'a'..'z' || currentLine[end] in 'A'..'Z')) end++ columnNumber = end symbol = Symbol(Token.Name, lineNumber, start+1, currentLine.substring( start, end).toLowerCase()) } // Name // When the character is a digit, // get the integer. Save the start // and move over all digits or // first period characters. Same // end variable comment applies // here. Allocate the symbol. in '0'..'9' -> { val start = columnNumber-1 var end = start while (end != currentLine.length && currentLine[end] in '0'..'9') { end++ } // while columnNumber = end val number = currentLine.substring( start, end) symbol = Symbol(Token.Constant, lineNumber, start+1, number) } // Number // When the character is the open // parentheses, generate its symbol. '(' -> symbol = Symbol(Token.Open, lineNumber, columnNumber, "${currentLine[columnNumber-1]}") // When the character is the close // parentheses, generate its symbol. ')' -> symbol = Symbol(Token.Close, lineNumber, columnNumber, "${currentLine[columnNumber-1]}") // Otherwise, the character isn't // valid so generate the error // symbol. else -> symbol = Symbol(Token.Error, lineNumber, columnNumber, "${currentLine[columnNumber-1]}") } // when // On exception, generate the end of // input symbol. This is expected to be // the null for end of file, but treat // all exceptions this way. } catch (error: Throwable) { symbol = Symbol(Token.EndFile, lineNumber, columnNumber, "[EOF]") } // try // If we want the debug the tokens, // display them. In either case, return // our token. if (debug%2 == 1) println(symbol) return symbol } // getNextSymbol // Method to output an error message. // Complain about the error that // terminated our run. Set the fact that // an error occurred to allow the // processing to abort. fun syntaxError(error: Int, symbol: Symbol, expected: String) { println("Invalid program at Line:"+ "${symbol.line} & Column:"+ "${symbol.column}!") println(currentLine) println(" ".repeat(symbol.column-1)+'^') println("Error code: %02d".format(error)) println("Expecting $expected!") println("Found '${symbol.data}'.") badSyntax = true } // syntaxError // Method to parse an expression verifying // it matches the expected argument type. fun expression(parameter: Parameter): Argument = // When we got an open parentheses, // it appears we have a statement // starting so see if we can use it. when (symbol.token) { Token.Open -> // When we expected a // variable, complain and // return the easiest argument // to create. when (parameter.type) { Type.Symbol -> { syntaxError(1, symbol, "variable") Argument.Constant(0) } // Symbol // When we expected a // function, complain and // return the easiest argument // to create. Type.Function -> { syntaxError(2, symbol, "function") Argument.Constant(0) } // Function // When we were expecting an // expression, statement or // parameter, a statement is // acceptable so process it // and make an argument out // of its call to return. else -> Argument.Expression(statement()) } // when // When we have a name, see if we can // use it. Token.Name -> // When we expected a // statement, complain and // return the easiest argument // to create. when (parameter.type) { Type.Statement, Type.Statements -> { syntaxError(3, symbol, "statement") Argument.Constant(0) } // Statement // When we are expecting a // variable name, check it out. // Get the name used, get the // next token, filter our names // for only that name within // our scope, and select the // last. If none were left, // created a new variable and // return it. Otherwise, if a // existing variable was found, // return it. Otherwise, // complain and return the // easiest argument to create. Type.Symbol, Type.Parameter, Type.Parameters -> { val name = symbol.data getNextSymbol() val variable = names.filter { it.name == name && it.scope <= scope }. lastOrNull() if (variable == null) { val new = Name.Variable( name, scope, 0) names.add(new) Argument.Symbol(new) } else if (variable is Name.Variable) Argument.Symbol(variable) else { syntaxError(4, symbol, "undeclared name") Argument.Constant(0) } // if } // Symbol // When we are expecting a new // function name, check it out. // Get the name used, get the // next token, filter our names // for only that name within // our scope, and select the // last. If none were left, // created a new function and // return it. Otherwise, // complain and return the // easiest argument to create. Type.Function -> { val name = symbol.data getNextSymbol() val temp = names.filter { it.name == name && it.scope < scope }. lastOrNull() if (temp == null) { val new = Name.Function( name, scope-1) names.add(new) Argument.Symbol(new) } else { syntaxError(5, symbol, "undeclared name") Argument.Constant(0) } // if } // Function // When we expected an // expression, a variable is // allowed so check it out. // Get the name used, filter // our names for only that // name within our scope // declared as a variable, // and select the last. If // none were left, complain and // return the easiest argument // to create. Otherwise, get // the next token and return // the variable. else -> { val name = symbol.data val old = names.filter { it.name == name && it.scope <= scope && it is Name.Variable }. lastOrNull() if (old == null) { syntaxError(6, symbol, "declared variable") Argument.Constant(0) } else { getNextSymbol() Argument.Symbol(old) } // if } // else } // when // When we have constant, see if // we can use it. Token.Constant -> when (parameter.type) { // When we expected a // variable, complain and // return the easiest argument // to create. Type.Symbol -> { syntaxError(7, symbol, "varable") Argument.Constant(0) } // Symbol // When we expected a // function, complain and // return the easiest argument // to create. Type.Function -> { syntaxError(8, symbol, "function") Argument.Constant(0) } // Function // When we expected a // statement, complain and // return the easiest argument // to create. Type.Statement, Type.Statements -> { syntaxError(9, symbol, "statement") Argument.Constant(0) } // Statement // When we expected a // parameter, complain and // return the easiest argument // to create. Type.Parameter, Type.Parameters -> { syntaxError(10, symbol, "parameter") Argument.Constant(0) } // Parameter // When we expected an // expression, constants are // allowed so get the next // token and return our // constant. else -> { val value = symbol.data.toInt() getNextSymbol() Argument.Constant(value) } // else } // when // Otherwise, we got a token that // can not be used so complain // and return the easiest argument // to create. else -> { syntaxError(11, symbol, "expression") Argument.Constant(0) } // else } // when // Method to parse a list of expressions. fun expressions( parameters: List): List { // Function to update a user defined // function's list of parameters. These // are used to match any call to the // definition during our parsing. fun update( arguments: MutableList) { // If the first argument is a name // for the function and the second is // a name or expression for the // parameters, see about updating // the parameter list of the function. if (arguments[0] is Argument.Symbol && arguments[1] is Argument.Symbol || arguments[1] is Argument.Expression) { // Get the function and parameters. // If the function was declare // as a function, we are good to // deal with the parameters. val function = (arguments[0] as Argument.Symbol).variable val parameter = arguments[1] if (function is Name.Function) // If the parameter is a single // variable, make a list of it // and store it in the function. // User defines only support // expressions as arguments. if (parameter is Argument.Symbol && parameter.variable is Name.Variable) function.parameters = listOf( Parameter(parameter.variable. name, Type.Expression)) // Otherwise, if we got an // expression, it should be a // prm predefined call with a // list of names. else if (parameter is Argument.Expression) { // Get the call and define our // empty list. For each // argument of the call, if // it is a variable, add it // to the list. Otherwise, // complain and abort the // loop. Once done, store the // list in the function. val call = parameter.expression val list = mutableListOf< Parameter>() for (argument in call.arguments) if (argument is Argument.Symbol && argument.variable is Name.Variable) list.add(Parameter( argument.variable.name, Type.Expression)) else { syntaxError(12, symbol, "parameter") break } // if function.parameters = list.toList() // Otherwise, complain. } else syntaxError(13, symbol, "function") // Otherwise, complain. } else syntaxError(14, symbol, "parameter") } // update // If we are debugging this method // level, state we entered here. if (debug/2%2 == 1) println("() var index = 0 do { // If we are debugging this method // level, state we entered // expression, call it, and state // we exited it. Otherwise, just // call it. if (debug/2%2 == 1) println("") // Add the argument to the list. If // the expected type is a single, // we need to move to the next one. // If we have two arguments and // this one is a parameter, we // have a user defined function // definition so update its parameter // list. Increment to the next // parameter type. If there was no // error so far, we finished them // all, and we have more arguments, // complain. arguments.add(argument) when (parameters[index].type) { Type.Symbol, Type.Function, Type.Expression, Type.Parameter, Type.Statement -> { if (parameters[index].type == Type.Parameter && arguments.size == 2) update(arguments) index++ if (!badSyntax && index == parameters.size && symbol.token != Token.Close) syntaxError(15, symbol, "less arguments") } // type } // when } while (!badSyntax && symbol.token != Token.Close) // If we have not found an error and // we have not matched the last // expected type and that type is // not optional, complain. if (!badSyntax && index != parameters.size && parameters[index].type !in listOf( Type.Expressions, Type.Statements, Type.Parameters)) syntaxError(16, symbol, "more arguments") // If we are debugging this method // level, state we exited here. In // either case, return our list of // arguments. if (debug/2%2 == 1) println("expressions ${arguments}>") return arguments.toList() } // expressions // Method to parse a statement. fun statement(): Call { // Function to update the calls for a // user defined function. These are // used to execute the call during // our execution. fun update(function: Name.Function, arguments: List) { // Declare an empty list for the // calls. For the arguments skipping // the function, put the calls into // the list. val calls = mutableListOf() for (index in 1 until arguments.size) // If the argument is already a // call, add it to the list. if (arguments[index] is Argument.Expression) calls.add((arguments[index] as Argument.Expression).expression) // Otherwise, if this is the first // argument, it should be a single // parameter so verify it is a // variable. If so, lookup the // prm predefine so we can make a // call with it. If we found it, // add the call with the single // parameter to our list. // Otherwise, if not found, // complain. else if (index == 1 && arguments[1] is Argument.Symbol) { val prm = names.filter { it.name == "prm" && it.scope == 0 }.firstOrNull() if (prm != null) calls.add(Call(prm, listOf(arguments[1]))) else syntaxError(17, symbol, "parameter") // Otherwise, we must have a // parameter so complain. } else syntaxError(18, symbol, "parameter") // Store the calls in the function. function.calls = calls.toList() } // update // If we are debugging this method // level, state we entered here. if (debug/4%2 == 1) println("()) if (symbol.token == Token.Open) { // Get our next token and if it is // a name, we can continue. getNextSymbol() if (symbol.token == Token.Name) { // Filter our names to functions // matching the name we just got // within our scope and get the // last one. If it is null, complain // about missing predefine or // function. val function = names.filter { symbol.data == it.name && it.scope <= scope && it is Name.Function }.lastOrNull() if (function == null || function !is Name.Function) syntaxError(19, symbol, "defined function") // Otherwise, we have a function so // process it. else { // If the function is a for or // fun call, increment our scope. // In either case, get our next // token. if (function.name in listOf( "for", "fun")) scope++ getNextSymbol() // If the function has parameters, // parse them. Parse the // expressions making up the call // and update our return call. // If we have not seen an error // and we have a valid function // definition, get the name and // add its calls. Otherwise, // complain about the invalid // function. if (function.parameters.size > 0) { result = Call(function, expressions( function.parameters)) if (!badSyntax && function.name == "fun" && result.arguments[0] is Argument.Symbol) { val new = (result.arguments[0] as Argument.Symbol).variable if (new is Name.Function) update(new, result.arguments) else syntaxError(20, symbol, "function") } // if // Otherwise, create its call. } else result = Call(function, listOf()) // If we got our close // parentheses, get our next // token. Otherwise, if we have // not seen an error, complain. if (symbol.token == Token.Close) getNextSymbol() else if (!badSyntax) syntaxError(21, symbol, "')'") // If a new scope was created, // delete any names in that // scope and decrement it. if (function.name in listOf( "for", "fun")) { names.removeAll { it.scope == scope } scope-- } // if } // if // Otherwise, complain about missing // predefine or function. } else syntaxError(22, symbol, "defined function") // Otherwise, complain about missing // open parentheses. } else syntaxError(23, symbol, "'('") // If we are debugging this method // level, state we exited here. In // either case, return our call. if (debug/4%2 == 1) println("statement ${result}>") return result } // statement // Method to parse a list of statements. fun statements(): List { // If we are debugging this method // level, state we entered here. if (debug/4%2 == 1) println("() do { calls.add(statement()) } while (!badSyntax && symbol.token == Token.Open) // If we are debugging this method // level, state we exiting here. if (debug/4%2 == 1) println("statements $calls>") // Return the list of calls we found. return calls.toList() } // statements // Method to parse the program and execute // it when error free. fun program() { // If we are debugging this method // level, state we entered here. if (debug/4%2 == 1) println("") } // program } // Parser // Main function to create our parser and // start processing the program. fun main(args: Array) { Parser().program() } // main

welisp ch