diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 79b95c4a95..311ae6d01d 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -18,10 +18,10 @@ // Add the IDs of extensions you want installed when the container is created. "extensions": [ - "matklad.rust-analyzer", "bungcip.better-toml", "vadimcn.vscode-lldb", - "mutantdino.resourcemonitor" + "mutantdino.resourcemonitor", + "rust-lang.rust-analyzer" ], // Use 'forwardPorts' to make a list of ports inside the container available locally. diff --git a/Cargo.lock b/Cargo.lock index 84604ca2f1..cae7820359 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -82,16 +82,16 @@ dependencies = [ [[package]] name = "clap" -version = "3.1.18" +version = "3.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b" +checksum = "190814073e85d238f31ff738fcb0bf6910cedeb73376c87cd69291028966fd83" dependencies = [ "atty", "bitflags", "clap_derive", "clap_lex", "indexmap", - "lazy_static", + "once_cell", "strsim", "termcolor", "textwrap", @@ -99,9 +99,9 @@ dependencies = [ [[package]] name = "clap_derive" -version = "3.1.18" +version = "3.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25320346e922cffe59c0bbc5410c8d8784509efb321488971081313cb1e1a33c" +checksum = "759bf187376e1afa7b85b959e6a664a3e7a95203415dba952ad19139e798f902" dependencies = [ "heck", "proc-macro-error", @@ -112,9 +112,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.2.0" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213" +checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5" dependencies = [ "os_str_bytes", ] @@ -160,9 +160,9 @@ checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" [[package]] name = "either" -version = "1.6.1" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" +checksum = "3f107b87b6afc2a64fd13cac55fe06d6c8859f12d4b14cbcdd2c67d0976781be" [[package]] name = "encode_unicode" @@ -211,9 +211,9 @@ checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" [[package]] name = "hashbrown" -version = "0.11.2" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" +checksum = "db0d4cf898abf0081f964436dc980e96670a0f36863e4b83aaacdb65c9d7ccc3" [[package]] name = "heck" @@ -232,9 +232,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "1.8.2" +version = "1.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6012d540c5baa3589337a98ce73408de9b5a25ec9fc2c6fd6be8f0d39e0ca5a" +checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e" dependencies = [ "autocfg", "hashbrown", @@ -243,7 +243,7 @@ dependencies = [ [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/TheDan64/inkwell?branch=master#7253f9250d8a5e5e83125f1f6f85ba8b80d12acc" +source = "git+https://github.com/TheDan64/inkwell?branch=master#25b9fc5870370211504e874e7c81dc53573bca79" dependencies = [ "either", "inkwell_internals", @@ -256,7 +256,7 @@ dependencies = [ [[package]] name = "inkwell_internals" version = "0.5.0" -source = "git+https://github.com/TheDan64/inkwell?branch=master#7253f9250d8a5e5e83125f1f6f85ba8b80d12acc" +source = "git+https://github.com/TheDan64/inkwell?branch=master#25b9fc5870370211504e874e7c81dc53573bca79" dependencies = [ "proc-macro2", "quote", @@ -265,9 +265,9 @@ dependencies = [ [[package]] name = "insta" -version = "1.14.1" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bcc3e639bcba360d9237acabd22014c16f3df772db463b7446cd81b070714767" +checksum = "4126dd76ebfe2561486a1bd6738a33d2029ffb068a99ac446b7f8c77b2e58dbc" dependencies = [ "console", "once_cell", @@ -297,14 +297,14 @@ checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836" [[package]] name = "linked-hash-map" -version = "0.5.4" +version = "0.5.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3" +checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f" [[package]] name = "lld_rs" version = "130.0.0" -source = "git+https://github.com/ghaith/lld-rs?tag=v130.0.0#8e7fe8a475c7dff332232aa816e4e41b33f0e553" +source = "git+https://github.com/mun-lang/lld-rs?branch=main#acc3ec6b53344417b4f87cd91c510582bfad4111" dependencies = [ "cc", "lazy_static", @@ -338,18 +338,18 @@ dependencies = [ [[package]] name = "logos" -version = "0.12.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "427e2abca5be13136da9afdbf874e6b34ad9001dd70f2b103b083a85daa7b345" +checksum = "bf8b031682c67a8e3d5446840f9573eb7fe26efe7ec8d195c9ac4c0647c502f1" dependencies = [ "logos-derive", ] [[package]] name = "logos-derive" -version = "0.12.0" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56a7d287fd2ac3f75b11f19a1c8a874a7d55744bd91f7a1b3e7cf87d4343c36d" +checksum = "a1d849148dbaf9661a6151d1ca82b13bb4c4c128146a88d05253b38d4e2f496c" dependencies = [ "beef", "fnv", @@ -357,7 +357,6 @@ dependencies = [ "quote", "regex-syntax", "syn", - "utf8-ranges", ] [[package]] @@ -393,9 +392,9 @@ dependencies = [ [[package]] name = "num-complex" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97fbc387afefefd5e9e39493299f3069e14a140dd34dc19b4c1c1a8fddb6a790" +checksum = "7ae39348c8bc5fbd7f40c727a9925f03517afd2ab27d46702108b6a7e5414c19" dependencies = [ "num-traits", ] @@ -423,9 +422,9 @@ dependencies = [ [[package]] name = "num-rational" -version = "0.4.0" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a" +checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" dependencies = [ "autocfg", "num-bigint", @@ -533,18 +532,18 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.39" +version = "1.0.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c54b25569025b7fc9651de43004ae593a75ad88543b17178aa5e1b9c4f15f56f" +checksum = "dd96a1e8ed2596c337f8eae5f24924ec83f5ad5ab21ea8e455d3566c69fbcaf7" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.18" +version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1feb54ed693b93a84e14094943b84b7c4eae204c512b7ccb95ab0c66d278ad1" +checksum = "3bcdf212e9776fbcb2d23ab029360416bb1706b1aea2d1a5ba002727cbcab804" dependencies = [ "proc-macro2", ] @@ -668,9 +667,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.81" +version = "1.0.82" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b7ce2b32a1aed03c558dc61a5cd328f15aff2dbc17daad8fb8af04d2100e15c" +checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7" dependencies = [ "itoa", "ryu", @@ -697,9 +696,9 @@ checksum = "2e24979f63a11545f5f2c60141afe249d4f19f84581ea2138065e400941d83d3" [[package]] name = "smallvec" -version = "1.8.0" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83" +checksum = "2fd0db749597d91ff862fd1d55ea87f7855a744a8425a64695b6fca237d1dad1" [[package]] name = "strsim" @@ -709,9 +708,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623" [[package]] name = "syn" -version = "1.0.96" +version = "1.0.98" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0748dd251e24453cb8717f0354206b91557e4ec8703673a4b30208f2abaf1ebf" +checksum = "c50aef8a904de4c23c788f104b7dddc7d6f79c647c7c8ce4cc8f73eb0ca773dd" dependencies = [ "proc-macro2", "quote", @@ -791,9 +790,9 @@ checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c" [[package]] name = "unicode-ident" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee" +checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c" [[package]] name = "unicode-width" @@ -801,12 +800,6 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973" -[[package]] -name = "utf8-ranges" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba" - [[package]] name = "version_check" version = "0.9.4" diff --git a/Cargo.toml b/Cargo.toml index 1320523dca..b1e0f9de1e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,10 @@ license = "LGPL-3.0-or-later" keywords = ["iec61131", "st", "Structued_Text"] categories = ["development-tools::build-utils"] +[features] +default = [] +debug = [] + [dependencies] logos = "0.12.0" inkwell = { git = "https://github.com/TheDan64/inkwell", branch = "master", features= ["llvm13-0"] } @@ -20,7 +24,7 @@ glob = "0.3.0" encoding_rs = "0.8" encoding_rs_io = "0.1" codespan-reporting = "0.11.1" -lld_rs = { git = "https://github.com/ghaith/lld-rs", tag = "v130.0.0" } +lld_rs = { git = "https://github.com/mun-lang/lld-rs", branch = "main"} generational-arena = "0.2.8" regex = "1" serde = { version = "1.0", features = ["derive"] } diff --git a/examples/hw.st b/examples/hw.st deleted file mode 100644 index f4e0b913fe..0000000000 --- a/examples/hw.st +++ /dev/null @@ -1,7 +0,0 @@ -PROGRAM foo - VAR - x AT %Q* : INT; - y AT %QW1 : INT; - z AT %IW1.1 : INT; - END_VAR -END_PROGRAM diff --git a/src/ast.rs b/src/ast.rs index d0ff64066e..fcf9adfab2 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -1,5 +1,8 @@ // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder -use crate::{lexer::IdProvider, typesystem::DataTypeInformation}; +use crate::{ + lexer::IdProvider, + typesystem::{DataTypeInformation, VOID_TYPE}, +}; use serde::{Deserialize, Serialize}; use std::{ fmt::{Debug, Display, Formatter, Result}, @@ -494,6 +497,7 @@ pub enum DataType { }, VarArgs { referenced_type: Option>, + sized: bool, //If the variadic has the sized property }, GenericType { name: String, @@ -525,7 +529,12 @@ impl DataType { | DataType::StringType { name, .. } | DataType::SubRangeType { name, .. } => name.as_ref().map(|x| x.as_str()), DataType::GenericType { name, .. } => Some(name.as_str()), - DataType::VarArgs { .. } => None, + DataType::VarArgs { + referenced_type, .. + } => referenced_type + .as_ref() + .and_then(|it| DataTypeDeclaration::get_name(it.as_ref())) + .or(Some(VOID_TYPE)), } } @@ -1239,8 +1248,8 @@ pub fn get_enum_element_name(enum_element: &AstStatement) -> String { /// flattens expression-lists and MultipliedStatements into a vec of statements. /// It can also handle nested structures like 2(3(4,5)) -pub fn flatten_expression_list(condition: &AstStatement) -> Vec<&AstStatement> { - match condition { +pub fn flatten_expression_list(list: &AstStatement) -> Vec<&AstStatement> { + match list { AstStatement::ExpressionList { expressions, .. } => expressions .iter() .by_ref() @@ -1254,7 +1263,7 @@ pub fn flatten_expression_list(condition: &AstStatement) -> Vec<&AstStatement> { .take(*multiplier as usize) .flatten() .collect(), - _ => vec![condition], + _ => vec![list], } } diff --git a/src/ast/pre_processor.rs b/src/ast/pre_processor.rs index a5b52de285..3247383961 100644 --- a/src/ast/pre_processor.rs +++ b/src/ast/pre_processor.rs @@ -322,6 +322,10 @@ fn replace_generic_type_name(dt: &mut DataTypeDeclaration, generics: &HashMap replace_generic_type_name(referenced_type.as_mut(), generics), _ => {} }, diff --git a/src/builtins.rs b/src/builtins.rs index 934c82ebc9..b748be5c1d 100644 --- a/src/builtins.rs +++ b/src/builtins.rs @@ -1,14 +1,18 @@ use std::collections::HashMap; -use inkwell::values::{BasicValue, BasicValueEnum}; +use inkwell::{ + basic_block::BasicBlock, + values::{BasicValue, BasicValueEnum, IntValue}, +}; use lazy_static::lazy_static; use crate::{ ast::{AstStatement, CompilationUnit, LinkageType, SourceRange}, - codegen::generators::expression_generator::ExpressionCodeGenerator, + codegen::generators::expression_generator::{self, ExpressionCodeGenerator}, diagnostics::Diagnostic, lexer::{self, IdProvider}, parser, + resolver::TypeAnnotator, }; // Defines a set of functions that are always included in a compiled application @@ -17,12 +21,13 @@ lazy_static! { ( "ADR", BuiltIn { - decl: "FUNCTION ADR : LWORD + decl: "FUNCTION ADR : LWORD VAR_INPUT - in : T; + in : U; END_VAR END_FUNCTION ", + annotation: None, code: |generator, params, location| { if let [reference] = params { generator @@ -40,12 +45,13 @@ lazy_static! { ( "REF", BuiltIn { - decl: "FUNCTION REF : REF_TO T + decl: "FUNCTION REF : REF_TO U VAR_INPUT - in : T; + in : U; END_VAR END_FUNCTION ", + annotation: None, code: |generator, params, location| { if let [reference] = params { generator @@ -59,17 +65,123 @@ lazy_static! { } } }, + ), + ( + "MUX", + BuiltIn { + decl: "FUNCTION MUX : U + VAR_INPUT + K : DINT; + args : {sized} U...; + END_VAR + END_FUNCTION + ", + annotation : None, + code: |generator, params, location| { + let llvm = generator.llvm; + let context = llvm.context; + let builder = &llvm.builder; + + let function_context = generator.get_function_context(params.get(0).expect("Param 0 exists"))?; + let insert_block = builder.get_insert_block().expect("Builder should have a block at this point"); + + //Generate an access from the first param + if let (&[k], params) = params.split_at(1) { + //Create a temp var + let result_type = params.get(0) + .ok_or_else(|| Diagnostic::codegen_error("Invalid signature for MUX", location)) + .and_then(|it| generator.get_type_hint_info_for(it)) + .and_then(|it| generator.llvm_index.get_associated_type(it.get_name()))?; + let result_var = generator.llvm.create_local_variable("", &result_type); + let k = generator.generate_expression(k)?; + + let mut blocks = vec![]; + for it in params.iter() { + let block = context.append_basic_block(function_context.function, ""); + blocks.push((*it,block)) + } + let continue_block = context.append_basic_block(function_context.function, "continue_block"); + + let cases = blocks.into_iter().enumerate().map::, _>(|(index, (it, block))| { + let value = context.i32_type().const_int(index as u64, false); + builder.position_at_end(block); + let expr = generator.generate_expression(it)?; + builder.build_store(result_var, expr); + builder.build_unconditional_branch(continue_block); + Ok((value,block)) + }).collect::,_>>()?; + builder.position_at_end(insert_block); + builder.build_switch(k.into_int_value(), continue_block, &cases); + builder.position_at_end(continue_block); + let result_var = builder.build_load(result_var, ""); + Ok(result_var) + } else { + Err(Diagnostic::codegen_error("Invalid signature for MUX", location)) + } + + + } + }, + ), + ( + "SEL", + BuiltIn { + decl: "FUNCTION SEL : U + VAR_INPUT + G : BOOL; + IN0 : U; + IN1 : U; + END_VAR + END_FUNCTION + ", + annotation: None, + code: |generator, params, location| { + if let &[g,in0,in1] = params { + //Evaluate the parameters + let cond = expression_generator::to_i1(generator.generate_expression(g)?.into_int_value(), &generator.llvm.builder); + let in0 = generator.generate_expression(in0)?; + let in1 = generator.generate_expression(in1)?; + //Generate an llvm select instruction + Ok(generator.llvm.builder.build_select(cond, in1, in0, "")) + } else { + Err(Diagnostic::codegen_error("Invalid signature for SEL", location)) + } + + } + } + ), + ( + "MOVE", + BuiltIn { + decl : "FUNCTION MOVE : U + VAR_INPUT + in : U; + END_VAR + END_FUNCTION", + annotation: None, + code : |generator, params, location| { + if params.len() == 1 { + generator.generate_expression(params[0]) + } else { + Err(Diagnostic::codegen_error("MOVE expects exactly one parameter", location)) + } + } + } ) ]); } +type AnnotationFunction = + fn(&mut TypeAnnotator, &AstStatement, &[&AstStatement]) -> Result<(), Diagnostic>; +type CodegenFunction = for<'ink, 'b> fn( + &'b ExpressionCodeGenerator<'ink, 'b>, + &[&AstStatement], + SourceRange, +) -> Result, Diagnostic>; pub struct BuiltIn { decl: &'static str, - code: for<'ink, 'b> fn( - &'b ExpressionCodeGenerator<'ink, 'b>, - &[&AstStatement], - SourceRange, - ) -> Result, Diagnostic>, + annotation: Option, + code: CodegenFunction, } impl BuiltIn { @@ -81,6 +193,9 @@ impl BuiltIn { ) -> Result, Diagnostic> { (self.code)(generator, params, location) } + pub(crate) fn get_annotation(&self) -> Option { + self.annotation + } } pub fn parse_built_ins(id_provider: IdProvider) -> CompilationUnit { @@ -89,7 +204,13 @@ pub fn parse_built_ins(id_provider: IdProvider) -> CompilationUnit { .map(|(_, it)| it.decl) .collect::>() .join(" "); - parser::parse(lexer::lex_with_ids(&src, id_provider), LinkageType::BuiltIn).0 + let mut unit = parser::parse( + lexer::lex_with_ids(&src, id_provider.clone()), + LinkageType::BuiltIn, + ) + .0; + crate::ast::pre_process(&mut unit, id_provider); + unit } /// Returns the requested functio from the builtin index or None diff --git a/src/codegen/generators/expression_generator.rs b/src/codegen/generators/expression_generator.rs index 5a125ce3f2..22faf0b9f4 100644 --- a/src/codegen/generators/expression_generator.rs +++ b/src/codegen/generators/expression_generator.rs @@ -3,13 +3,11 @@ use crate::{ ast::{self, DirectAccessType, SourceRange}, codegen::llvm_typesystem, diagnostics::{Diagnostic, INTERNAL_LLVM_ERROR}, - index::{ - ArgumentType, ImplementationIndexEntry, Index, PouIndexEntry, VariableIndexEntry, - VariableType, - }, + index::{ImplementationIndexEntry, Index, PouIndexEntry, VariableIndexEntry}, resolver::{AnnotationMap, AstAnnotations, StatementAnnotation}, typesystem::{ - is_same_type_class, Dimension, StringEncoding, DINT_TYPE, INT_SIZE, INT_TYPE, LINT_TYPE, + is_same_type_class, Dimension, StringEncoding, VarArgs, DINT_TYPE, INT_SIZE, INT_TYPE, + LINT_TYPE, }, }; use inkwell::{ @@ -36,12 +34,12 @@ use super::{llvm::Llvm, statement_generator::FunctionContext}; /// the generator for expressions pub struct ExpressionCodeGenerator<'a, 'b> { - llvm: &'b Llvm<'a>, - index: &'b Index, + pub llvm: &'b Llvm<'a>, + pub index: &'b Index, annotations: &'b AstAnnotations, - llvm_index: &'b LlvmTypedIndex<'a>, + pub llvm_index: &'b LlvmTypedIndex<'a>, /// the current function to create blocks in - function_context: Option<&'b FunctionContext<'a>>, + pub function_context: Option<&'b FunctionContext<'a>>, /// the string-prefix to use for temporary variables pub temp_variable_prefix: String, @@ -118,7 +116,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { } /// returns the function context or returns a Compile-Error - fn get_function_context( + pub fn get_function_context( &self, statement: &AstStatement, ) -> Result<&'b FunctionContext<'ink>, Diagnostic> { @@ -578,10 +576,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { // foo(z:= a, x:=c, y := b); let declared_parameters = self .index - .get_container_members(implementation.get_type_name()) - .into_iter() - .filter(|it| it.is_parameter()) - .collect::>(); + .get_declared_parameters(implementation.get_type_name()); // the parameters to be passed to the function call self.generate_function_arguments(pou, call_params, declared_parameters)? @@ -631,23 +626,24 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { declared_parameters: Vec<&VariableIndexEntry>, ) -> Result>, Diagnostic> { let mut result = Vec::new(); + let mut variadic_params = Vec::new(); for (idx, param_statement) in arguments.into_iter().enumerate() { let (location, param_statement) = get_implicit_call_parameter(param_statement, &declared_parameters, idx)?; //None -> possibly variadic - let (declaration_type, type_name) = declared_parameters + let param = declared_parameters //get paremeter at location .get(location) //find the parameter's type and name - .map(|it| (it.get_declaration_type(), it.get_type_name())) + .map(|it| Some((it.get_declaration_type(), it.get_type_name()))) //TODO : Is this idomatic, we need to wrap in ok because the next step does not necessarily fail .map(Ok) .unwrap_or_else(|| { //If we are dealing with a variadic function, we can accept all extra parameters if pou.is_variadic() { - self.get_type_hint_for(param_statement) - .map(|it| (ArgumentType::ByVal(VariableType::Input), it.get_name())) + variadic_params.push(param_statement); + Ok(None) } else { //We are not variadic, we have too many parameters here Err(Diagnostic::codegen_error( @@ -657,14 +653,23 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { } })?; - let argument: BasicValueEnum = if declaration_type.is_by_ref() { - self.generate_argument_by_ref(param_statement, type_name)? - } else { - //pass by val - self.generate_argument_by_val(type_name, param_statement)? - }; - - result.push((location, argument)); + if let Some((declaration_type, type_name)) = param { + let argument: BasicValueEnum = if declaration_type.is_by_ref() { + self.generate_argument_by_ref(param_statement, type_name)? + } else { + //pass by val + self.generate_argument_by_val(type_name, param_statement)? + }; + result.push((location, argument)); + } + } + //Push variadic collection and optionally the variadic size + if pou.is_variadic() { + let last_location = result.len(); + let variadic_params = self.generate_variadic_arguments_list(pou, &variadic_params)?; + for (i, param) in variadic_params.into_iter().enumerate() { + result.push((i + last_location, param)); + } } result.sort_by(|(idx_a, _), (idx_b, _)| idx_a.cmp(idx_b)); Ok(result @@ -745,6 +750,50 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { .map(Into::into) } + pub fn generate_variadic_arguments_list( + &self, + pou: &PouIndexEntry, + variadic_params: &[&AstStatement], + ) -> Result>, Diagnostic> { + let generated_params = variadic_params + .iter() + .map(|param_statement| { + self.get_type_hint_for(param_statement) + .map(|it| it.get_name()) + .and_then(|type_name| self.generate_argument_by_val(type_name, param_statement)) + }) + .collect::, _>>()?; + //get the real varargs from the index + if let Some(VarArgs::Sized(Some(type_name))) = self + .index + .get_variadic_member(pou.get_name()) + .and_then(|it| it.get_varargs()) + { + let llvm_type = generated_params + .get(0) + .map(|it| Ok(it.get_type())) + .unwrap_or_else(|| self.llvm_index.get_associated_type(type_name))?; + let size = generated_params.len(); + let size_param = self.llvm.i32_type().const_int(size as u64, true); + let arr = Llvm::get_array_type(llvm_type, size as u32); + let arr_storage = self.llvm.builder.build_alloca(arr, ""); + for (i, ele) in generated_params.iter().enumerate() { + let ele_ptr = self.llvm.load_array_element( + arr_storage, + &[ + self.llvm.context.i32_type().const_zero(), + self.llvm.context.i32_type().const_int(i as u64, true), + ], + "", + )?; + self.llvm.builder.build_store(ele_ptr, *ele); + } + Ok(vec![size_param.into(), arr_storage.into()]) + } else { + Ok(generated_params) + } + } + /// generates a new instance of a function called `function_name` and returns a PointerValue to it /// /// - `function_name` the name of the function as registered in the index diff --git a/src/codegen/generators/llvm.rs b/src/codegen/generators/llvm.rs index eac1425b33..3ec16dd9a4 100644 --- a/src/codegen/generators/llvm.rs +++ b/src/codegen/generators/llvm.rs @@ -2,6 +2,7 @@ use crate::ast::SourceRange; use crate::diagnostics::Diagnostic; use crate::typesystem::{CHAR_TYPE, WCHAR_TYPE}; +use inkwell::types::ArrayType; use inkwell::{ builder::Builder, context::Context, @@ -318,4 +319,16 @@ impl<'a> Llvm<'a> { )), } } + + pub fn get_array_type(llvm_type: BasicTypeEnum, size: u32) -> ArrayType { + match llvm_type { + //Add all arguments to the pointer + BasicTypeEnum::ArrayType(_) => llvm_type.into_array_type().array_type(size), + BasicTypeEnum::FloatType(_) => llvm_type.into_float_type().array_type(size), + BasicTypeEnum::IntType(_) => llvm_type.into_int_type().array_type(size), + BasicTypeEnum::PointerType(_) => llvm_type.into_pointer_type().array_type(size), + BasicTypeEnum::StructType(_) => llvm_type.into_struct_type().array_type(size), + BasicTypeEnum::VectorType(_) => llvm_type.into_vector_type().array_type(size), + } + } } diff --git a/src/codegen/generators/pou_generator.rs b/src/codegen/generators/pou_generator.rs index 2bb64e614b..098a2d4ac2 100644 --- a/src/codegen/generators/pou_generator.rs +++ b/src/codegen/generators/pou_generator.rs @@ -11,6 +11,7 @@ use crate::{ diagnostics::{Diagnostic, INTERNAL_LLVM_ERROR}, index::{self, ImplementationType}, resolver::AstAnnotations, + typesystem::{self, VarArgs}, }; /// The pou_generator contains functions to generate the code for POUs (PROGRAM, FUNCTION, FUNCTION_BLOCK) @@ -51,11 +52,9 @@ pub fn generate_implementation_stubs<'ink>( let mut llvm_index = LlvmTypedIndex::default(); let pou_generator = PouGenerator::new(llvm, index, annotations, types_index); for (name, implementation) in index.get_implementations() { - if let Some(pou) = index.find_pou(implementation.get_call_name()) { - if !pou.is_generic() { - let curr_f = pou_generator.generate_implementation_stub(implementation, module)?; - llvm_index.associate_implementation(name, curr_f)?; - } + if !implementation.is_generic() { + let curr_f = pou_generator.generate_implementation_stub(implementation, module)?; + llvm_index.associate_implementation(name, curr_f)?; } } @@ -164,9 +163,8 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { }; let variadic = global_index - .find_effective_type_info(implementation.get_type_name()) - .map(|it| it.is_variadic()) - .unwrap_or(false); + .get_variadic_member(implementation.get_type_name()) + .and_then(VariableIndexEntry::get_varargs); let function_declaration = self.create_llvm_function_type(parameters, variadic, return_type)?; @@ -207,9 +205,8 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { } else { //find the function's parameters self.index - .get_container_members(implementation.get_call_name()) + .get_declared_parameters(implementation.get_call_name()) .iter() - .filter(|v| v.is_parameter()) .map(|v| { self.llvm_index .get_associated_type(v.get_type_name()) @@ -320,27 +317,34 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { fn create_llvm_function_type( &self, parameters: Vec>, - is_var_args: bool, + variadic: Option<&'cg VarArgs>, return_type: Option>, ) -> Result, Diagnostic> { - let params = parameters.as_slice(); + //Sized variadic is not considered a variadic function, but receives 2 extra parameters, size and a pointer + let is_var_args = variadic.map(|it| !it.is_sized()).unwrap_or_default(); + let size_and_pointer = self.get_size_and_pointer(variadic); + let mut params = parameters; + if let Some(sized_variadics) = size_and_pointer { + params.extend_from_slice(&sized_variadics); + }; + match return_type { Some(enum_type) if enum_type.is_int_type() => { - Ok(enum_type.into_int_type().fn_type(params, is_var_args)) + Ok(enum_type.into_int_type().fn_type(¶ms, is_var_args)) } Some(enum_type) if enum_type.is_float_type() => { - Ok(enum_type.into_float_type().fn_type(params, is_var_args)) + Ok(enum_type.into_float_type().fn_type(¶ms, is_var_args)) } Some(enum_type) if enum_type.is_array_type() => { - Ok(enum_type.into_array_type().fn_type(params, is_var_args)) + Ok(enum_type.into_array_type().fn_type(¶ms, is_var_args)) } Some(enum_type) if enum_type.is_pointer_type() => { - Ok(enum_type.into_pointer_type().fn_type(params, is_var_args)) + Ok(enum_type.into_pointer_type().fn_type(¶ms, is_var_args)) } Some(enum_type) if enum_type.is_struct_type() => { - Ok(enum_type.into_struct_type().fn_type(params, is_var_args)) + Ok(enum_type.into_struct_type().fn_type(¶ms, is_var_args)) } - None => Ok(self.llvm.context.void_type().fn_type(params, is_var_args)), + None => Ok(self.llvm.context.void_type().fn_type(¶ms, is_var_args)), _ => Err(Diagnostic::codegen_error( &format!("Unsupported return type {:?}", return_type), SourceRange::undefined(), @@ -577,4 +581,24 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { } Ok(()) } + + fn get_size_and_pointer( + &self, + variadic: Option<&'cg VarArgs>, + ) -> Option<[BasicMetadataTypeEnum<'ink>; 2]> { + if let Some(VarArgs::Sized(Some(type_name))) = variadic { + //Create a size parameter of type i32 (DINT) + let size_param = self + .llvm_index + .find_associated_type(typesystem::DINT_TYPE) + .map(Into::into)?; + let ptr_param = self + .llvm_index + .find_associated_type(type_name) + .map(|it| it.ptr_type(AddressSpace::Generic).into())?; + Some([size_param, ptr_param]) + } else { + None + } + } } diff --git a/src/codegen/llvm_typesystem.rs b/src/codegen/llvm_typesystem.rs index 80fc2de075..b4ee0ba2bf 100644 --- a/src/codegen/llvm_typesystem.rs +++ b/src/codegen/llvm_typesystem.rs @@ -142,6 +142,12 @@ pub fn cast_if_needed<'ctx>( .get_intrinsic_type_by_name(value_type.get_name()) .get_type_information(); + // if the current or target type are generic (unresolved or builtin) + // return the value without modification + if target_type.is_generic(index) || value_type.is_generic(index) { + return Ok(value); + } + match target_type { DataTypeInformation::Integer { signed, diff --git a/src/codegen/tests/code_gen_tests.rs b/src/codegen/tests/code_gen_tests.rs index 5e586c2d26..c8a44be00a 100644 --- a/src/codegen/tests/code_gen_tests.rs +++ b/src/codegen/tests/code_gen_tests.rs @@ -1469,29 +1469,6 @@ fn function_with_two_parameters_called_in_program() { insta::assert_snapshot!(result); } -#[test] -fn function_with_varargs_called_in_program() { - let result = codegen( - " - @EXTERNAL - FUNCTION foo : DINT - VAR_INPUT - args : ...; - END_VAR - END_FUNCTION - - PROGRAM prg - VAR - x : DINT; - END_VAR - x := foo(FALSE, 3, (x + 1)); - END_PROGRAM - ", - ); - - insta::assert_snapshot!(result); -} - #[test] fn function_with_local_var_initialization_and_call() { let result = codegen( diff --git a/src/codegen/tests/expression_tests.rs b/src/codegen/tests/expression_tests.rs index 370a574a52..bfee3bd3e6 100644 --- a/src/codegen/tests/expression_tests.rs +++ b/src/codegen/tests/expression_tests.rs @@ -497,3 +497,76 @@ fn builtin_function_call_ref() { // We expect a direct conversion and subsequent assignment to pointer(no call) insta::assert_snapshot!(result); } + +#[test] +fn builtin_function_call_mux() { + let result = codegen( + "PROGRAM main + VAR + a,b,c,d,e : DINT; + END_VAR + a := MUX(3, b,c,d,e); //3 = d + END_PROGRAM", + ); + + insta::assert_snapshot!(result); +} + +#[test] +fn builtin_function_call_sel() { + let result = codegen( + "PROGRAM main + VAR + a,b,c : DINT; + END_VAR + a := SEL(TRUE, b,c); + END_PROGRAM", + ); + + insta::assert_snapshot!(result); +} + +#[test] +fn builtin_function_call_sel_as_expression() { + let result = codegen( + "PROGRAM main + VAR + a,b,c : DINT; + END_VAR + a := SEL(TRUE, b,c) + 10; + END_PROGRAM", + ); + + insta::assert_snapshot!(result); +} + +#[test] +fn builtin_function_call_move() { + let result = codegen( + "PROGRAM main + VAR + a,b : DINT; + END_VAR + a := MOVE(b); + END_PROGRAM", + ); + + insta::assert_snapshot!(result); +} + +#[test] +fn test_max_int() { + let result = codegen( + r" + {external} + FUNCTION MAX : U + VAR_INPUT in : {sized} U...; END_VAR + END_FUNCTION + + FUNCTION main : INT + main := MAX(INT#5,INT#2,INT#1,INT#3,INT#4,INT#7,INT#-1); + END_FUNCTION", + ); + + insta::assert_snapshot!(result); +} diff --git a/src/codegen/tests/function_tests.rs b/src/codegen/tests/function_tests.rs index e6145473c3..d2b6beb555 100644 --- a/src/codegen/tests/function_tests.rs +++ b/src/codegen/tests/function_tests.rs @@ -88,36 +88,7 @@ fn simple_call() { "#, ); - insta::assert_snapshot!(result, @r###" - ; ModuleID = 'main' - source_filename = "main" - - %main_interface = type { i32 } - - @main_instance = global %main_interface zeroinitializer - - define i32 @func(i32 %0) { - entry: - %x = alloca i32, align 4 - store i32 %0, i32* %x, align 4 - %func = alloca i32, align 4 - store i32 0, i32* %func, align 4 - %func_ret = load i32, i32* %func, align 4 - ret i32 %func_ret - } - - define void @main(%main_interface* %0) { - entry: - %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 - %load_a = load i32, i32* %a, align 4 - %call = call i32 @func(i32 %load_a) - %call1 = call i32 @func(i32 1) - %load_a2 = load i32, i32* %a, align 4 - %tmpVar = add i32 1, %load_a2 - %call3 = call i32 @func(i32 %tmpVar) - ret void - } - "###); + insta::assert_snapshot!(result); } #[test] @@ -136,55 +107,7 @@ fn passing_a_string_to_a_function() { "#, ); - insta::assert_snapshot!(result, @r###" - ; ModuleID = 'main' - source_filename = "main" - - %main_interface = type { [6 x i8] } - - @main_instance = global %main_interface zeroinitializer - @utf08_literal_0 = unnamed_addr constant [6 x i8] c"12345\00" - - define i32 @func([6 x i8] %0) { - entry: - %x = alloca [6 x i8], align 1 - store [6 x i8] %0, [6 x i8]* %x, align 1 - %func = alloca i32, align 4 - store i32 0, i32* %func, align 4 - %func_ret = load i32, i32* %func, align 4 - ret i32 %func_ret - } - - define void @main(%main_interface* %0) { - entry: - %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 - %1 = alloca [6 x i8], align 1 - %2 = bitcast [6 x i8]* %1 to i8* - call void @llvm.memset.p0i8.i64(i8* align 1 %2, i8 0, i64 ptrtoint ([6 x i8]* getelementptr ([6 x i8], [6 x i8]* null, i32 1) to i64), i1 false) - %3 = bitcast [6 x i8]* %1 to i8* - %4 = bitcast [6 x i8]* %a to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %3, i8* align 1 %4, i32 5, i1 false) - %5 = load [6 x i8], [6 x i8]* %1, align 1 - %call = call i32 @func([6 x i8] %5) - %6 = alloca [6 x i8], align 1 - %7 = bitcast [6 x i8]* %6 to i8* - call void @llvm.memset.p0i8.i64(i8* align 1 %7, i8 0, i64 ptrtoint ([6 x i8]* getelementptr ([6 x i8], [6 x i8]* null, i32 1) to i64), i1 false) - %8 = bitcast [6 x i8]* %6 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %8, i8* align 1 getelementptr inbounds ([6 x i8], [6 x i8]* @utf08_literal_0, i32 0, i32 0), i32 5, i1 false) - %9 = load [6 x i8], [6 x i8]* %6, align 1 - %call1 = call i32 @func([6 x i8] %9) - ret void - } - - ; Function Attrs: argmemonly nofree nounwind willreturn writeonly - declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #0 - - ; Function Attrs: argmemonly nofree nounwind willreturn - declare void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i32, i1 immarg) #1 - - attributes #0 = { argmemonly nofree nounwind willreturn writeonly } - attributes #1 = { argmemonly nofree nounwind willreturn } - "###); + insta::assert_snapshot!(result); } #[test] @@ -203,33 +126,7 @@ fn passing_a_string_to_a_function_as_reference() { "#, ); - insta::assert_snapshot!(result, @r###" - ; ModuleID = 'main' - source_filename = "main" - - %main_interface = type { [6 x i8] } - - @main_instance = global %main_interface zeroinitializer - @utf08_literal_0 = unnamed_addr constant [6 x i8] c"12345\00" - - define i32 @func([6 x i8]* %0) { - entry: - %x = alloca [6 x i8]*, align 8 - store [6 x i8]* %0, [6 x i8]** %x, align 8 - %func = alloca i32, align 4 - store i32 0, i32* %func, align 4 - %func_ret = load i32, i32* %func, align 4 - ret i32 %func_ret - } - - define void @main(%main_interface* %0) { - entry: - %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 - %call = call i32 @func([6 x i8]* %a) - %call1 = call i32 @func([6 x i8]* @utf08_literal_0) - ret void - } - "###); + insta::assert_snapshot!(result); } #[test] @@ -253,51 +150,54 @@ fn passing_arguments_to_functions_by_ref_and_val() { "#, ); - insta::assert_snapshot!(result, @r###" - ; ModuleID = 'main' - source_filename = "main" + insta::assert_snapshot!(result); +} - %main_interface = type {} +#[test] +fn function_with_varargs_called_in_program() { + let result = codegen( + " + @EXTERNAL + FUNCTION foo : DINT + VAR_INPUT + args : ...; + END_VAR + END_FUNCTION + + PROGRAM prg + VAR + x : DINT; + END_VAR + x := foo(FALSE, 3, (x + 1)); + END_PROGRAM + ", + ); + + insta::assert_snapshot!(result); +} - @main_instance = global %main_interface zeroinitializer +#[test] +fn function_with_sized_varargs_called_in_program() { + let result = codegen( + " + @EXTERNAL + FUNCTION foo : DINT + VAR_INPUT + args : {sized} DINT...; + END_VAR + END_FUNCTION - define i32 @func(i16* %0, i32* %1, i16 %2, i32 %3) { - entry: - %byRef1 = alloca i16*, align 8 - store i16* %0, i16** %byRef1, align 8 - %byRef2 = alloca i32*, align 8 - store i32* %1, i32** %byRef2, align 8 - %byVal1 = alloca i16, align 2 - store i16 %2, i16* %byVal1, align 2 - %byVal2 = alloca i32, align 4 - store i32 %3, i32* %byVal2, align 4 - %func = alloca i32, align 4 - store i32 0, i32* %func, align 4 - %deref = load i16*, i16** %byRef1, align 8 - %load_byRef1 = load i16, i16* %deref, align 2 - %4 = sext i16 %load_byRef1 to i32 - %deref1 = load i32*, i32** %byRef2, align 8 - %load_byRef2 = load i32, i32* %deref1, align 4 - %tmpVar = mul i32 %4, %load_byRef2 - %load_byVal1 = load i16, i16* %byVal1, align 2 - %5 = sext i16 %load_byVal1 to i32 - %tmpVar2 = mul i32 %tmpVar, %5 - %deref3 = load i32*, i32** %byRef2, align 8 - %load_byRef24 = load i32, i32* %deref3, align 4 - %tmpVar5 = mul i32 %tmpVar2, %load_byRef24 - store i32 %tmpVar5, i32* %func, align 4 - %func_ret = load i32, i32* %func, align 4 - ret i32 %func_ret - } + PROGRAM prg + VAR + x : DINT; + END_VAR + x := foo(0, 3, (x + 1)); + END_PROGRAM + ", + ); - define void @main(%main_interface* %0) { - entry: - %1 = alloca i32, align 4 - store i32 1, i32* %1, align 4 - %2 = alloca i32, align 4 - store i32 2, i32* %2, align 4 - %call = call i32 @func(i32* %1, i32* %2, i16 3, i32 4) - ret void - } - "###); + // The function definition contains a size and pointer for the parameters + // The parameters are stored in a local vector (allocated in place) + // Function call with 3 as first parameter (size) and the arguments array as pointer + insta::assert_snapshot!(result); } diff --git a/src/codegen/tests/generics_test.rs b/src/codegen/tests/generics_test.rs index 56f6176500..86fb8c7ba4 100644 --- a/src/codegen/tests/generics_test.rs +++ b/src/codegen/tests/generics_test.rs @@ -72,3 +72,22 @@ fn generic_output_parameter() { // AND we expect a second call to foo__BYTE with out1 passed as a pointer insta::assert_snapshot!(codegen(src)); } + +#[test] +fn generic_call_gets_cast_to_biggest_type() { + let src = r" + + {external} + FUNCTION MAX : T + VAR_INPUT + args : {sized} T...; + END_VAR + END_FUNCTION + + FUNCTION main : LREAL + main := MAX(SINT#5,DINT#1,LREAL#1.5,1.2); + END_FUNCTION"; + + //Expecting all values to be LREAL + insta::assert_snapshot!(codegen(src)); +} diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap new file mode 100644 index 0000000000..b54fe22279 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap @@ -0,0 +1,20 @@ +--- +source: src/codegen/tests/expression_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { i32, i32 } + +@main_instance = global %main_interface zeroinitializer + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %b = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 1 + %load_b = load i32, i32* %b, align 4 + store i32 %load_b, i32* %a, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap new file mode 100644 index 0000000000..7e62446544 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap @@ -0,0 +1,52 @@ +--- +source: src/codegen/tests/expression_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { i32, i32, i32, i32, i32 } + +@main_instance = global %main_interface zeroinitializer + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %b = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 1 + %c = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 2 + %d = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 3 + %e = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 4 + %1 = alloca i32, align 4 + switch i32 3, label %continue_block [ + i32 0, label %2 + i32 1, label %3 + i32 2, label %4 + i32 3, label %5 + ] + +2: ; preds = %entry + %load_b = load i32, i32* %b, align 4 + store i32 %load_b, i32* %1, align 4 + br label %continue_block + +3: ; preds = %entry + %load_c = load i32, i32* %c, align 4 + store i32 %load_c, i32* %1, align 4 + br label %continue_block + +4: ; preds = %entry + %load_d = load i32, i32* %d, align 4 + store i32 %load_d, i32* %1, align 4 + br label %continue_block + +5: ; preds = %entry + %load_e = load i32, i32* %e, align 4 + store i32 %load_e, i32* %1, align 4 + br label %continue_block + +continue_block: ; preds = %entry, %5, %4, %3, %2 + %6 = load i32, i32* %1, align 4 + store i32 %6, i32* %a, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap new file mode 100644 index 0000000000..a438e9bcb2 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap @@ -0,0 +1,23 @@ +--- +source: src/codegen/tests/expression_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { i32, i32, i32 } + +@main_instance = global %main_interface zeroinitializer + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %b = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 1 + %c = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 2 + %load_b = load i32, i32* %b, align 4 + %load_c = load i32, i32* %c, align 4 + %1 = select i1 true, i32 %load_c, i32 %load_b + store i32 %1, i32* %a, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap new file mode 100644 index 0000000000..91915b5536 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap @@ -0,0 +1,24 @@ +--- +source: src/codegen/tests/expression_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { i32, i32, i32 } + +@main_instance = global %main_interface zeroinitializer + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %b = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 1 + %c = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 2 + %load_b = load i32, i32* %b, align 4 + %load_c = load i32, i32* %c, align 4 + %1 = select i1 true, i32 %load_c, i32 %load_b + %tmpVar = add i32 %1, 10 + store i32 %tmpVar, i32* %a, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap new file mode 100644 index 0000000000..b5a3ef7014 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap @@ -0,0 +1,34 @@ +--- +source: src/codegen/tests/expression_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +define i16 @main() { +entry: + %main = alloca i16, align 2 + store i16 0, i16* %main, align 2 + %0 = alloca [7 x i16], align 2 + %1 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 0 + store i16 5, i16* %1, align 2 + %2 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 1 + store i16 2, i16* %2, align 2 + %3 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 2 + store i16 1, i16* %3, align 2 + %4 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 3 + store i16 3, i16* %4, align 2 + %5 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 4 + store i16 4, i16* %5, align 2 + %6 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 5 + store i16 7, i16* %6, align 2 + %7 = getelementptr inbounds [7 x i16], [7 x i16]* %0, i32 0, i32 6 + store i16 -1, i16* %7, align 2 + %call = call i16 @MAX__INT(i32 7, [7 x i16]* %0) + store i16 %call, i16* %main, align 2 + %main_ret = load i16, i16* %main, align 2 + ret i16 %main_ret +} + +declare i16 @MAX__INT(i32, i16*) + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap new file mode 100644 index 0000000000..72a7de639b --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap @@ -0,0 +1,30 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%prg_interface = type { i32 } + +@prg_instance = global %prg_interface zeroinitializer + +declare i32 @foo(i32, i32*) + +define void @prg(%prg_interface* %0) { +entry: + %x = getelementptr inbounds %prg_interface, %prg_interface* %0, i32 0, i32 0 + %load_x = load i32, i32* %x, align 4 + %tmpVar = add i32 %load_x, 1 + %1 = alloca [3 x i32], align 4 + %2 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i32 0, i32 0 + store i32 0, i32* %2, align 4 + %3 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i32 0, i32 1 + store i32 3, i32* %3, align 4 + %4 = getelementptr inbounds [3 x i32], [3 x i32]* %1, i32 0, i32 2 + store i32 %tmpVar, i32* %4, align 4 + %call = call i32 @foo(i32 3, [3 x i32]* %1) + store i32 %call, i32* %x, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap new file mode 100644 index 0000000000..3cc62d6af4 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap @@ -0,0 +1,23 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%prg_interface = type { i32 } + +@prg_instance = global %prg_interface zeroinitializer + +declare i32 @foo(...) + +define void @prg(%prg_interface* %0) { +entry: + %x = getelementptr inbounds %prg_interface, %prg_interface* %0, i32 0, i32 0 + %load_x = load i32, i32* %x, align 4 + %tmpVar = add i32 %load_x, 1 + %call = call i32 (...) @foo(i1 false, i32 3, i32 %tmpVar) + store i32 %call, i32* %x, align 4 + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap new file mode 100644 index 0000000000..b05d24ebe2 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap @@ -0,0 +1,52 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { [6 x i8] } + +@main_instance = global %main_interface zeroinitializer +@utf08_literal_0 = unnamed_addr constant [6 x i8] c"12345\00" + +define i32 @func([6 x i8] %0) { +entry: + %x = alloca [6 x i8], align 1 + store [6 x i8] %0, [6 x i8]* %x, align 1 + %func = alloca i32, align 4 + store i32 0, i32* %func, align 4 + %func_ret = load i32, i32* %func, align 4 + ret i32 %func_ret +} + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %1 = alloca [6 x i8], align 1 + %2 = bitcast [6 x i8]* %1 to i8* + call void @llvm.memset.p0i8.i64(i8* align 1 %2, i8 0, i64 ptrtoint ([6 x i8]* getelementptr ([6 x i8], [6 x i8]* null, i32 1) to i64), i1 false) + %3 = bitcast [6 x i8]* %1 to i8* + %4 = bitcast [6 x i8]* %a to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %3, i8* align 1 %4, i32 5, i1 false) + %5 = load [6 x i8], [6 x i8]* %1, align 1 + %call = call i32 @func([6 x i8] %5) + %6 = alloca [6 x i8], align 1 + %7 = bitcast [6 x i8]* %6 to i8* + call void @llvm.memset.p0i8.i64(i8* align 1 %7, i8 0, i64 ptrtoint ([6 x i8]* getelementptr ([6 x i8], [6 x i8]* null, i32 1) to i64), i1 false) + %8 = bitcast [6 x i8]* %6 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %8, i8* align 1 getelementptr inbounds ([6 x i8], [6 x i8]* @utf08_literal_0, i32 0, i32 0), i32 5, i1 false) + %9 = load [6 x i8], [6 x i8]* %6, align 1 + %call1 = call i32 @func([6 x i8] %9) + ret void +} + +; Function Attrs: argmemonly nofree nounwind willreturn writeonly +declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #0 + +; Function Attrs: argmemonly nofree nounwind willreturn +declare void @llvm.memcpy.p0i8.p0i8.i32(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i32, i1 immarg) #1 + +attributes #0 = { argmemonly nofree nounwind willreturn writeonly } +attributes #1 = { argmemonly nofree nounwind willreturn } + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap new file mode 100644 index 0000000000..431270e14c --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap @@ -0,0 +1,30 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { [6 x i8] } + +@main_instance = global %main_interface zeroinitializer +@utf08_literal_0 = unnamed_addr constant [6 x i8] c"12345\00" + +define i32 @func([6 x i8]* %0) { +entry: + %x = alloca [6 x i8]*, align 8 + store [6 x i8]* %0, [6 x i8]** %x, align 8 + %func = alloca i32, align 4 + store i32 0, i32* %func, align 4 + %func_ret = load i32, i32* %func, align 4 + ret i32 %func_ret +} + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %call = call i32 @func([6 x i8]* %a) + %call1 = call i32 @func([6 x i8]* @utf08_literal_0) + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap new file mode 100644 index 0000000000..f355e79123 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap @@ -0,0 +1,50 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type {} + +@main_instance = global %main_interface zeroinitializer + +define i32 @func(i16* %0, i32* %1, i16 %2, i32 %3) { +entry: + %byRef1 = alloca i16*, align 8 + store i16* %0, i16** %byRef1, align 8 + %byRef2 = alloca i32*, align 8 + store i32* %1, i32** %byRef2, align 8 + %byVal1 = alloca i16, align 2 + store i16 %2, i16* %byVal1, align 2 + %byVal2 = alloca i32, align 4 + store i32 %3, i32* %byVal2, align 4 + %func = alloca i32, align 4 + store i32 0, i32* %func, align 4 + %deref = load i16*, i16** %byRef1, align 8 + %load_byRef1 = load i16, i16* %deref, align 2 + %4 = sext i16 %load_byRef1 to i32 + %deref1 = load i32*, i32** %byRef2, align 8 + %load_byRef2 = load i32, i32* %deref1, align 4 + %tmpVar = mul i32 %4, %load_byRef2 + %load_byVal1 = load i16, i16* %byVal1, align 2 + %5 = sext i16 %load_byVal1 to i32 + %tmpVar2 = mul i32 %tmpVar, %5 + %deref3 = load i32*, i32** %byRef2, align 8 + %load_byRef24 = load i32, i32* %deref3, align 4 + %tmpVar5 = mul i32 %tmpVar2, %load_byRef24 + store i32 %tmpVar5, i32* %func, align 4 + %func_ret = load i32, i32* %func, align 4 + ret i32 %func_ret +} + +define void @main(%main_interface* %0) { +entry: + %1 = alloca i32, align 4 + store i32 1, i32* %1, align 4 + %2 = alloca i32, align 4 + store i32 2, i32* %2, align 4 + %call = call i32 @func(i32* %1, i32* %2, i16 3, i32 4) + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap new file mode 100644 index 0000000000..59d45384b4 --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap @@ -0,0 +1,33 @@ +--- +source: src/codegen/tests/function_tests.rs +expression: result +--- +; ModuleID = 'main' +source_filename = "main" + +%main_interface = type { i32 } + +@main_instance = global %main_interface zeroinitializer + +define i32 @func(i32 %0) { +entry: + %x = alloca i32, align 4 + store i32 %0, i32* %x, align 4 + %func = alloca i32, align 4 + store i32 0, i32* %func, align 4 + %func_ret = load i32, i32* %func, align 4 + ret i32 %func_ret +} + +define void @main(%main_interface* %0) { +entry: + %a = getelementptr inbounds %main_interface, %main_interface* %0, i32 0, i32 0 + %load_a = load i32, i32* %a, align 4 + %call = call i32 @func(i32 %load_a) + %call1 = call i32 @func(i32 1) + %load_a2 = load i32, i32* %a, align 4 + %tmpVar = add i32 1, %load_a2 + %call3 = call i32 @func(i32 %tmpVar) + ret void +} + diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap new file mode 100644 index 0000000000..c0a4368f1d --- /dev/null +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap @@ -0,0 +1,28 @@ +--- +source: src/codegen/tests/generics_test.rs +expression: codegen(src) +--- +; ModuleID = 'main' +source_filename = "main" + +define double @main() { +entry: + %main = alloca double, align 8 + store double 0.000000e+00, double* %main, align 8 + %0 = alloca [4 x double], align 8 + %1 = getelementptr inbounds [4 x double], [4 x double]* %0, i32 0, i32 0 + store double 5.000000e+00, double* %1, align 8 + %2 = getelementptr inbounds [4 x double], [4 x double]* %0, i32 0, i32 1 + store double 1.000000e+00, double* %2, align 8 + %3 = getelementptr inbounds [4 x double], [4 x double]* %0, i32 0, i32 2 + store double 1.500000e+00, double* %3, align 8 + %4 = getelementptr inbounds [4 x double], [4 x double]* %0, i32 0, i32 3 + store double 1.200000e+00, double* %4, align 8 + %call = call double @MAX__LREAL(i32 4, [4 x double]* %0) + store double %call, double* %main, align 8 + %main_ret = load double, double* %main, align 8 + ret double %main_ret +} + +declare double @MAX__LREAL(i32, double*) + diff --git a/src/diagnostics.rs b/src/diagnostics.rs index b26e1a4bac..a5a83fb984 100644 --- a/src/diagnostics.rs +++ b/src/diagnostics.rs @@ -59,6 +59,7 @@ pub enum ErrNo { var__invalid_constant, var__cannot_assign_to_const, var__invalid_assignment, + var__missing_type, //reference related reference__unresolved, @@ -514,6 +515,14 @@ impl Diagnostic { } } + pub fn missing_datatype(reason: Option<&str>, location: SourceRange) -> Diagnostic { + Diagnostic::SyntaxError { + message: format!("Missing datatype {}", reason.unwrap_or("")), + range: location, + err_no: ErrNo::var__missing_type, + } + } + pub fn incompatible_type_size( nature: &str, size: u32, diff --git a/src/index.rs b/src/index.rs index 5c56ff436d..8beb2c0eb5 100644 --- a/src/index.rs +++ b/src/index.rs @@ -44,6 +44,8 @@ pub struct VariableIndexEntry { binding: Option, /// the location in the original source-file pub source_location: SourceRange, + /// Variadic information placeholder for the variable, if any + varargs: Option, } #[derive(Debug, PartialEq, Clone)] @@ -97,6 +99,7 @@ pub struct MemberInfo<'b> { variable_type_name: &'b str, binding: Option, is_constant: bool, + varargs: Option, } impl VariableIndexEntry { @@ -119,6 +122,7 @@ impl VariableIndexEntry { linkage: LinkageType::Internal, binding: None, source_location, + varargs: None, } } @@ -139,6 +143,7 @@ impl VariableIndexEntry { linkage: LinkageType::Internal, binding: None, source_location, + varargs: None, } } @@ -162,6 +167,11 @@ impl VariableIndexEntry { self } + pub fn set_varargs(mut self, varargs: Option) -> Self { + self.varargs = varargs; + self + } + /// Creates a new VariableIndexEntry from the current entry with a new container and type /// This is used to create new entries from previously generic entries pub fn into_typed(&self, container: &str, new_type: &str) -> Self { @@ -170,10 +180,16 @@ impl VariableIndexEntry { } else { &self.name }; + let varargs = self + .varargs + .as_ref() + .map(|varargs| varargs.as_typed(new_type)); + VariableIndexEntry { name: name.to_string(), qualified_name: format!("{}.{}", container, name), data_type_name: new_type.to_string(), + varargs, ..self.to_owned() } } @@ -229,12 +245,20 @@ impl VariableIndexEntry { self.binding.as_ref() } - pub(crate) fn is_parameter(&self) -> bool { + pub fn is_parameter(&self) -> bool { matches!( self.get_variable_type(), VariableType::Input | VariableType::Output | VariableType::InOut ) } + + pub fn is_variadic(&self) -> bool { + self.varargs.is_some() + } + + pub fn get_varargs(&self) -> Option<&VarArgs> { + self.varargs.as_ref() + } } #[derive(Copy, Clone, Debug, PartialEq)] @@ -322,6 +346,10 @@ impl ImplementationIndexEntry { pub fn get_implementation_type(&self) -> &ImplementationType { &self.implementation_type } + + pub fn is_generic(&self) -> bool { + self.generic + } } impl From<&Implementation> for ImplementationIndexEntry { @@ -979,6 +1007,17 @@ impl Index { .unwrap_or_else(Vec::new) } + pub fn get_declared_parameters(&self, container_name: &str) -> Vec<&VariableIndexEntry> { + self.member_variables + .get(&container_name.to_lowercase()) + .map(|it| { + it.values() + .filter(|it| it.is_parameter() && !it.is_variadic()) + }) + .map(|it| it.collect()) + .unwrap_or_else(Vec::new) + } + /// returns true if the current index is a VAR_INPUT, VAR_IN_OUT or VAR_OUTPUT that is not a variadic argument /// In other words it returns whether the member variable at `index` of the given container is a possible parameter in /// call to it @@ -987,12 +1026,18 @@ impl Index { .get(&container_name.to_lowercase()) .and_then(|map| { map.values() - .filter(|item| item.is_parameter()) + .filter(|item| item.is_parameter() && !item.is_variadic()) .find(|item| item.location_in_parent == index) }) .is_some() } + pub fn get_variadic_member(&self, container_name: &str) -> Option<&VariableIndexEntry> { + self.member_variables + .get(&container_name.to_lowercase()) + .and_then(|map| map.values().find(|it| it.is_variadic())) + } + pub fn find_input_parameter(&self, pou_name: &str, index: u32) -> Option<&VariableIndexEntry> { self.member_variables .get(&pou_name.to_lowercase()) @@ -1210,7 +1255,8 @@ impl Index { ) .set_constant(member_info.is_constant) .set_initial_value(initial_value) - .set_hardware_binding(member_info.binding); + .set_hardware_binding(member_info.binding) + .set_varargs(member_info.varargs); self.register_member_entry(container_name, entry); } diff --git a/src/index/tests/builtin_tests.rs b/src/index/tests/builtin_tests.rs index 87c7fdfdd4..0505cc36c9 100644 --- a/src/index/tests/builtin_tests.rs +++ b/src/index/tests/builtin_tests.rs @@ -8,8 +8,14 @@ fn builtin_functions_added_to_index() { assert!(index.find_member("ADR", "in").is_some()); assert!(index.find_member("REF", "in").is_some()); + assert!(index.find_member("MUX", "K").is_some()); + assert!(index.find_member("SEL", "G").is_some()); + assert!(index.find_member("MOVE", "in").is_some()); assert!(index.find_implementation_by_name("ADR").is_some()); assert!(index.find_implementation_by_name("REF").is_some()); + assert!(index.find_implementation_by_name("MUX").is_some()); + assert!(index.find_implementation_by_name("SEL").is_some()); + assert!(index.find_implementation_by_name("MOVE").is_some()); } #[test] @@ -17,6 +23,12 @@ fn test_indexer_has_builtins() { let (_, index) = index(""); assert!(index.find_member("ADR", "in").is_some()); assert!(index.find_member("REF", "in").is_some()); + assert!(index.find_member("MUX", "K").is_some()); + assert!(index.find_member("SEL", "G").is_some()); + assert!(index.find_member("MOVE", "in").is_some()); assert!(index.find_implementation_by_name("ADR").is_some()); assert!(index.find_implementation_by_name("REF").is_some()); + assert!(index.find_implementation_by_name("MUX").is_some()); + assert!(index.find_implementation_by_name("SEL").is_some()); + assert!(index.find_implementation_by_name("MOVE").is_some()); } diff --git a/src/index/tests/index_tests.rs b/src/index/tests/index_tests.rs index 2766c41d96..300b58dea3 100644 --- a/src/index/tests/index_tests.rs +++ b/src/index/tests/index_tests.rs @@ -5,7 +5,7 @@ use crate::index::{ArgumentType, PouIndexEntry, VariableIndexEntry}; use crate::lexer::IdProvider; use crate::parser::tests::literal_int; use crate::test_utils::tests::{annotate, index, parse_and_preprocess}; -use crate::typesystem::TypeSize; +use crate::typesystem::{TypeSize, INT_TYPE, VOID_TYPE}; use crate::{ast::*, index::VariableType, typesystem::DataTypeInformation}; #[test] @@ -239,9 +239,12 @@ fn function_with_varargs_param_marked() { END_FUNCTION "#, ); - let function = index.find_effective_type("myFunc").unwrap(); - assert!(function.get_type_information().is_variadic()); - assert_eq!(None, function.get_type_information().get_variadic_type()); + let function = index.find_pou("myFunc").unwrap(); + assert!(function.is_variadic()); + assert_eq!( + VOID_TYPE, + index.get_variadic_member("myFunc").unwrap().get_type_name() + ); } #[test] @@ -256,11 +259,11 @@ fn function_with_typed_varargs_param_marked() { END_FUNCTION "#, ); - let function = index.find_effective_type("myFunc").unwrap(); - assert!(function.get_type_information().is_variadic()); + let function = index.find_pou("myFunc").unwrap(); + assert!(function.is_variadic()); assert_eq!( - Some("INT"), - function.get_type_information().get_variadic_type() + INT_TYPE, + index.get_variadic_member("myFunc").unwrap().get_type_name() ); } @@ -509,78 +512,42 @@ fn callable_instances_can_be_retreived() { "#, ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb1_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb2_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb3_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb1_local"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb1_local", "fb2_inst", "fb3_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb1_inst", "fb2_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["fb1_inst", "fb2_inst", "fb3_inst"]) - .is_some() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["foo"]) - .is_none() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["a"]) - .is_none() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["b"]) - .is_none() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["c"]) - .is_none() - ); - assert_eq!( - true, - index - .find_callable_instance_variable(Some("prg"), &["d"]) - .is_none() - ); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb1_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb2_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb3_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb1_local"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb1_local", "fb2_inst", "fb3_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb1_inst", "fb2_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["fb1_inst", "fb2_inst", "fb3_inst"]) + .is_some()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["foo"]) + .is_none()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["a"]) + .is_none()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["b"]) + .is_none()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["c"]) + .is_none()); + assert!(index + .find_callable_instance_variable(Some("prg"), &["d"]) + .is_none()); } #[test] @@ -1747,13 +1714,10 @@ fn function_name_equals_return_type() { // with the name "time" assert_eq!(data_type.get_name(), "TIME"); // and DataTypeInformation of the type struct - assert_eq!( - true, - matches!( - data_type.get_type_information(), - DataTypeInformation::Struct { .. } - ) - ); + assert!(matches!( + data_type.get_type_information(), + DataTypeInformation::Struct { .. } + )); } #[test] @@ -1772,7 +1736,7 @@ fn global_vars_for_structs() { // THEN there should be a global variable for the struct let global_var = index.find_global_initializer("__main_x__init"); - assert_eq!(true, global_var.is_some()); + assert!(global_var.is_some()); } #[test] @@ -1917,7 +1881,8 @@ fn a_program_pou_is_indexed() { location_in_parent: 0, linkage: LinkageType::Internal, binding: None, - source_location: SourceRange::new(9..46) + source_location: SourceRange::new(9..46), + varargs: None, } }), index.find_pou("myProgram"), diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_instances_are_repeated.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_instances_are_repeated.snap index 8fd53357fa..579ad6de0f 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_instances_are_repeated.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_instances_are_repeated.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 91..264, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 124..127, }, + varargs: None, }, ), ( @@ -103,6 +105,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -152,6 +155,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ( @@ -180,6 +184,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 157..161, }, + varargs: None, }, ), ( @@ -243,6 +248,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -306,6 +312,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ( @@ -334,6 +341,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 196..200, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_with_const_instances_are_repeated.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_with_const_instances_are_repeated.snap index af89aea875..22b33ca290 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_with_const_instances_are_repeated.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__array_with_const_instances_are_repeated.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 91..234, }, + varargs: None, }, ), ( @@ -59,6 +60,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 133..137, }, + varargs: None, }, ), ( @@ -87,6 +89,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 179..182, }, + varargs: None, }, ), ( @@ -136,6 +139,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -185,6 +189,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__filter_on_variables_are_applied.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__filter_on_variables_are_applied.snap index a330ce6ce4..a1772de439 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__filter_on_variables_are_applied.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__filter_on_variables_are_applied.snap @@ -1,6 +1,6 @@ --- source: src/index/tests/instance_resolver_tests.rs -expression: "index.filter_instances(|it, _|\n !it.is_constant()).collect::>>()" +expression: "index.filter_instances(|it, _|\n !it.is_constant()).collect::>>()" --- [ ( @@ -26,6 +26,7 @@ expression: "index.filter_instances(|it, _|\n !it.is_c source_location: SourceRange { range: 194..197, }, + varargs: None, }, ), ( @@ -51,6 +52,7 @@ expression: "index.filter_instances(|it, _|\n !it.is_c source_location: SourceRange { range: 91..161, }, + varargs: None, }, ), ( @@ -79,6 +81,7 @@ expression: "index.filter_instances(|it, _|\n !it.is_c source_location: SourceRange { range: 124..127, }, + varargs: None, }, ), ( @@ -110,6 +113,7 @@ expression: "index.filter_instances(|it, _|\n !it.is_c source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -141,6 +145,7 @@ expression: "index.filter_instances(|it, _|\n !it.is_c source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_fb_variables_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_fb_variables_are_retrieved.snap index 52a4bf1301..a2bedf45f8 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_fb_variables_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_fb_variables_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 110..113, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -82,6 +84,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ( @@ -107,6 +110,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 136..206, }, + varargs: None, }, ), ( @@ -135,6 +139,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 169..172, }, + varargs: None, }, ), ( @@ -166,6 +171,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 40..41, }, + varargs: None, }, ), ( @@ -197,6 +203,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 42..43, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_struct_variables_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_struct_variables_are_retrieved.snap index 1af5e5f29e..1b8f04c387 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_struct_variables_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_struct_variables_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 95..99, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 32..33, }, + varargs: None, }, ), ( @@ -82,6 +84,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 34..35, }, + varargs: None, }, ), ( @@ -107,6 +110,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 123..195, }, + varargs: None, }, ), ( @@ -135,6 +139,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 156..160, }, + varargs: None, }, ), ( @@ -166,6 +171,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 32..33, }, + varargs: None, }, ), ( @@ -197,6 +203,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 34..35, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_vars_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_vars_are_retrieved.snap index 9fdb9aba0c..cda29ba098 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_vars_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__global_vars_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 20..21, }, + varargs: None, }, ), ( @@ -51,6 +52,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 22..23, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__nested_global_struct_variables_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__nested_global_struct_variables_are_retrieved.snap index 2dc2854a35..00a1e377f2 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__nested_global_struct_variables_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__nested_global_struct_variables_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 167..171, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 32..33, }, + varargs: None, }, ), ( @@ -85,6 +87,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 104..105, }, + varargs: None, }, ), ( @@ -116,6 +119,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 106..107, }, + varargs: None, }, ), ( @@ -144,6 +148,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 34..35, }, + varargs: None, }, ), ( @@ -175,6 +180,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 104..105, }, + varargs: None, }, ), ( @@ -206,6 +212,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 106..107, }, + varargs: None, }, ), ( @@ -231,6 +238,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 195..267, }, + varargs: None, }, ), ( @@ -259,6 +267,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 228..232, }, + varargs: None, }, ), ( @@ -290,6 +299,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 32..33, }, + varargs: None, }, ), ( @@ -324,6 +334,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 104..105, }, + varargs: None, }, ), ( @@ -358,6 +369,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 106..107, }, + varargs: None, }, ), ( @@ -389,6 +401,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 34..35, }, + varargs: None, }, ), ( @@ -423,6 +436,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 104..105, }, + varargs: None, }, ), ( @@ -457,6 +471,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 106..107, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__pointer_variables_are_not_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__pointer_variables_are_not_retrieved.snap index a5b71f74d2..d129640871 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__pointer_variables_are_not_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__pointer_variables_are_not_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 91..168, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 124..127, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__program_variables_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__program_variables_are_retrieved.snap index bad8e6bd2c..7358651b14 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__program_variables_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__program_variables_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 9..97, }, + varargs: None, }, ), ( @@ -54,6 +55,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 50..51, }, + varargs: None, }, ), ( @@ -82,6 +84,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 52..53, }, + varargs: None, }, ), ] diff --git a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__programs_are_retrieved.snap b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__programs_are_retrieved.snap index 2ed22bbcb8..ca656ccc41 100644 --- a/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__programs_are_retrieved.snap +++ b/src/index/tests/snapshots/rusty__index__tests__instance_resolver_tests__programs_are_retrieved.snap @@ -26,6 +26,7 @@ expression: "index.find_instances().collect::>>()" source_location: SourceRange { range: 9..45, }, + varargs: None, }, ), ] diff --git a/src/index/visitor.rs b/src/index/visitor.rs index f3a619455c..9b9622f652 100644 --- a/src/index/visitor.rs +++ b/src/index/visitor.rs @@ -45,13 +45,17 @@ pub fn visit_pou(index: &mut Index, pou: &Pou) { let mut member_names = vec![]; //register the pou's member variables + let mut member_varargs = None; let mut count = 0; - let mut varargs = None; for block in &pou.variable_blocks { let block_type = get_declaration_type_for(block); for var in &block.variables { - if let DataTypeDeclaration::DataTypeDefinition { - data_type: ast::DataType::VarArgs { referenced_type }, + let varargs = if let DataTypeDeclaration::DataTypeDefinition { + data_type: + ast::DataType::VarArgs { + referenced_type, + sized, + }, .. } = &var.data_type { @@ -60,45 +64,56 @@ pub fn visit_pou(index: &mut Index, pou: &Pou) { .map(|it| &**it) .and_then(DataTypeDeclaration::get_name) .map(|it| it.to_string()); - varargs = Some(name); - continue; + Some(if *sized { + VarArgs::Sized(name) + } else { + VarArgs::Unsized(name) + }) + } else { + None + }; + + if varargs.is_some() { + member_varargs = varargs.clone(); } + member_names.push(var.name.clone()); - let var_type_name = var.data_type.get_name().expect("named datatype"); - let type_name = if block_type.is_by_ref() { - //register a pointer type for argument - register_byref_pointer_type_for(index, var_type_name) - } else { - var_type_name.to_string() - }; - let initial_value = index - .get_mut_const_expressions() - .maybe_add_constant_expression( - var.initializer.clone(), - type_name.as_str(), - Some(pou.name.clone()), - ); + if let Some(var_type_name) = var.data_type.get_name() { + let type_name = if block_type.is_by_ref() { + //register a pointer type for argument + register_byref_pointer_type_for(index, var_type_name) + } else { + var_type_name.to_string() + }; + let initial_value = index + .get_mut_const_expressions() + .maybe_add_constant_expression( + var.initializer.clone(), + type_name.as_str(), + Some(pou.name.clone()), + ); - let binding = var - .address - .as_ref() - .and_then(|it| HardwareBinding::from_statement(index, it, Some(pou.name.clone()))); - - index.register_member_variable( - MemberInfo { - container_name: &pou.name, - variable_name: &var.name, - variable_linkage: block_type, - variable_type_name: &type_name, - is_constant: block.constant, - binding, - }, - initial_value, - var.location.clone(), - count, - ); - count += 1; + let binding = var.address.as_ref().and_then(|it| { + HardwareBinding::from_statement(index, it, Some(pou.name.clone())) + }); + + index.register_member_variable( + MemberInfo { + container_name: &pou.name, + variable_name: &var.name, + variable_linkage: block_type, + variable_type_name: &type_name, + is_constant: block.constant, + binding, + varargs, + }, + initial_value, + var.location.clone(), + count, + ); + count += 1; + } } } @@ -119,6 +134,7 @@ pub fn visit_pou(index: &mut Index, pou: &Pou) { variable_type_name: return_type_name, is_constant: false, //return variables are not constants binding: None, + varargs: None, }, None, source_location, @@ -126,14 +142,13 @@ pub fn visit_pou(index: &mut Index, pou: &Pou) { ) } - let has_varargs = varargs.is_some(); + let has_varargs = member_varargs.is_some(); let datatype = typesystem::DataType { name: pou.name.to_string(), initial_value: None, information: DataTypeInformation::Struct { name: interface_name, member_names, - varargs, source: StructSource::Pou(pou.pou_type.clone()), }, nature: TypeNature::Any, @@ -317,7 +332,6 @@ fn visit_data_type( let information = DataTypeInformation::Struct { name: type_name.clone(), member_names, - varargs: None, source: StructSource::OriginalDeclaration, }; @@ -385,6 +399,7 @@ fn visit_data_type( variable_type_name: member_type, is_constant: false, //struct members are not constants //TODO thats probably not true (you can define a struct in an CONST-block?!) binding, + varargs: None, }, init, var.location.clone(), diff --git a/src/lexer/tests/lexer_tests.rs b/src/lexer/tests/lexer_tests.rs index 31daa65b99..33f028a91f 100644 --- a/src/lexer/tests/lexer_tests.rs +++ b/src/lexer/tests/lexer_tests.rs @@ -69,12 +69,15 @@ fn undefined_pragmas_are_ignored_by_the_lexer() { #[test] fn registered_pragmas_parsed() { let mut lexer = lex(r" - {external}{ref}{not_registerd} + {external}{ref}{sized}{not_registerd} "); assert_eq!(lexer.token, PropertyExternal, "Token : {}", lexer.slice()); lexer.advance(); assert_eq!(lexer.token, PropertyByRef, "Token : {}", lexer.slice()); lexer.advance(); + assert_eq!(lexer.token, PropertySized, "Token : {}", lexer.slice()); + lexer.advance(); + assert_eq!(lexer.token, End); } #[test] diff --git a/src/lexer/tokens.rs b/src/lexer/tokens.rs index 5f9f1f3739..aef9ddb243 100644 --- a/src/lexer/tokens.rs +++ b/src/lexer/tokens.rs @@ -19,6 +19,9 @@ pub enum Token { #[token("{ref}")] PropertyByRef, + #[token("{sized}")] + PropertySized, + #[token("PROGRAM", ignore(case))] KeywordProgram, diff --git a/src/parser.rs b/src/parser.rs index 7de094c85a..d70302bc73 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -576,11 +576,13 @@ fn parse_full_data_type_definition( KeywordSemicolon }; parse_any_in_region(lexer, vec![end_keyword], |lexer| { + let sized = lexer.allow(&PropertySized); if lexer.allow(&KeywordDotDotDot) { Some(( DataTypeDeclaration::DataTypeDefinition { data_type: DataType::VarArgs { referenced_type: None, + sized, }, location: lexer.last_range.clone().into(), scope: lexer.scope.clone(), @@ -594,6 +596,7 @@ fn parse_full_data_type_definition( DataTypeDeclaration::DataTypeDefinition { data_type: DataType::VarArgs { referenced_type: Some(Box::new(type_def)), + sized, }, location: lexer.last_range.clone().into(), scope: lexer.scope.clone(), diff --git a/src/parser/tests/function_parser_tests.rs b/src/parser/tests/function_parser_tests.rs index 54bb6ab623..3f23abdecc 100644 --- a/src/parser/tests/function_parser_tests.rs +++ b/src/parser/tests/function_parser_tests.rs @@ -53,6 +53,7 @@ fn a_function_with_varargs_can_be_parsed() { data_type: DataTypeDefinition { data_type: VarArgs { referenced_type: None, + sized: false, }, }, }, @@ -90,6 +91,79 @@ fn a_function_with_typed_varargs_can_be_parsed() { referenced_type: "INT", }, ), + sized: false, + }, + }, + }, + ], + variable_block_type: Input( + ByVal, + ), + } + "###); +} + +#[test] +fn a_function_with_sized_varargs_can_be_parsed() { + let src = "FUNCTION foo : INT VAR_INPUT x : INT; y : {sized} ...; END_VAR END_FUNCTION"; + let result = parse(src).0; + + let prg = &result.units[0]; + let variable_block = &prg.variable_blocks[0]; + let ast_string = format!("{:#?}", variable_block); + insta::assert_snapshot!(ast_string, @r###" + VariableBlock { + variables: [ + Variable { + name: "x", + data_type: DataTypeReference { + referenced_type: "INT", + }, + }, + Variable { + name: "y", + data_type: DataTypeDefinition { + data_type: VarArgs { + referenced_type: None, + sized: true, + }, + }, + }, + ], + variable_block_type: Input( + ByVal, + ), + } + "###); +} + +#[test] +fn a_function_with_sized_typed_varargs_can_be_parsed() { + let src = "FUNCTION foo : INT VAR_INPUT x : INT; y : {sized} INT...; END_VAR END_FUNCTION"; + let result = parse(src).0; + + let prg = &result.units[0]; + let variable_block = &prg.variable_blocks[0]; + let ast_string = format!("{:#?}", variable_block); + insta::assert_snapshot!(ast_string,@r###" + VariableBlock { + variables: [ + Variable { + name: "x", + data_type: DataTypeReference { + referenced_type: "INT", + }, + }, + Variable { + name: "y", + data_type: DataTypeDefinition { + data_type: VarArgs { + referenced_type: Some( + DataTypeReference { + referenced_type: "INT", + }, + ), + sized: true, }, }, }, @@ -139,6 +213,7 @@ fn varargs_parameters_can_be_parsed() { data_type: DataTypeDeclaration::DataTypeDefinition { data_type: DataType::VarArgs { referenced_type: None, + sized: false, }, location: SourceRange::undefined(), scope: Some("foo".into()), @@ -157,6 +232,84 @@ fn varargs_parameters_can_be_parsed() { location: SourceRange::undefined(), }, )), + sized: false, + }, + location: SourceRange::undefined(), + scope: Some("foo".into()), + }, + initializer: None, + address: None, + location: SourceRange::undefined(), + }, + ], + }], + location: SourceRange::undefined(), + name_location: SourceRange::undefined(), + poly_mode: None, + generics: vec![], + linkage: crate::ast::LinkageType::Internal, + }; + assert_eq!(format!("{:#?}", expected), format!("{:#?}", x).as_str()); +} + +#[test] +fn sized_varargs_parameters_can_be_parsed() { + let src = " + FUNCTION foo : DINT + VAR_INPUT + args1 : {sized} ...; + args2 : {sized} INT...; + END_VAR + END_FUNCTION + "; + let (parse_result, diagnostics) = parse(src); + + assert_eq!( + format!("{:#?}", diagnostics), + format!("{:#?}", Vec::::new()).as_str() + ); + + let x = &parse_result.units[0]; + let expected = Pou { + name: "foo".into(), + pou_type: PouType::Function, + return_type: Some(DataTypeDeclaration::DataTypeReference { + referenced_type: "DINT".into(), + location: SourceRange::undefined(), + }), + variable_blocks: vec![VariableBlock { + constant: false, + access: AccessModifier::Protected, + retain: false, + variable_block_type: VariableBlockType::Input(ArgumentProperty::ByVal), + location: SourceRange::undefined(), + linkage: LinkageType::Internal, + variables: vec![ + Variable { + name: "args1".into(), + data_type: DataTypeDeclaration::DataTypeDefinition { + data_type: DataType::VarArgs { + referenced_type: None, + sized: true, + }, + location: SourceRange::undefined(), + scope: Some("foo".into()), + }, + initializer: None, + address: None, + location: SourceRange::undefined(), + }, + Variable { + name: "args2".into(), + data_type: DataTypeDeclaration::DataTypeDefinition { + data_type: DataType::VarArgs { + referenced_type: Some(Box::new( + DataTypeDeclaration::DataTypeReference { + referenced_type: "INT".into(), + location: SourceRange::undefined(), + }, + )), + sized: true, }, location: SourceRange::undefined(), scope: Some("foo".into()), @@ -327,8 +480,7 @@ fn function_inline_struct_return_unsupported() { // WHEN parsing is done let (_parse_result, diagnostics) = parse(function); // THEN there should be one diagnostic -> unsupported return type - assert_eq!( - true, + assert!( diagnostics.contains(&Diagnostic::function_unsupported_return_type( &DataTypeDeclaration::DataTypeDefinition { data_type: DataType::StructType { diff --git a/src/resolver.rs b/src/resolver.rs index 619dd5160b..9bfc25f46c 100644 --- a/src/resolver.rs +++ b/src/resolver.rs @@ -10,12 +10,14 @@ use std::collections::{HashMap, HashSet}; use indexmap::IndexMap; pub mod const_evaluator; +mod generics; use crate::{ ast::{ - self, AstId, AstStatement, CompilationUnit, DataType, DataTypeDeclaration, GenericBinding, - LinkageType, Operator, Pou, TypeNature, UserTypeDeclaration, Variable, + flatten_expression_list, AstId, AstStatement, CompilationUnit, DataType, + DataTypeDeclaration, Operator, Pou, TypeNature, UserTypeDeclaration, Variable, }, + builtins::{self, BuiltIn}, index::{Index, PouIndexEntry, VariableIndexEntry, VariableType}, typesystem::{ self, get_bigger_type, DataTypeInformation, StringEncoding, BOOL_TYPE, BYTE_TYPE, @@ -46,7 +48,7 @@ macro_rules! visit_all_statements { /// Helper methods `qualifier`, `current_pou` and `lhs_pou` copy the current context and /// change one field. #[derive(Clone)] -struct VisitorContext<'s> { +pub struct VisitorContext<'s> { /// the type_name of the context for a reference (e.g. `a.b` where `a`'s type is the context of `b`) qualifier: Option, /// optional context for references (e.g. `x` may mean `POU.x` if used inside `POU`'s body) @@ -116,8 +118,8 @@ impl<'s> VisitorContext<'s> { } pub struct TypeAnnotator<'i> { - index: &'i Index, - annotation_map: AnnotationMapImpl, + pub(crate) index: &'i Index, + pub(crate) annotation_map: AnnotationMapImpl, string_literals: StringLiterals, } @@ -195,7 +197,7 @@ impl From<&PouIndexEntry> for StatementAnnotation { } } -fn get_type_for_annotation<'a>( +pub fn get_type_for_annotation<'a>( index: &'a Index, annotation: &StatementAnnotation, ) -> Option<&'a typesystem::DataType> { @@ -702,6 +704,7 @@ impl<'i> TypeAnnotator<'i> { } => self.visit_data_type_declaration(ctx, referenced_type), DataType::VarArgs { referenced_type: Some(referenced_type), + .. } => { self.visit_data_type_declaration(ctx, referenced_type.as_ref()); } @@ -1150,93 +1153,8 @@ impl<'i> TypeAnnotator<'i> { } self.update_right_hand_side_expected_type(left, right); } - AstStatement::CallStatement { - parameters, - operator, - .. - } => { - self.visit_statement(ctx, operator); - let operator_qualifier = self - .annotation_map - .get(operator) - .and_then(|it| match it { - StatementAnnotation::Function { qualified_name, .. } => { - Some(qualified_name.clone()) - } - StatementAnnotation::Program { qualified_name } => { - Some(qualified_name.clone()) - } - StatementAnnotation::Variable { resulting_type, .. } => { - //lets see if this is a FB - self.index - .find_pou(resulting_type.as_str()) - .filter(|it| matches!(it, PouIndexEntry::FunctionBlock { .. })) - .map(|it| it.get_name().to_string()) - } - // call statements on array access "arr[1]()" will return a StatementAnnotation::Value - StatementAnnotation::Value { resulting_type } => { - // make sure we come from an array access - if let AstStatement::ArrayAccess { .. } = operator.as_ref() { - return Some(resulting_type.clone()); - } - None - } - _ => None, - }) - .unwrap_or_else(|| VOID_TYPE.to_string()); - let ctx = ctx.with_call(operator_qualifier.as_str()); - let mut generics_candidates: HashMap> = HashMap::new(); - let mut params = vec![]; - if let Some(s) = parameters.as_ref() { - self.visit_statement(&ctx, s); - if let Some(s) = parameters.as_ref() { - let parameters = ast::flatten_expression_list(s); - let all_members = self.index.get_container_members(&operator_qualifier); - let members = all_members.iter().filter(|it| it.is_parameter()); - for (i, m) in members.enumerate() { - if let Some(p) = parameters.get(i) { - //Add a possible generic candidate - if let Some((key, candidate)) = TypeAnnotator::get_generic_candidate( - self.index, - &self.annotation_map, - m, - p, - ) { - generics_candidates - .entry(key.to_string()) - .or_insert_with(std::vec::Vec::new) - .push(candidate.to_string()); - } else { - //Don't do this for generics - params.push((*p, m.get_type_name().to_string())); - } - } - } - } - } - for (p, name) in params { - self.annotate_parameters(p, &name); - } - - //Attempt to resolve the generic signature here - self.update_generic_call_statement( - generics_candidates, - &operator_qualifier, - operator, - parameters, - ctx, - ); - - if let Some(StatementAnnotation::Function { return_type, .. }) = - self.annotation_map.get(operator) - { - if let Some(return_type) = self.index.find_effective_type(return_type) { - self.annotation_map.annotate( - statement, - StatementAnnotation::value(return_type.get_name()), - ); - } - } + AstStatement::CallStatement { .. } => { + self.visit_call_statement(statement, ctx); } AstStatement::CastStatement { target, type_name, .. @@ -1274,287 +1192,140 @@ impl<'i> TypeAnnotator<'i> { } } - /// determines a possible generic for the current statement - /// returns a pair with the possible generics symbol and the real datatype - /// e.g. `( "T", "INT" )` - fn get_generic_candidate<'idx>( - index: &'idx Index, - annotation_map: &'idx AnnotationMapImpl, - member: &VariableIndexEntry, - statement: &AstStatement, - ) -> Option<(&'idx str, &'idx str)> { - //find inner type if this was turned into an array or pointer (if this is `POINTER TO T` lets find out what T is) - let effective_type = index.find_effective_type_info(member.get_type_name()); - let candidate = match effective_type { - Some(DataTypeInformation::Pointer { - inner_type_name, .. - }) - | Some(DataTypeInformation::Array { - inner_type_name, .. - }) => index.find_effective_type_info(inner_type_name), - _ => effective_type, + fn visit_call_statement(&mut self, statement: &AstStatement, ctx: &VisitorContext) { + let (operator, parameters_stmt) = if let AstStatement::CallStatement { + operator, + parameters, + .. + } = statement + { + (operator.as_ref(), parameters.as_ref().as_ref()) + } else { + unreachable!("Always a call statement"); }; - - //If generic add a generic annotation - if let Some(DataTypeInformation::Generic { generic_symbol, .. }) = candidate { - let statement = match statement { - //The right side of the assignment is the source of truth - AstStatement::Assignment { right, .. } => right, - _ => statement, - }; - //Find the statement's type - annotation_map - .get_type(statement, index) - .map(|it| (generic_symbol.as_str(), it.get_name())) + self.visit_statement(ctx, operator); + let operator_qualifier = self.get_call_name(operator); + let ctx = ctx.with_call(operator_qualifier.as_str()); + let parameters = if let Some(parameters) = parameters_stmt { + self.visit_statement(&ctx, parameters); + flatten_expression_list(parameters) } else { - None - } - } - - /// Updates the generic information of a function call - /// It collects all candidates for a generic function - /// Then chooses the best fitting function signature - /// And reannotates the function with the found information - fn update_generic_call_statement( - &mut self, - generics_candidates: HashMap>, - implementation_name: &str, - operator: &AstStatement, - parameters: &Option, - ctx: VisitorContext, - ) { - if let Some(PouIndexEntry::Function { - generics, linkage, .. - }) = self.index.find_pou(implementation_name) + vec![] + }; + if let Some(anntation) = + builtins::get_builtin(&operator_qualifier).and_then(BuiltIn::get_annotation) { - if linkage != &LinkageType::BuiltIn && !generics.is_empty() { - let generic_map = &self.derive_generic_types(generics, generics_candidates); - //Annotate the statement with the new function call - if let Some(StatementAnnotation::Function { - qualified_name, - return_type, - }) = self.annotation_map.get(operator) - { - //Figure out the new name for the call - let (new_name, annotation) = self.get_generic_function_annotation( - generics, - qualified_name, - return_type, - generic_map, - ); - - //Create a new pou and implementation for the function - let cloned_return_type = return_type.clone(); //borrow checker will not allow to use return_type below :-( - if let Some(pou) = self.index.find_pou(qualified_name) { - //only register concrete typed function if it was not indexed yet - if self.index.find_pou(new_name.as_str()).is_none() { - //register the pou-entry, implementation and member-variables for the requested (typed) implemmentation - // e.g. call to generic_foo(aInt) - self.register_generic_pou_entries( - pou, - cloned_return_type.as_str(), - new_name.as_str(), - generic_map, - ); - } + anntation(self, operator, ¶meters).unwrap(); + } else { + //If builtin, skip this + let mut generics_candidates: HashMap> = HashMap::new(); + let mut params = vec![]; + let mut parameters = parameters.into_iter(); + for m in self + .index + .get_declared_parameters(&operator_qualifier) + .into_iter() + { + if let Some(p) = parameters.next() { + let type_name = m.get_type_name(); + if let Some((key, candidate)) = TypeAnnotator::get_generic_candidate( + self.index, + &self.annotation_map, + type_name, + p, + ) { + generics_candidates + .entry(key.to_string()) + .or_insert_with(std::vec::Vec::new) + .push(candidate.to_string()) + } else { + params.push((p, type_name.to_string())) } - - //annotate the call-statement so it points to the new implementation - self.annotation_map.annotate(operator, annotation); } - //Adjust annotations on the inner statement - if let Some(s) = parameters.as_ref() { - self.visit_statement(&ctx, s); - self.update_generic_function_parameters(s, implementation_name, generic_map); + } + //We possibly did not consume all parameters, see if the variadic arguments are derivable + match self.index.find_pou(&operator_qualifier) { + Some(pou) if pou.is_variadic() => { + //get variadic argument type, if it is generic, update the generic candidates + if let Some(type_name) = self + .index + .get_variadic_member(pou.get_name()) + .map(VariableIndexEntry::get_type_name) + { + for parameter in parameters { + if let Some((key, candidate)) = TypeAnnotator::get_generic_candidate( + self.index, + &self.annotation_map, + type_name, + parameter, + ) { + generics_candidates + .entry(key.to_string()) + .or_insert_with(std::vec::Vec::new) + .push(candidate.to_string()) + } else { + params.push((parameter, type_name.to_string())) + } + } + } } + _ => {} } - } - } - - /// douplicates the given generic_function under the `new_name` (e.g. foo__INT__REAL)using the - /// real datatypes for the generics as given in `generics` (e.g. { T=INT, U=REAL}) - pub fn register_generic_pou_entries( - &mut self, - generic_function: &PouIndexEntry, - return_type: &str, - new_name: &str, - generics: &HashMap, - ) { - // the generic implementation - if let Some(generic_implementation) = generic_function.find_implementation(self.index) { - //register a copy of the generic's implemntation under the new name - self.annotation_map.new_index.register_implementation( - new_name, - new_name, - generic_implementation.get_associated_class_name(), - generic_implementation.get_implementation_type().clone(), - generic_implementation.generic, + for (p, name) in params { + self.annotate_parameters(p, &name); + } + //Attempt to resolve the generic signature here + self.update_generic_call_statement( + generics_candidates, + &operator_qualifier, + operator, + parameters_stmt, + ctx, ); - - //register a copy of the pou under the new name - self.annotation_map - .new_index - .register_pou(PouIndexEntry::create_function_entry( - new_name, - return_type, - &[], - LinkageType::External, //it has to be external, we should have already found this in the global index if it was internal - generic_function.is_variadic(), - )); - - // register the member-variables (interface) of the new function - // copy each member-index-entry and make sure to turn the generic (e.g. T) - // into the concrete type (e.g. INT) - if let Some(generic_function_members) = - self.index.get_members(generic_function.get_name()) - { - for (_, member) in generic_function_members { - let new_type_name = - if let Some(DataTypeInformation::Generic { generic_symbol, .. }) = - self.index.find_effective_type_info(member.get_type_name()) - { - // this is a generic member, so lets see what it's generic symbol is and translate it - generics - .get(generic_symbol) - .map(String::as_str) - .unwrap_or_else(|| member.get_type_name()) - } else { - // not a generic member, just use the original type - member.get_type_name() - }; - - //register the member under the new container (old: foo__T, new: foo__INT) - //with its new type-name (old: T, new: INT) - let entry = member.into_typed(new_name, new_type_name); - self.annotation_map - .new_index - .register_member_entry(new_name, entry); - } + } + if let Some(StatementAnnotation::Function { return_type, .. }) = + self.annotation_map.get(operator) + { + if let Some(return_type) = self.index.find_effective_type(return_type) { + self.annotation_map.annotate( + statement, + StatementAnnotation::value(return_type.get_name()), + ); } } } - fn update_generic_function_parameters( - &mut self, - s: &AstStatement, - function_name: &str, - generic_map: &HashMap, - ) { - /// An internal struct used to hold the type and nature of a generic parameter - struct TypeAndNature<'a> { - datatype: &'a typesystem::DataType, - nature: TypeNature, - } - - // Map the input or output parameters of the function into a list of Index Entry with an optional generic type discription - let parameters = ast::flatten_expression_list(s); - let all_members = self.index.get_container_members(function_name); - let members: Vec<(&VariableIndexEntry, Option)> = all_members - .iter() - .filter(|it| it.is_parameter()) - .copied() - .map(|it| { - //if the member is generic - if let Some(DataTypeInformation::Generic { - generic_symbol, - nature, - .. - }) = self.index.find_effective_type_info(it.get_type_name()) - { - let real_type = generic_map - .get(generic_symbol) - .and_then(|it| self.index.find_effective_type(it)) - .map(|datatype| TypeAndNature { - datatype, - nature: *nature, - }); - (it, real_type) - } else { - (it, None) + fn get_call_name(&mut self, operator: &AstStatement) -> String { + let operator_qualifier = self + .annotation_map + .get(operator) + .and_then(|it| match it { + StatementAnnotation::Function { qualified_name, .. } => { + Some(qualified_name.clone()) } - }) - .collect(); - - //See if parameters have assignments, as they need to be treated differently - if parameters.iter().any(|it| { - matches!( - it, - AstStatement::Assignment { .. } | AstStatement::OutputAssignment { .. } - ) - }) { - for p in parameters { - match p { - AstStatement::Assignment { left, right, .. } - | AstStatement::OutputAssignment { left, right, .. } => { - if let AstStatement::Reference { name, .. } = &**left { - //Find the member with that name - if let Some((_, Some(TypeAndNature { datatype, nature }))) = - members.iter().find(|(it, _)| it.get_name() == name) - { - self.annotation_map.add_generic_nature(p, *nature); - self.annotation_map.annotate( - left, - StatementAnnotation::value(datatype.get_name()), - ); - self.update_right_hand_side_expected_type(left, right); - } - } - } - _ => { /*do nothing*/ } + StatementAnnotation::Program { qualified_name } => Some(qualified_name.clone()), + StatementAnnotation::Variable { resulting_type, .. } => { + //lets see if this is a FB + self.index + .find_pou(resulting_type.as_str()) + .filter(|it| matches!(it, PouIndexEntry::FunctionBlock { .. })) + .map(|it| it.get_name().to_string()) } - } - } else { - for (i, (_, dt)) in members.iter().enumerate() { - if let Some(p) = parameters.get(i) { - if let Some(TypeAndNature { datatype, nature }) = dt { - self.annotation_map.add_generic_nature(p, *nature); - self.annotation_map - .annotate_type_hint(p, StatementAnnotation::value(datatype.get_name())); + // call statements on array access "arr[1]()" will return a StatementAnnotation::Value + StatementAnnotation::Value { resulting_type } => { + // make sure we come from an array access + if let AstStatement::ArrayAccess { .. } = operator { + return Some(resulting_type.clone()); } + None } - } - } - } - - fn get_generic_function_annotation( - &self, - generics: &[GenericBinding], - qualified_name: &str, - return_type: &str, - generic_map: &HashMap, - ) -> (String, StatementAnnotation) { - let generic_name = generics - .iter() - .map(|it| { - generic_map - .get(&it.name) - .map(String::as_str) - .unwrap_or_else(|| it.name.as_str()) + _ => None, }) - .collect::>() - .join("__"); - let function_name = format!("{}__{}", qualified_name, generic_name); - let return_type = if let DataTypeInformation::Generic { generic_symbol, .. } = - self.index.get_type_information_or_void(return_type) - { - generic_map - .get(generic_symbol) - .map(String::as_str) - .unwrap_or(return_type) - } else { - return_type - } - .to_string(); - ( - function_name.clone(), - StatementAnnotation::Function { - qualified_name: function_name, - return_type, - }, - ) + .unwrap_or_else(|| VOID_TYPE.to_string()); + operator_qualifier } - fn annotate_parameters(&mut self, p: &AstStatement, type_name: &str) { + pub(crate) fn annotate_parameters(&mut self, p: &AstStatement, type_name: &str) { if !matches!(p, AstStatement::Assignment { .. }) { if let Some(effective_member_type) = self.index.find_effective_type(type_name) { //update the type hint @@ -1630,42 +1401,6 @@ impl<'i> TypeAnnotator<'i> { _ => {} } } - - fn derive_generic_types( - &self, - generics: &[GenericBinding], - generics_candidates: HashMap>, - ) -> HashMap { - let mut generic_map: HashMap = HashMap::new(); - for GenericBinding { name, .. } in generics { - //Get the current binding - if let Some(candidates) = generics_candidates.get(name) { - //Find the best suiting type - let winner = candidates - .iter() - .fold( - None, - |previous_type: Option<&DataTypeInformation>, current| { - let current_type = self - .index - .find_effective_type_info(current) - .map(|it| self.index.find_intrinsic_type(it)); - //Find bigger - if let Some((previous, current)) = previous_type.zip(current_type) { - Some(typesystem::get_bigger_type(previous, current, self.index)) - } else { - current_type - } - }, - ) - .map(DataTypeInformation::get_name); - if let Some(winner) = winner { - generic_map.insert(name.into(), winner.into()); - } - } - } - generic_map - } } /// adds a string-type to the given index and returns it's name diff --git a/src/resolver/generics.rs b/src/resolver/generics.rs new file mode 100644 index 0000000000..c20e8b4b04 --- /dev/null +++ b/src/resolver/generics.rs @@ -0,0 +1,366 @@ +use std::collections::HashMap; + +use crate::{ + ast::{self, AstStatement, GenericBinding, LinkageType, TypeNature}, + index::{Index, PouIndexEntry, VariableIndexEntry}, + resolver::AnnotationMap, + typesystem::{self, DataTypeInformation}, +}; + +use super::{AnnotationMapImpl, StatementAnnotation, TypeAnnotator, VisitorContext}; + +// Utility methods handling generic resolution +impl<'i> TypeAnnotator<'i> { + /// determines a possible generic for the current statement + /// returns a pair with the possible generics symbol and the real datatype + /// e.g. `( "T", "INT" )` + pub(super) fn get_generic_candidate<'idx>( + index: &'idx Index, + annotation_map: &'idx AnnotationMapImpl, + type_name: &str, + statement: &AstStatement, + ) -> Option<(&'idx str, &'idx str)> { + //find inner type if this was turned into an array or pointer (if this is `POINTER TO T` lets find out what T is) + let effective_type = index.find_effective_type_info(type_name); + let candidate = match effective_type { + Some(DataTypeInformation::Pointer { + inner_type_name, .. + }) + | Some(DataTypeInformation::Array { + inner_type_name, .. + }) => index.find_effective_type_info(inner_type_name), + _ => effective_type, + }; + + //If generic add a generic annotation + if let Some(DataTypeInformation::Generic { generic_symbol, .. }) = candidate { + let statement = match statement { + //The right side of the assignment is the source of truth + AstStatement::Assignment { right, .. } => right, + _ => statement, + }; + //Find the statement's type + annotation_map + .get_type(statement, index) + .map(|it| (generic_symbol.as_str(), it.get_name())) + } else { + None + } + } + + /// Updates the generic information of a function call + /// It collects all candidates for a generic function + /// Then chooses the best fitting function signature + /// And reannotates the function with the found information + pub(super) fn update_generic_call_statement( + &mut self, + generics_candidates: HashMap>, + implementation_name: &str, + operator: &AstStatement, + parameters: Option<&AstStatement>, + ctx: VisitorContext, + ) { + if let Some(PouIndexEntry::Function { + generics, linkage, .. + }) = self.index.find_pou(implementation_name) + { + if !generics.is_empty() { + let generic_map = &self.derive_generic_types(generics, generics_candidates); + //Annotate the statement with the new function call + if let Some(StatementAnnotation::Function { + qualified_name, + return_type, + }) = self.annotation_map.get(operator) + { + let cloned_return_type = return_type.clone(); //borrow checker will not allow to use return_type below :-( + //Figure out the new name for the call + let (new_name, annotation) = self.get_generic_function_annotation( + *linkage, + generics, + qualified_name, + return_type, + generic_map, + ); + + //Create a new pou and implementation for the function + if let Some(pou) = self.index.find_pou(qualified_name) { + //only register concrete typed function if it was not indexed yet + if self.index.find_pou(new_name.as_str()).is_none() { + //register the pou-entry, implementation and member-variables for the requested (typed) implemmentation + // e.g. call to generic_foo(aInt) + self.register_generic_pou_entries( + pou, + cloned_return_type.as_str(), + new_name.as_str(), + generic_map, + ); + } + } + + //annotate the call-statement so it points to the new implementation + self.annotation_map.annotate(operator, annotation); + } + //Adjust annotations on the inner statement + if let Some(s) = parameters.as_ref() { + self.visit_statement(&ctx, s); + self.update_generic_function_parameters(s, implementation_name, generic_map); + } + } + } + } + + /// douplicates the given generic_function under the `new_name` (e.g. foo__INT__REAL)using the + /// real datatypes for the generics as given in `generics` (e.g. { T=INT, U=REAL}) + pub fn register_generic_pou_entries( + &mut self, + generic_function: &PouIndexEntry, + return_type: &str, + new_name: &str, + generics: &HashMap, + ) { + // the generic implementation + if let Some(generic_implementation) = generic_function.find_implementation(self.index) { + //register a copy of the generic's implemntation under the new name + self.annotation_map.new_index.register_implementation( + new_name, + new_name, + generic_implementation.get_associated_class_name(), + generic_implementation.get_implementation_type().clone(), + false, + ); + + //register a copy of the pou under the new name + self.annotation_map + .new_index + .register_pou(PouIndexEntry::create_function_entry( + new_name, + return_type, + &[], + LinkageType::External, //it has to be external, we should have already found this in the global index if it was internal + generic_function.is_variadic(), + )); + + // register the member-variables (interface) of the new function + // copy each member-index-entry and make sure to turn the generic (e.g. T) + // into the concrete type (e.g. INT) + if let Some(generic_function_members) = + self.index.get_members(generic_function.get_name()) + { + for (_, member) in generic_function_members { + let new_type_name = + if let Some(DataTypeInformation::Generic { generic_symbol, .. }) = + self.index.find_effective_type_info(member.get_type_name()) + { + // this is a generic member, so lets see what it's generic symbol is and translate it + generics + .get(generic_symbol) + .map(String::as_str) + .unwrap_or_else(|| member.get_type_name()) + } else { + // not a generic member, just use the original type + member.get_type_name() + }; + + //register the member under the new container (old: foo__T, new: foo__INT) + //with its new type-name (old: T, new: INT) + let entry = member.into_typed(new_name, new_type_name); + self.annotation_map + .new_index + .register_member_entry(new_name, entry); + } + } + } + } + + fn update_generic_function_parameters( + &mut self, + s: &AstStatement, + function_name: &str, + generic_map: &HashMap, + ) { + /// An internal struct used to hold the type and nature of a generic parameter + struct TypeAndNature<'a> { + datatype: &'a typesystem::DataType, + nature: TypeNature, + } + + // Map the input or output parameters of the function into a list of Index Entry with an optional generic type discription + let parameters = ast::flatten_expression_list(s); + let members: Vec<(&VariableIndexEntry, Option)> = self + .index + .get_declared_parameters(function_name) + .into_iter() + .map(|it| { + //if the member is generic + if let Some(DataTypeInformation::Generic { + generic_symbol, + nature, + .. + }) = self.index.find_effective_type_info(it.get_type_name()) + { + let real_type = generic_map + .get(generic_symbol) + .and_then(|it| self.index.find_effective_type(it)) + .map(|datatype| TypeAndNature { + datatype, + nature: *nature, + }); + (it, real_type) + } else { + (it, None) + } + }) + .collect(); + + //See if parameters have assignments, as they need to be treated differently + if parameters.iter().any(|it| { + matches!( + it, + AstStatement::Assignment { .. } | AstStatement::OutputAssignment { .. } + ) + }) { + for p in parameters { + match p { + AstStatement::Assignment { left, right, .. } + | AstStatement::OutputAssignment { left, right, .. } => { + if let AstStatement::Reference { name, .. } = &**left { + //Find the member with that name + if let Some((_, Some(TypeAndNature { datatype, nature }))) = + members.iter().find(|(it, _)| it.get_name() == name) + { + self.annotation_map.add_generic_nature(p, *nature); + self.annotation_map.annotate( + left, + StatementAnnotation::value(datatype.get_name()), + ); + self.update_right_hand_side_expected_type(left, right); + } + } + } + _ => { /*do nothing*/ } + } + } + } else { + //First handle the declared params + let mut parameters = parameters.into_iter(); + for (_, dt) in members { + if let Some(p) = parameters.next() { + if let Some(TypeAndNature { datatype, nature }) = dt { + self.annotation_map.add_generic_nature(p, nature); + self.annotation_map + .annotate_type_hint(p, StatementAnnotation::value(datatype.get_name())); + } + } + } + //Then handle the varargs + //Get the variadic argument if any + if let Some(dt) = self.index.get_variadic_member(function_name).map(|it| { + //if the member is generic + if let Some(DataTypeInformation::Generic { + generic_symbol, + nature, + .. + }) = self.index.find_effective_type_info(it.get_type_name()) + { + let real_type = generic_map + .get(generic_symbol) + .and_then(|it| self.index.find_effective_type(it)) + .map(|datatype| TypeAndNature { + datatype, + nature: *nature, + }); + real_type + } else { + None + } + }) { + for p in parameters { + if let Some(TypeAndNature { datatype, nature }) = dt { + self.annotation_map.add_generic_nature(p, nature); + self.annotation_map + .annotate_type_hint(p, StatementAnnotation::value(datatype.get_name())); + } + } + } + } + } + pub fn get_generic_function_annotation( + &self, + linkage: LinkageType, + generics: &[GenericBinding], + qualified_name: &str, + return_type: &str, + generic_map: &HashMap, + ) -> (String, StatementAnnotation) { + let generic_name = generics + .iter() + .map(|it| { + generic_map + .get(&it.name) + .map(String::as_str) + .unwrap_or_else(|| it.name.as_str()) + }) + .collect::>() + .join("__"); + let function_name = if linkage == LinkageType::BuiltIn { + qualified_name.to_string() + } else { + format!("{}__{}", qualified_name, generic_name) + }; + let return_type = if let DataTypeInformation::Generic { generic_symbol, .. } = + self.index.get_type_information_or_void(return_type) + { + generic_map + .get(generic_symbol) + .map(String::as_str) + .unwrap_or(return_type) + } else { + return_type + } + .to_string(); + ( + function_name.clone(), + StatementAnnotation::Function { + qualified_name: function_name, + return_type, + }, + ) + } + + /// Derives the correct type for the generic call from the list of parameters + pub fn derive_generic_types( + &self, + generics: &[GenericBinding], + generics_candidates: HashMap>, + ) -> HashMap { + let mut generic_map: HashMap = HashMap::new(); + for GenericBinding { name, .. } in generics { + //Get the current binding + if let Some(candidates) = generics_candidates.get(name) { + //Find the best suiting type + let winner = candidates + .iter() + .fold( + None, + |previous_type: Option<&DataTypeInformation>, current| { + let current_type = self + .index + .find_effective_type_info(current) + .map(|it| self.index.find_intrinsic_type(it)); + //Find bigger + if let Some((previous, current)) = previous_type.zip(current_type) { + Some(typesystem::get_bigger_type(previous, current, self.index)) + } else { + current_type + } + }, + ) + .map(DataTypeInformation::get_name); + if let Some(winner) = winner { + generic_map.insert(name.into(), winner.into()); + } + } + } + generic_map + } +} diff --git a/src/resolver/tests/resolve_expressions_tests.rs b/src/resolver/tests/resolve_expressions_tests.rs index b05defc7fa..607f30f4bd 100644 --- a/src/resolver/tests/resolve_expressions_tests.rs +++ b/src/resolver/tests/resolve_expressions_tests.rs @@ -2739,13 +2739,10 @@ fn resolve_function_with_same_name_as_return_type() { let effective_type = index.find_effective_type("TIME").unwrap(); assert_eq!(effective_type, associated_type); // AND should be Integer - assert_eq!( - true, - matches!( - effective_type.get_type_information(), - DataTypeInformation::Integer { .. } - ) - ) + assert!(matches!( + effective_type.get_type_information(), + DataTypeInformation::Integer { .. } + )) } #[test] @@ -2979,10 +2976,7 @@ fn call_on_function_block_array() { AstStatement::CallStatement { operator, .. } => Some(operator.as_ref()), _ => None, }; - assert_eq!( - matches!(operator, Some(&AstStatement::ArrayAccess { .. })), - true - ); + assert!(matches!(operator, Some(&AstStatement::ArrayAccess { .. })),); let annotation = annotations.get(operator.unwrap()); assert_eq!( diff --git a/src/resolver/tests/resolve_generic_calls.rs b/src/resolver/tests/resolve_generic_calls.rs index 9aedd34156..ee9082b7c2 100644 --- a/src/resolver/tests/resolve_generic_calls.rs +++ b/src/resolver/tests/resolve_generic_calls.rs @@ -1,9 +1,9 @@ use crate::{ assert_type_and_hint, - ast::{self, AstStatement}, + ast::{self, flatten_expression_list, AstStatement}, resolver::{AnnotationMap, TypeAnnotator}, test_utils::tests::index, - typesystem::{BYTE_TYPE, DINT_TYPE, INT_TYPE, LWORD_TYPE, REAL_TYPE}, + typesystem::{BYTE_TYPE, DINT_TYPE, INT_TYPE, LREAL_TYPE, LWORD_TYPE, REAL_TYPE, SINT_TYPE}, }; #[test] @@ -522,4 +522,197 @@ fn builtin_generic_functions_do_not_get_specialized_calls() { //The return type should have the correct type assert_type_and_hint!(&annotations, &index, call, LWORD_TYPE, None); + + //The parameter should have the correct (original) type + if let AstStatement::CallStatement { parameters, .. } = call { + let params = flatten_expression_list(parameters.as_ref().as_ref().unwrap()); + assert_type_and_hint!(&annotations, &index, params[0], DINT_TYPE, Some(DINT_TYPE)); + } else { + panic!("Expected call statement") + } + let call = &unit.implementations[0].statements[2]; + if let AstStatement::CallStatement { parameters, .. } = call { + let params = flatten_expression_list(parameters.as_ref().as_ref().unwrap()); + assert_type_and_hint!(&annotations, &index, params[0], REAL_TYPE, Some(REAL_TYPE)); + } else { + panic!("Expected call statement") + } +} + +#[test] +fn builtin_sel_param_type_is_not_changed() { + let (unit, index) = index( + " + FUNCTION test : DINT + VAR + a,b: DINT; + END_VAR + SEL(FALSE,a,b); + END_FUNCTION + ", + ); + + let (annotations, _) = TypeAnnotator::visit_unit(&index, &unit); + //get the type/hints for a and b in the call, they should be unchanged (DINT, None) + let call = &unit.implementations[0].statements[0]; + if let AstStatement::CallStatement { parameters, .. } = call { + let params = flatten_expression_list(parameters.as_ref().as_ref().unwrap()); + assert_type_and_hint!(&annotations, &index, params[1], DINT_TYPE, Some(DINT_TYPE)); + assert_type_and_hint!(&annotations, &index, params[2], DINT_TYPE, Some(DINT_TYPE)); + } else { + panic!("Expected call statement") + } +} + +#[test] +fn resolve_variadic_generics() { + let (unit, index) = index( + " + FUNCTION ex : U + VAR_INPUT + ar : {sized}U...; + END_VAR + END_FUNCTION + + FUNCTION test : DINT + VAR + a,b: DINT; + END_VAR + ex(a,b); + END_FUNCTION + ", + ); + + let (annotations, _) = TypeAnnotator::visit_unit(&index, &unit); + //ex should resolve to ex__dint + //a and b have the type dint + let call = &unit.implementations[1].statements[0]; + //The call statement should return a DINT + assert_type_and_hint!(&annotations, &index, call, DINT_TYPE, None); + if let AstStatement::CallStatement { + operator, + parameters, + .. + } = call + { + assert_eq!(Some("ex__DINT"), annotations.get_call_name(operator)); + let params = flatten_expression_list(parameters.as_ref().as_ref().unwrap()); + assert_type_and_hint!(&annotations, &index, params[0], DINT_TYPE, Some(DINT_TYPE)); + assert_type_and_hint!(&annotations, &index, params[1], DINT_TYPE, Some(DINT_TYPE)); + } else { + panic!("Expected call statement") + } +} + +#[test] +fn generic_call_gets_cast_to_biggest_type() { + let (unit, index) = index( + r" + + {external} + FUNCTION MAX : T + VAR_INPUT + args : {sized} T...; + END_VAR + END_FUNCTION + + FUNCTION main : LREAL + MAX(SINT#5,DINT#1,LREAL#1.5,1.2); + END_FUNCTION", + ); + + //Expecting all values to be LREAL + let (annotations, _) = TypeAnnotator::visit_unit(&index, &unit); + let call = &unit.implementations[1].statements[0]; + assert_type_and_hint!(&annotations, &index, call, LREAL_TYPE, None); + //Call returns LREAL + if let AstStatement::CallStatement { parameters, .. } = call { + let params = ast::flatten_expression_list(parameters.as_ref().as_ref().unwrap()); + assert_type_and_hint!(&annotations, &index, params[0], SINT_TYPE, Some(LREAL_TYPE)); + assert_type_and_hint!(&annotations, &index, params[1], DINT_TYPE, Some(LREAL_TYPE)); + assert_type_and_hint!( + &annotations, + &index, + params[2], + LREAL_TYPE, + Some(LREAL_TYPE) + ); + assert_type_and_hint!(&annotations, &index, params[3], REAL_TYPE, Some(LREAL_TYPE)); + } else { + panic!("Expected call statement") + } +} + +#[test] +fn sel_return_type_follows_params() { + let (unit, index) = index( + " + FUNCTION main + SEL(TRUE,1,2); + SEL(TRUE,1,2) + 10; + 15 + SEL(TRUE,1,2); + END_FUNCTION", + ); + + let (annotations, _) = TypeAnnotator::visit_unit(&index, &unit); + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[0], + DINT_TYPE, + None + ); + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[1], + DINT_TYPE, + None + ); + //Also test that the left side of the operator is dint + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[2], + DINT_TYPE, + None + ); + //Also test that the right side of the operator is dint +} + +#[test] +fn mux_return_type_follows_params() { + let (unit, index) = index( + " + FUNCTION main + MUX(0,1,2); + MUX(0,1,2) + 10; + 15 + MUX(0,1,2); + END_FUNCTION", + ); + + let (annotations, _) = TypeAnnotator::visit_unit(&index, &unit); + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[0], + DINT_TYPE, + None + ); + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[1], + DINT_TYPE, + None + ); + //Also test that the left side of the operator is dint + assert_type_and_hint!( + &annotations, + &index, + &unit.implementations[0].statements[2], + DINT_TYPE, + None + ); + //Also test that the right side of the operator is dint } diff --git a/src/resolver/tests/resolve_literals_tests.rs b/src/resolver/tests/resolve_literals_tests.rs index c055f31b3c..8596690b02 100644 --- a/src/resolver/tests/resolve_literals_tests.rs +++ b/src/resolver/tests/resolve_literals_tests.rs @@ -488,10 +488,7 @@ fn expression_list_as_array_initilization_is_annotated_correctly() { for exp in expressions { if let Some(data_type) = annotations.get_type_hint(exp, &index) { let type_info = data_type.get_type_information(); - assert_eq!( - true, - matches!(type_info, DataTypeInformation::Integer { .. }) - ) + assert!(matches!(type_info, DataTypeInformation::Integer { .. })) } else { unreachable!(); } diff --git a/src/runner.rs b/src/runner.rs index 54464b5087..e7c1071b49 100644 --- a/src/runner.rs +++ b/src/runner.rs @@ -95,6 +95,8 @@ pub fn compile(context: &Context, source: T) -> ExecutionEngine { Diagnostician::null_diagnostician(), ) .unwrap(); + #[cfg(feature = "debug")] + code_gen.module.print_to_stderr(); code_gen .module .create_jit_execution_engine(inkwell::OptimizationLevel::None) diff --git a/src/test_utils.rs b/src/test_utils.rs index 3d0a6fa008..f27270093e 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -38,6 +38,7 @@ pub mod tests { let mut index = Index::default(); //Import builtins let builtins = builtins::parse_built_ins(id_provider.clone()); + index.import(index::visitor::visit(&builtins, id_provider.clone())); let (mut unit, ..) = parser::parse( diff --git a/src/tests/adr/pou_adr.rs b/src/tests/adr/pou_adr.rs index b70c56de98..2ec3364b7c 100644 --- a/src/tests/adr/pou_adr.rs +++ b/src/tests/adr/pou_adr.rs @@ -65,7 +65,6 @@ fn programs_state_is_stored_in_a_struct() { "v", "vt", ], - varargs: None, source: Pou( Program, ), diff --git a/src/typesystem.rs b/src/typesystem.rs index f578fe30a0..41f31108e3 100644 --- a/src/typesystem.rs +++ b/src/typesystem.rs @@ -108,7 +108,25 @@ impl DataType { } } -type VarArgs = Option; +#[derive(Debug, Clone, PartialEq)] +pub enum VarArgs { + Sized(Option), + Unsized(Option), +} + +impl VarArgs { + pub fn is_sized(&self) -> bool { + matches!(self, VarArgs::Sized(..)) + } + + pub fn as_typed(&self, new_type: &str) -> VarArgs { + match self { + VarArgs::Sized(Some(_)) => VarArgs::Sized(Some(new_type.to_string())), + VarArgs::Unsized(Some(_)) => VarArgs::Unsized(Some(new_type.to_string())), + _ => self.clone(), + } + } +} #[derive(Debug, Clone, PartialEq)] pub enum StringEncoding { @@ -177,7 +195,6 @@ pub enum DataTypeInformation { Struct { name: TypeId, member_names: Vec, - varargs: Option, source: StructSource, }, Array { @@ -314,28 +331,6 @@ impl DataTypeInformation { ) } - pub fn is_variadic(&self) -> bool { - matches!( - self, - DataTypeInformation::Struct { - varargs: Some(_), - .. - } - ) - } - - pub fn get_variadic_type(&self) -> Option<&str> { - if let DataTypeInformation::Struct { - varargs: Some(inner_type), - .. - } = &self - { - inner_type.as_ref().map(String::as_str) - } else { - None - } - } - pub fn is_generic(&self, index: &Index) -> bool { match self { DataTypeInformation::Array { diff --git a/src/validation.rs b/src/validation.rs index bc243cf09d..47fb7c8a3a 100644 --- a/src/validation.rs +++ b/src/validation.rs @@ -124,8 +124,11 @@ impl Validator { context: &ValidationContext, container: &VariableBlock, ) { - self.variable_validator - .validate_variable_block(container, context); + self.variable_validator.validate_variable_block(container); + + for variable in &container.variables { + self.visit_variable(context, variable); + } } pub fn visit_variable(&mut self, context: &ValidationContext, variable: &Variable) { @@ -170,6 +173,7 @@ impl Validator { } => self.visit_data_type_declaration(context, referenced_type), DataType::VarArgs { referenced_type: Some(referenced_type), + .. } => { self.visit_data_type_declaration(context, referenced_type.as_ref()); } diff --git a/src/validation/tests/variable_validation_tests.rs b/src/validation/tests/variable_validation_tests.rs index 6fa1652a5e..05575f26ab 100644 --- a/src/validation/tests/variable_validation_tests.rs +++ b/src/validation/tests/variable_validation_tests.rs @@ -173,3 +173,27 @@ fn constant_fb_instances_are_illegal() { ] ); } + +#[test] +fn sized_varargs_require_type() { + // GIVEN a function with a untyped sized variadic argument + // WHEN it is validated + let diagnostics = parse_and_validate( + " + FUNCTION f_with_var : INT + VAR_INPUT + in : INT; + args : {sized}...; + END_VAR + END_FUNCTION + ", + ); + + assert_eq!( + diagnostics, + vec![Diagnostic::missing_datatype( + Some(": Sized Variadics require a known datatype."), + (103..106).into() + ),] + ) +} diff --git a/src/validation/variable_validator.rs b/src/validation/variable_validator.rs index 0b9f995006..64aabd51f8 100644 --- a/src/validation/variable_validator.rs +++ b/src/validation/variable_validator.rs @@ -23,7 +23,7 @@ impl VariableValidator { } } - pub fn validate_variable_block(&mut self, block: &VariableBlock, context: &ValidationContext) { + pub fn validate_variable_block(&mut self, block: &VariableBlock) { if block.constant && !matches!( block.variable_block_type, @@ -33,10 +33,6 @@ impl VariableValidator { self.diagnostics .push(Diagnostic::invalid_constant_block(block.location.clone())) } - - for variable in &block.variables { - self.validate_variable(variable, context); - } } pub fn validate_variable(&mut self, variable: &Variable, context: &ValidationContext) { @@ -104,6 +100,13 @@ impl VariableValidator { self.diagnostics .push(Diagnostic::empty_variable_block(location.clone())); } + DataType::VarArgs { + referenced_type: None, + sized: true, + } => self.diagnostics.push(Diagnostic::missing_datatype( + Some(": Sized Variadics require a known datatype."), + location.clone(), + )), _ => {} } } diff --git a/tests/correctness/functions.rs b/tests/correctness/functions.rs index 08ff15cd69..7bfd8d8b5d 100644 --- a/tests/correctness/functions.rs +++ b/tests/correctness/functions.rs @@ -1,3 +1,5 @@ +use rusty::runner::run_no_param; + // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder use super::super::*; @@ -745,3 +747,122 @@ fn by_ref_and_by_val_mixed_function_call() { let res: i32 = compile_and_run(function.to_string(), &mut MainType::default()); assert_eq!(res, 11_110) } + +#[test] +fn mux_test() { + let function = r#" + FUNCTION main : DINT + VAR + num,b : DINT := 2; + END_VAR + b := num; + main := MUX(num,b,5,6,7,8); //Result is 6 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 6) +} + +#[test] +fn mux_test_variables() { + let function = r#" + FUNCTION main : DINT + VAR + num,b,c,d,e,f : DINT; + END_VAR + num := 2; + b := 4; + c := 5; + d := 6; + e := 7; + f := 8; + main := MUX(num,b,c,d,e,f); //Result is 6 (d) + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 6) +} + +#[test] +fn sel_test_false() { + let function = r#" + FUNCTION main : DINT + main := SEL(FALSE,4,5); //Result is 4 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 4) +} + +#[test] +fn sel_test_true() { + let function = r#" + FUNCTION main : DINT + main := SEL(TRUE,4,5); //Result is 5 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 5) +} + +#[test] +fn sel_test_true_vars() { + let function = r#" + FUNCTION main : DINT + VAR a,b : DINT; END_VAR + a := 4; + b := 5; + main := SEL(TRUE,a,b); //Result is 5 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 5) +} + +#[test] +fn sel_expression_test() { + let function = r#" + FUNCTION main : DINT + VAR a,b : DINT; END_VAR + a := 4; + b := 5; + main := SEL(TRUE,a,b) + 10; //Result is 15 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 15); +} + +#[test] +fn move_test() { + let function = r#" + FUNCTION main : DINT + VAR a : DINT; END_VAR + a := 4; + main := MOVE(a); //Result is 4 + END_FUNCTION + "#; + + let context = Context::create(); + let exec_engine = compile(&context, function); + let res: i32 = run_no_param(&exec_engine, "main"); + assert_eq!(res, 4) +}