Support case insesitive keywords

src/codegen/generators/data_type_generator.rs

@@ -234,8 +234,8 @@ fn register_aliased_initial_value<'ink>(
  } else {
  // if there's no initializer defined for this alias, we go and check the aliased type for an initial value
  index
- .get_types()
- .get(referenced_type)
+ .get_type(referenced_type)
+ .ok()
  .and_then(|referenced_data_type| {
  generate_initial_value(index, types_index, llvm, referenced_data_type)
  })

src/codegen/llvm_index.rs

@@ -60,7 +60,8 @@ impl<'ink> LlvmTypedIndex<'ink> {
  type_name: &str,
  target_type: BasicTypeEnum<'ink>,
  ) -> Result<(), CompileError> {
- self.type_associations.insert(type_name.into(), target_type);
+ self.type_associations
+ .insert(type_name.to_lowercase(), target_type);
  Ok(())
  }
 
@@ -70,7 +71,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  initial_value: BasicValueEnum<'ink>,
  ) -> Result<(), CompileError> {
  self.initial_value_associations
- .insert(type_name.into(), initial_value);
+ .insert(type_name.to_lowercase(), initial_value);
  Ok(())
  }
 
@@ -82,16 +83,19 @@ impl<'ink> LlvmTypedIndex<'ink> {
  ) -> Result<(), CompileError> {
  let qualified_name = format!("{}.{}", container_name, variable_name);
  self.loaded_variable_associations
- .insert(qualified_name, target_value);
+ .insert(qualified_name.to_lowercase(), target_value);
  Ok(())
  }
 
  pub fn find_associated_type(&self, type_name: &str) -> Option<BasicTypeEnum<'ink>> {
- self.type_associations.get(type_name).copied().or_else(|| {
- self.parent_index
- .map(|it| it.find_associated_type(type_name))
- .flatten()
- })
+ self.type_associations
+ .get(&type_name.to_lowercase())
+ .copied()
+ .or_else(|| {
+ self.parent_index
+ .map(|it| it.find_associated_type(type_name))
+ .flatten()
+ })
  }
 
  pub fn get_associated_type(
@@ -104,7 +108,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
 
  pub fn find_associated_initial_value(&self, type_name: &str) -> Option<BasicValueEnum<'ink>> {
  self.initial_value_associations
- .get(type_name)
+ .get(&type_name.to_lowercase())
  .copied()
  .or_else(|| {
  self.parent_index
@@ -119,7 +123,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  global_variable: GlobalValue<'ink>,
  ) -> Result<(), CompileError> {
  self.initial_value_associations.insert(
- variable_name.into(),
+ variable_name.to_lowercase(),
  global_variable.as_pointer_value().into(),
  );
  Ok(())
@@ -131,7 +135,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  function_value: FunctionValue<'ink>,
  ) -> Result<(), CompileError> {
  self.implementations
- .insert(callable_name.into(), function_value);
+ .insert(callable_name.to_lowercase(), function_value);
  Ok(())
  }
 
@@ -140,7 +144,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  callable_name: &str,
  ) -> Option<FunctionValue<'ink>> {
  self.implementations
- .get(callable_name)
+ .get(&callable_name.to_lowercase())
  .copied()
  .or_else(|| {
  self.parent_index
@@ -154,7 +158,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  qualified_name: &str,
  ) -> Option<BasicValueEnum<'ink>> {
  self.initial_value_associations
- .get(qualified_name)
+ .get(&qualified_name.to_lowercase())
  .copied()
  .or_else(|| {
  self.parent_index
@@ -169,7 +173,7 @@ impl<'ink> LlvmTypedIndex<'ink> {
  ) -> Option<PointerValue<'ink>> {
  let result = self
  .loaded_variable_associations
- .get(qualified_name)
+ .get(&qualified_name.to_lowercase())
  .copied()
  .or_else(|| {
  self.parent_index

src/codegen/tests/code_gen_tests.rs

@@ -163,6 +163,7 @@ entry:
 
  assert_eq!(result, expected);
 }
+
 #[test]
 fn program_with_variables_generates_void_function_and_struct() {
  let result = codegen!(
@@ -580,6 +581,42 @@ entry:
  assert_eq!(result, expected);
 }
 
+#[test]
+fn different_case_references() {
+ let result = codegen!(
+ r#"
+TYPE MyInt: INT := 1; END_TYPE
+TYPE MyDInt: DINT := 2; END_TYPE
+
+PROGRAM prg
+VAR
+y : int;
+z : MyInt;
+zz : Mydint;
+END_VAR
+END_PROGRAM
+"#
+ );
+
+ let expected = r#"; ModuleID = 'main'
+source_filename = "main"
+
+%prg_interface = type { i16, i16, i32 }
+
+@prg_instance = global %prg_interface { i16 0, i32 1, i32 2 }
+
+define void @prg(%prg_interface* %0) {
+entry:
+ %y = getelementptr inbounds %prg_interface, %prg_interface* %0, i32 0, i32 0
+ %z = getelementptr inbounds %prg_interface, %prg_interface* %0, i32 0, i32 1
+ %zz = getelementptr inbounds %prg_interface, %prg_interface* %0, i32 0, i32 2
+ ret void
+}
+"#;
+
+ assert_eq!(result, expected);
+}
+
 #[test]
 fn program_with_string_type_assignment() {
  let result = codegen!(

src/index.rs

@@ -193,26 +193,26 @@ impl Index {
  }
 
  pub fn find_global_variable(&self, name: &str) -> Option<&VariableIndexEntry> {
- self.global_variables.get(name)
+ self.global_variables.get(&name.to_lowercase())
  }
 
  pub fn find_member(&self, pou_name: &str, variable_name: &str) -> Option<&VariableIndexEntry> {
  self.member_variables
- .get(pou_name)
- .and_then(|map| map.get(variable_name))
+ .get(&pou_name.to_lowercase())
+ .and_then(|map| map.get(&variable_name.to_lowercase()))
  }
 
  pub fn find_local_members(&self, container_name: &str) -> Vec<&VariableIndexEntry> {
  self.member_variables
- .get(container_name)
+ .get(&container_name.to_lowercase())
  .map(|it| it.values().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
  pub fn is_declared_parameter(&self, pou_name: &str, index: u32) -> bool {
  self.member_variables
- .get(pou_name)
+ .get(&pou_name.to_lowercase())
  .and_then(|map| {
  map.values()
  .filter(|item| {
@@ -226,11 +226,13 @@ impl Index {
  }
 
  pub fn find_input_parameter(&self, pou_name: &str, index: u32) -> Option<&VariableIndexEntry> {
- self.member_variables.get(pou_name).and_then(|map| {
- map.values()
- .filter(|item| item.information.variable_type == VariableType::Input)
- .find(|item| item.information.location == index)
- })
+ self.member_variables
+ .get(&pou_name.to_lowercase())
+ .and_then(|map| {
+ map.values()
+ .filter(|item| item.information.variable_type == VariableType::Input)
+ .find(|item| item.information.location == index)
+ })
  }
 
  pub fn find_variable(
@@ -260,7 +262,7 @@ impl Index {
  }
 
  pub fn find_type(&self, type_name: &str) -> Option<&DataType> {
- self.types.get(type_name)
+ self.types.get(&type_name.to_lowercase())
  }
 
  pub fn find_effective_type_by_name(&self, type_name: &str) -> Option<&DataType> {
@@ -322,7 +324,7 @@ impl Index {
  }
 
  pub fn find_return_variable(&self, pou_name: &str) -> Option<&VariableIndexEntry> {
- let members = self.member_variables.get(pou_name); //.ok_or_else(||CompileError::unknown_type(pou_name, 0..0))?;
+ let members = self.member_variables.get(&pou_name.to_lowercase()); //.ok_or_else(||CompileError::unknown_type(pou_name, 0..0))?;
  if let Some(members) = members {
  for (_, variable) in members {
  if variable.information.variable_type == VariableType::Return {
@@ -351,7 +353,8 @@ impl Index {
  .ok_or_else(|| CompileError::unknown_type(type_name, SourceRange::undefined()))
  }
 
- pub fn get_types(&self) -> &IndexMap<String, DataType> {
+ /// Returns a list of types, should not be used to search for types, just to react on them
+ pub(crate) fn get_types(&self) -> &IndexMap<String, DataType> {
  &self.types
  }
 
@@ -370,7 +373,7 @@ impl Index {
  impl_type: ImplementationType,
  ) {
  self.implementations.insert(
- call_name.into(),
+ call_name.to_lowercase(),
  ImplementationIndexEntry {
  call_name: call_name.into(),
  type_name: type_name.into(),
@@ -380,7 +383,7 @@ impl Index {
  }
 
  pub fn find_implementation(&self, call_name: &str) -> Option<&ImplementationIndexEntry> {
- self.implementations.get(call_name)
+ self.implementations.get(&call_name.to_lowercase())
  }
 
  /// registers a member-variable of a container to be accessed in a qualified name.
@@ -407,7 +410,7 @@ impl Index {
 
  let members = self
  .member_variables
- .entry(container_name.into())
+ .entry(container_name.to_lowercase())
  .or_insert_with(IndexMap::new);
 
  let qualified_name = format!("{}.{}", container_name, variable_name);
@@ -424,7 +427,7 @@ impl Index {
  location,
  },
  };
- members.insert(variable_name.into(), entry);
+ members.insert(variable_name.to_lowercase(), entry);
  }
 
  pub fn register_global_variable(
@@ -466,7 +469,8 @@ impl Index {
  location: 0,
  },
  };
- self.global_variables.insert(association_name.into(), entry);
+ self.global_variables
+ .insert(association_name.to_lowercase(), entry);
  }
 
  pub fn print_global_variables(&self) {
@@ -484,7 +488,7 @@ impl Index {
  initial_value,
  information,
  };
- self.types.insert(type_name.into(), index_entry);
+ self.types.insert(type_name.to_lowercase(), index_entry);
  }
 
  pub fn find_callable_instance_variable(

src/index/tests/index_tests.rs

@@ -19,6 +19,47 @@ fn lex(source: &str) -> lexer::ParseSession {
  lexer::lex(source)
 }
 
+#[test]
+fn index_not_case_sensitive() {
+ let index = index!(
+ r#"
+ TYPE st : STRUCT
+ x : INT;
+ y : DINT;
+ END_STRUCT
+ END_TYPE
+
+ VAR_GLOBAL
+ a: INT;
+ x : ST; 
+ END_VAR
+ FUNCTION foo : INT
+ END_FUNCTION
+
+ PROGRAM aProgram
+ VAR
+ c,d : INT;
+ END_VAR
+ END_PROGRAM
+ "#
+ );
+
+ let entry = index.find_global_variable("A").unwrap();
+ assert_eq!("a", entry.name);
+ assert_eq!("INT", entry.information.data_type_name);
+ let entry = index.find_global_variable("X").unwrap();
+ assert_eq!("x", entry.name);
+ assert_eq!("ST", entry.information.data_type_name);
+ let entry = index.find_member("ST", "X").unwrap();
+ assert_eq!("x", entry.name);
+ assert_eq!("INT", entry.information.data_type_name);
+ let entry = index.find_type("APROGRAM").unwrap();
+ assert_eq!("aProgram", entry.name);
+ let entry = index.find_implementation("Foo").unwrap();
+ assert_eq!("foo", entry.call_name);
+ assert_eq!("foo", entry.type_name);
+}
+
 #[test]
 fn global_variables_are_indexed() {
  let index = index!(
@@ -1152,7 +1193,7 @@ fn sub_range_boundaries_are_registered_at_the_index() {
  let index = index!(src);
 
  // THEN I expect the index to contain the defined range-information for the given type
- let my_int = &index.get_types().get("MyInt").unwrap().information;
+ let my_int = &index.get_type("MyInt").unwrap().information;
  let expected = &DataTypeInformation::SubRange {
  name: "MyInt".to_string(),
  referenced_type: "INT".to_string(),
@@ -1170,7 +1211,7 @@ fn sub_range_boundaries_are_registered_at_the_index() {
  assert_eq!(format!("{:?}", expected), format!("{:?}", my_int));
 
  // THEN I expect the index to contain the defined range-information for the given type
- let my_int = &index.get_types().get("MyAliasInt").unwrap().information;
+ let my_int = &index.get_type("MyAliasInt").unwrap().information;
  let expected = &DataTypeInformation::Alias {
  name: "MyAliasInt".to_string(),
  referenced_type: "MyInt".to_string(),

src/index/visitor.rs

@@ -14,7 +14,9 @@ pub fn visit(unit: &CompilationUnit) -> Index {
  //Create the typesystem
  let builtins = get_builtin_types();
  for data_type in builtins {
- index.types.insert(data_type.get_name().into(), data_type);
+ index
+ .types
+ .insert(data_type.get_name().to_lowercase(), data_type);
  }
 
  //Create user defined datatypes

src/lexer.rs

@@ -118,6 +118,8 @@ impl<'a> ParseSession<'a> {
  | Token::KeywordVarOutput
  | Token::KeywordVarGlobal
  | Token::KeywordVarInOut
+ | Token::KeywordVarTemp
+ | Token::KeywordNonRetain
  | Token::KeywordEndVar
  | Token::KeywordEndProgram
  | Token::KeywordEndFunction