CSY/reowolf Changeset - 7cf6df93d16d · Centrum Wiskunde & Informatica (CWI)

Changeset - 7cf6df93d16d

Parent rev.

Child rev.

[Not reviewed]

0 11 1

MH - 3 years ago 2022-03-24 16:39:48
contact@maxhenger.nl

Move builtin definitions to std lib

12 files changed with 222 insertions and 169 deletions:

bin-compiler/src/main.rs

src/protocol/ast.rs

src/protocol/ast_printer.rs

src/protocol/mod.rs

src/protocol/parser/mod.rs

130

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_typing.rs

src/protocol/parser/type_table.rs

src/protocol/tests/utils.rs

src/runtime2/component/component.rs

src/runtime2/component/component_pdl.rs

std/std.global.pdl

0 comments (0 inline, 0 general)

bin-compiler/src/main.rs

➞

Show inline comments

@@ @@ -18,97 +18,97 @@ fn main() { @@
                 .takes_value(true)
                 .multiple_occurrences(true)
+        )
         .arg(
             Arg::new("threads")
                 .long("threads")
                 .short('t')
                 .help("number of runtime threads")
                 .default_value("1")
                 .takes_value(true)
+        )
         .arg(
             Arg::new("debug")
                 .long("debug")
                 .short('d')
                 .help("enable debug logging")
         );
     // Retrieve arguments and convert
     let app = app.get_matches();
     let input_files = app.values_of("input");
     if input_files.is_none() {
         println!("ERROR: Expected at least one input file");
         return;
+    }
     let num_threads = app.value_of("threads").unwrap();
     let num_threads = match num_threads.parse::<i32>() {
         Ok(num_threads) => {
             if num_threads < 0 || num_threads > 255 {
                 println!("ERROR: Number of threads must be a number between 0 and 256");
                 return;
+            }
             num_threads as u32
         },
         Err(err) => {
             println!("ERROR: Failed to parse number of threads\nbecause: {}", err);
             return;
+        }
     };
     let debug_enabled = app.is_present("debug");
     // Add input files to file buffer
     let input_files = input_files.unwrap();
     assert!(input_files.len() > 0); // because arg is required
     let mut builder = rw::ProtocolDescriptionBuilder::new();
+    let mut builder = rw::ProtocolDescriptionBuilder::new().expect("create protocol description builder");
     let mut file_buffer = Vec::with_capacity(4096);
     for input_file in input_files {
         print!("Adding file: {} ... ", input_file);
         let mut file = match File::open(input_file) {
             Ok(file) => file,
             Err(err) => {
                 println!("FAILED (to open file)\nbecause:\n{}", err);
                 return;
+            }
         };
         file_buffer.clear();
         if let Err(err) = file.read_to_end(&mut file_buffer) {
             println!("FAILED (to read file)\nbecause:\n{}", err);
             return;
+        }
         if let Err(err) = builder.add(input_file.to_string(), file_buffer.clone()) {
             println!("FAILED (to tokenize file)\nbecause:\n{}", err);
+        }
         println!("Success");
+    }
     // Compile the program
     print!("Compiling program ... ");
     let protocol_description = match builder.compile() {
         Ok(pd) => pd,
         Err(err) => {
             println!("FAILED\nbecause:\n{}", err);
             return;
+        }
     };
     println!("Success");
     // Make sure there is a nameless module with a main component
     print!("Creating main component ... ");
     let runtime = rw::runtime2::Runtime::new(num_threads, debug_enabled, protocol_description);
     if let Err(err) = runtime.create_component(b"", b"main") {
         use rw::ComponentCreationError as CCE;
         let reason = match err {
             CCE::ModuleDoesntExist => "Input files did not contain a nameless module (that should contain the 'main' component)",
             CCE::DefinitionDoesntExist => "Input files did not contain a component called 'main'",
             CCE::DefinitionNotComponent => "Input file contained a 'main' function, but not a 'main' component",
             _ => "Unexpected error"
         };

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -1026,129 +1026,159 @@ pub struct ProcedureDefinitionMonomorph { @@
 impl ProcedureDefinitionMonomorph {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             argument_types: Vec::new(),
             expr_info: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub struct ExpressionInfo {
     pub type_id: TypeId,
     pub variant: ExpressionInfoVariant,
+}
 impl ExpressionInfo {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             type_id: TypeId::new_invalid(),
             variant: ExpressionInfoVariant::Generic,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ExpressionInfoVariant {
     Generic,
     Procedure(TypeId, u32), // procedure TypeID and its monomorph index
     Select(i32), // index
+}
 impl ExpressionInfoVariant {
     pub(crate) fn as_select(&self) -> i32 {
         match self {
             ExpressionInfoVariant::Select(v) => *v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_procedure(&self) -> (TypeId, u32) {
         match self {
             ExpressionInfoVariant::Procedure(type_id, monomorph_index) => (*type_id, *monomorph_index),
             _ => unreachable!(),
+        }
+    }
+}
 #[derive(Debug)]
 pub enum ProcedureSource {
     FuncUserDefined,
     CompUserDefined,
     // Builtin functions, available to user
     FuncGet,
     FuncPut,
     FuncFires,
     FuncCreate,
     FuncLength,
     FuncAssert,
     FuncPrint,
     // Buitlin functions, not available to user
     FuncSelectStart,
     FuncSelectRegisterCasePort,
     FuncSelectWait,
     // Builtin components, available to user
     CompRandomU32, // TODO: Remove, temporary thing
+}
 impl ProcedureSource {
     pub(crate) fn is_builtin(&self) -> bool {
         match self {
             ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => false,
             _ => true,
+        }
+    }
+}
 /// Generic storage for functions, primitive components and composite
 /// components.
 // Note that we will have function definitions for builtin functions as well. In
 // that case the span, the identifier span and the body are all invalid.
 #[derive(Debug)]
 pub struct ProcedureDefinition {
     pub this: ProcedureDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub builtin: bool,
     pub kind: ProcedureKind,
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parser
     pub source: ProcedureSource,
     pub return_type: Option<ParserType>, // present on functions, not components
     pub parameters: Vec<VariableId>,
     pub scope: ScopeId,
     pub body: BlockStatementId,
     // Monomorphization of typed procedures
     pub monomorphs: Vec<ProcedureDefinitionMonomorph>,
+}
 impl ProcedureDefinition {
     pub(crate) fn new_empty(
         this: ProcedureDefinitionId, defined_in: RootId, span: InputSpan,
         kind: ProcedureKind, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             builtin: false,
             span,
             kind, identifier, poly_vars,
             source: ProcedureSource::FuncUserDefined,
             return_type: None,
             parameters: Vec::new(),
             scope: ScopeId::new_invalid(),
             body: BlockStatementId::new_invalid(),
             monomorphs: Vec::new(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Fork(ForkStatement),
     EndFork(EndForkStatement),
     Select(SelectStatement),
     EndSelect(EndSelectStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -725,97 +725,97 @@ impl ASTWriter { @@
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
                     },
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
                     },
                     Literal::Tuple(data) => {
                         val.with_s_val("Tuple");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Cast(expr) => {
                 self.kv(indent).with_id(PREFIX_CAST_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("ToType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.to_type));
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Method").with_debug_val(&expr.method);
                 if !expr.procedure.is_invalid() {
                     let definition = &heap[expr.procedure];
-                    self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&definition.builtin);
+                    self.kv(indent2).with_s_key("Source").with_debug_val(&definition.source);
                     self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.kind);
                     self.kv(indent2).with_s_key("MethodName").with_identifier_val(&definition.identifier);
                     self.kv(indent2).with_s_key("ParserType")
                         .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
+                }
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
                 self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&expr.identifier);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
+        }
+    }
     fn write_variable(&mut self, heap: &Heap, variable_id: VariableId, indent: usize) {
         let var = &heap[variable_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_VARIABLE_ID, variable_id.index)
             .with_s_key("Variable");
         self.kv(indent2).with_s_key("Name").with_identifier_val(&var.identifier);
         self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);
         self.kv(indent2).with_s_key("ParserType")
             .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));
         self.kv(indent2).with_s_key("RelativePos").with_disp_val(&var.relative_pos_in_parent);
         self.kv(indent2).with_s_key("UniqueScopeID").with_disp_val(&var.unique_id_in_scope);
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------

src/protocol/mod.rs

➞

Show inline comments

 mod arena;
 pub(crate) mod eval;
 pub(crate) mod input_source;
 mod parser;
 #[cfg(test)] mod tests;
 pub(crate) mod ast;
 pub(crate) mod ast_printer;
 use std::sync::Mutex;
 use crate::collections::{StringPool, StringRef};
 use crate::protocol::ast::*;
+pub use crate::protocol::ast::*;
 use crate::protocol::eval::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::*;
 use crate::protocol::type_table::*;
 pub use parser::type_table::TypeId;
 /// A protocol description module
 pub struct Module {
     pub(crate) source: InputSource,
     pub(crate) root_id: RootId,
     pub(crate) name: Option<StringRef<'static>>,
+}
 /// Description of a protocol object, used to configure new connectors.
 #[repr(C)]
 pub struct ProtocolDescription {
     pub(crate) modules: Vec<Module>,
     pub(crate) heap: Heap,
     pub(crate) types: TypeTable,
     pub(crate) pool: Mutex<StringPool>,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct ComponentState {
     pub(crate) prompt: Prompt,
+}
 #[derive(Debug)]
 pub enum ComponentCreationError {
     ModuleDoesntExist,
     DefinitionDoesntExist,
     DefinitionNotComponent,
     InvalidNumArguments,
     InvalidArgumentType(usize),
     UnownedPort,
     InSync,
+}
 impl ProtocolDescription {
     pub fn parse(buffer: &[u8]) -> Result<Self, String> {
         let source = InputSource::new(String::new(), Vec::from(buffer));
         let mut parser = Parser::new();
+        let mut parser = Parser::new()?;
         parser.feed(source).expect("failed to feed source");
         if let Err(err) = parser.parse() {
             println!("ERROR:\n{}", err);
             return Err(format!("{}", err))
+        }
         debug_assert_eq!(parser.modules.len(), 1, "only supporting one module here for now");
         let modules: Vec<Module> = parser.modules.into_iter()
             .map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             })
             .collect();
         return Ok(ProtocolDescription {
             modules,
             heap: parser.heap,
             types: parser.type_table,
             pool: Mutex::new(parser.string_pool),
         });
+    }
     pub(crate) fn new_component(
         &self, module_name: &[u8], identifier: &[u8], arguments: ValueGroup
     ) -> Result<Prompt, ComponentCreationError> {
         // Find the module in which the definition can be found
         let module_root = self.lookup_module_root(module_name);
         if module_root.is_none() {
             return Err(ComponentCreationError::ModuleDoesntExist);
+        }
         let module_root = module_root.unwrap();
         let root = &self.heap[module_root];
         let definition_id = root.get_definition_ident(&self.heap, identifier);
         if definition_id.is_none() {
             return Err(ComponentCreationError::DefinitionDoesntExist);
+        }
         let definition_id = definition_id.unwrap();
         let ast_definition = &self.heap[definition_id];
         if !ast_definition.is_procedure() {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // Make sure that the types of the provided value group matches that of
         // the expected types.
@@ @@ -178,80 +178,80 @@ impl ProtocolDescription { @@
                 if let Value::Array(heap_pos) = argument {
                     let heap_pos = *heap_pos;
                     for element in &arguments.regions[heap_pos as usize] {
                         if !self.verify_same_type(expected, expected_idx + 1, arguments, element) {
                             return false;
+                        }
+                    }
                     return true;
                 } else {
                     return false;
+                }
             },
             CTP::Input => if let Value::Input(_) = argument { true } else { false },
             CTP::Output => if let Value::Output(_) = argument { true } else { false },
             CTP::Tuple(_) => todo!("implement full type checking on user-supplied arguments"),
             CTP::Instance(definition_id, _num_embedded) => {
                 let definition = self.types.get_base_definition(definition_id).unwrap();
                 match &definition.definition {
                     DefinedTypeVariant::Enum(definition) => {
                         if let Value::Enum(variant_value) = argument {
                             let is_valid = definition.variants.iter()
                                 .any(|v| v.value == *variant_value);
                             return is_valid;
+                        }
                     },
                     _ => todo!("implement full type checking on user-supplied arguments"),
+                }
                 return false;
             },
+        }
+    }
+}
 pub trait RunContext {
     fn performed_put(&mut self, port: PortId) -> bool;
     fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message
     fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched
     fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked
     fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared
     fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker
+}
 pub struct ProtocolDescriptionBuilder {
     parser: Parser,
+}
 impl ProtocolDescriptionBuilder {
     pub fn new() -> Self {
         return Self{
             parser: Parser::new(),
+        }
     pub fn new() -> Result<Self, String> {
         return Ok(Self{
             parser: Parser::new()?,
         })
+    }
     pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {
         let input = InputSource::new(filename, buffer);
         self.parser.feed(input)?;
         return Ok(())
+    }
     pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {
         self.parser.parse()?;
         let modules: Vec<Module> = self.parser.modules.into_iter()
             .map(|module| Module{
                 source: module.source,
                 root_id: module.root_id,
                 name: module.name.map(|(_, name)| name)
             })
             .collect();
         return Ok(ProtocolDescription {
             modules,
             heap: self.parser.heap,
             types: self.parser.type_table,
             pool: Mutex::new(self.parser.string_pool),
         });
+    }
+}

src/protocol/parser/mod.rs

➞

Show inline comments

 #[macro_use] mod visitor;
 pub(crate) mod symbol_table;
 pub(crate) mod type_table;
 pub(crate) mod tokens;
 pub(crate) mod token_parsing;
 pub(crate) mod pass_tokenizer;
 pub(crate) mod pass_symbols;
 pub(crate) mod pass_imports;
 pub(crate) mod pass_definitions;
 pub(crate) mod pass_definitions_types;
 pub(crate) mod pass_validation_linking;
 pub(crate) mod pass_rewriting;
 pub(crate) mod pass_typing;
 pub(crate) mod pass_stack_size;
 use tokens::*;
 use crate::collections::*;
 use visitor::Visitor;
 use pass_tokenizer::PassTokenizer;
 use pass_symbols::PassSymbols;
 use pass_imports::PassImport;
 use pass_definitions::PassDefinitions;
 use pass_validation_linking::PassValidationLinking;
 use pass_typing::{PassTyping, ResolveQueue};
 use pass_rewriting::PassRewriting;
 use pass_stack_size::PassStackSize;
 use symbol_table::*;
 use type_table::*;
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::ast_printer::ASTWriter;
 use crate::protocol::parser::type_table::PolymorphicVariable;
 const REOWOLF_PATH_ENV: &'static str = "REOWOLF_ROOT"; // first lookup reowolf path
 const REOWOLF_PATH_DIR: &'static str = "std"; // then try folder in current working directory
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum ModuleCompilationPhase {
     Tokenized,              // source is tokenized
     SymbolsScanned,         // all definitions are linked to their type class
     ImportsResolved,        // all imports are added to the symbol table
     DefinitionsParsed,      // produced the AST for the entire module
     TypesAddedToTable,      // added all definitions to the type table
     ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes
     Typed,                  // Type inference and checking has been performed
     Rewritten,              // Special AST nodes are rewritten into regular AST nodes
     // When we continue with the compiler:
     // StackSize
+}
 pub struct Module {
     // Buffers
     pub source: InputSource,
     pub tokens: TokenBuffer,
     // Identifiers
     pub root_id: RootId,
     pub name: Option<(PragmaId, StringRef<'static>)>,
     pub version: Option<(PragmaId, i64)>,
     pub phase: ModuleCompilationPhase,
+}
 pub struct TargetArch {
     pub void_type_id: TypeId,
     pub message_type_id: TypeId,
     pub bool_type_id: TypeId,
     pub uint8_type_id: TypeId,
     pub uint16_type_id: TypeId,
     pub uint32_type_id: TypeId,
     pub uint64_type_id: TypeId,
     pub sint8_type_id: TypeId,
     pub sint16_type_id: TypeId,
     pub sint32_type_id: TypeId,
     pub sint64_type_id: TypeId,
     pub char_type_id: TypeId,
     pub string_type_id: TypeId,
     pub array_type_id: TypeId,
     pub slice_type_id: TypeId,
     pub input_type_id: TypeId,
     pub output_type_id: TypeId,
     pub pointer_type_id: TypeId,
+}
 impl TargetArch {
     fn new() -> Self {
@@ @@ -89,193 +92,141 @@ impl TargetArch { @@
             uint16_type_id: TypeId::new_invalid(),
             uint32_type_id: TypeId::new_invalid(),
             uint64_type_id: TypeId::new_invalid(),
             sint8_type_id: TypeId::new_invalid(),
             sint16_type_id: TypeId::new_invalid(),
             sint32_type_id: TypeId::new_invalid(),
             sint64_type_id: TypeId::new_invalid(),
             char_type_id: TypeId::new_invalid(),
             string_type_id: TypeId::new_invalid(),
             array_type_id: TypeId::new_invalid(),
             slice_type_id: TypeId::new_invalid(),
             input_type_id: TypeId::new_invalid(),
             output_type_id: TypeId::new_invalid(),
             pointer_type_id: TypeId::new_invalid(),
+        }
+    }
+}
 pub struct PassCtx<'a> {
     heap: &'a mut Heap,
     symbols: &'a mut SymbolTable,
     pool: &'a mut StringPool,
     arch: &'a TargetArch,
+}
 pub struct Parser {
     // Storage of all information created/gathered during compilation.
     pub(crate) heap: Heap,
     pub(crate) string_pool: StringPool, // Do not deallocate, holds all strings
     pub(crate) modules: Vec<Module>,
     pub(crate) symbol_table: SymbolTable,
     pub(crate) type_table: TypeTable,
     // Compiler passes, used as little state machine that keep their memory
     // around.
     pass_tokenizer: PassTokenizer,
     pass_symbols: PassSymbols,
     pass_import: PassImport,
     pass_definitions: PassDefinitions,
     pass_validation: PassValidationLinking,
     pass_typing: PassTyping,
     pass_rewriting: PassRewriting,
     pass_stack_size: PassStackSize,
     // Compiler options
     pub write_ast_to: Option<String>,
     pub(crate) arch: TargetArch,
+}
 impl Parser {
     pub fn new() -> Self {
+    pub fn new() -> Result<Self, String> {
         let mut parser = Parser{
             heap: Heap::new(),
             string_pool: StringPool::new(),
             modules: Vec::new(),
             symbol_table: SymbolTable::new(),
             type_table: TypeTable::new(),
             pass_tokenizer: PassTokenizer::new(),
             pass_symbols: PassSymbols::new(),
             pass_import: PassImport::new(),
             pass_definitions: PassDefinitions::new(),
             pass_validation: PassValidationLinking::new(),
             pass_typing: PassTyping::new(),
             pass_rewriting: PassRewriting::new(),
             pass_stack_size: PassStackSize::new(),
             write_ast_to: None,
             arch: TargetArch::new(),
         };
         parser.symbol_table.insert_scope(None, SymbolScope::Global);
         // Insert builtin types
         // TODO: At some point use correct values for size/alignment
         parser.arch.void_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Void], false, 0, 1);
         parser.arch.message_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Message], false, 24, 8);
         parser.arch.bool_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Bool], false, 1, 1);
         parser.arch.uint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt8], false, 1, 1);
         parser.arch.uint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt16], false, 2, 2);
         parser.arch.uint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt32], false, 4, 4);
         parser.arch.uint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::UInt64], false, 8, 8);
         parser.arch.sint8_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt8], false, 1, 1);
         parser.arch.sint16_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt16], false, 2, 2);
         parser.arch.sint32_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt32], false, 4, 4);
         parser.arch.sint64_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::SInt64], false, 8, 8);
         parser.arch.char_type_id    = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Character], false, 4, 4);
         parser.arch.string_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::String], false, 24, 8);
         parser.arch.array_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Array, ConcreteTypePart::Void], true, 24, 8);
         parser.arch.slice_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Slice, ConcreteTypePart::Void], true, 16, 4);
         parser.arch.input_type_id   = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Input, ConcreteTypePart::Void], true, 8, 8);
         parser.arch.output_type_id  = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Output, ConcreteTypePart::Void], true, 8, 8);
         parser.arch.pointer_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Pointer, ConcreteTypePart::Void], true, 8, 8);
         // Insert builtin functions
         fn quick_type(variants: &[ParserTypeVariant]) -> ParserType {
             let mut t = ParserType{ elements: Vec::with_capacity(variants.len()), full_span: InputSpan::new() };
             for variant in variants {
                 t.elements.push(ParserTypeElement{ element_span: InputSpan::new(), variant: variant.clone() });
+            }
+            t
+        }
         parser.feed_standard_library()?;
         use ParserTypeVariant as PTV;
         insert_builtin_function(&mut parser, "get", &["T"], |id| (
             vec![
                 ("input", quick_type(&[PTV::Input, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::PolymorphicArgument(id.upcast(), 0)])
         ));
         insert_builtin_function(&mut parser, "put", &["T"], |id| (
             vec![
                 ("output", quick_type(&[PTV::Output, PTV::PolymorphicArgument(id.upcast(), 0)])),
                 ("value", quick_type(&[PTV::PolymorphicArgument(id.upcast(), 0)])),
             ],
             quick_type(&[PTV::Void])
         ));
         insert_builtin_function(&mut parser, "fires", &["T"], |id| (
             vec![
                 ("port", quick_type(&[PTV::InputOrOutput, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::Bool])
         ));
         insert_builtin_function(&mut parser, "create", &["T"], |id| (
             vec![
                 ("length", quick_type(&[PTV::IntegerLike]))
             ],
             quick_type(&[PTV::ArrayLike, PTV::PolymorphicArgument(id.upcast(), 0)])
         ));
         insert_builtin_function(&mut parser, "length", &["T"], |id| (
             vec![
                 ("array", quick_type(&[PTV::ArrayLike, PTV::PolymorphicArgument(id.upcast(), 0)]))
             ],
             quick_type(&[PTV::UInt32]) // TODO: @PtrInt
         ));
         insert_builtin_function(&mut parser, "assert", &[], |_id| (
             vec![
                 ("condition", quick_type(&[PTV::Bool])),
             ],
             quick_type(&[PTV::Void])
         ));
         insert_builtin_function(&mut parser, "print", &[], |_id| (
             vec![
                 ("message", quick_type(&[PTV::String])),
             ],
             quick_type(&[PTV::Void])
         ));
         parser
         return Ok(parser)
+    }
     pub fn feed(&mut self, mut source: InputSource) -> Result<(), ParseError> {
         let mut token_buffer = TokenBuffer::new();
         self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;
         let module = Module{
             source,
             tokens: token_buffer,
             root_id: RootId::new_invalid(),
             name: None,
             version: None,
             phase: ModuleCompilationPhase::Tokenized,
         };
         self.modules.push(module);
         Ok(())
+    }
     pub fn parse(&mut self) -> Result<(), ParseError> {
         let mut pass_ctx = PassCtx{
             heap: &mut self.heap,
             symbols: &mut self.symbol_table,
             pool: &mut self.string_pool,
             arch: &self.arch,
         };
         // Advance all modules to the phase where all symbols are scanned
         for module_idx in 0..self.modules.len() {
             self.pass_symbols.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // With all symbols scanned, perform further compilation until we can
         // add all base types to the type table.
         for module_idx in 0..self.modules.len() {
             self.pass_import.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
             self.pass_definitions.parse(&mut self.modules, module_idx, &mut pass_ctx)?;
+        }
         // Add every known type to the type table
         self.type_table.build_base_types(&mut self.modules, &mut pass_ctx)?;
         // Continue compilation with the remaining phases now that the types
         // are all in the type table
         for module_idx in 0..self.modules.len() {
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 modules: &mut self.modules,
@@ @@ -292,140 +243,122 @@ impl Parser { @@
         for module_idx in 0..self.modules.len() {
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 modules: &mut self.modules,
                 module_idx,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_typing.queue_module_definitions(&mut ctx, &mut queue);
         };
         while !queue.is_empty() {
             let top = queue.pop_front().unwrap();
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 modules: &mut self.modules,
                 module_idx: top.root_id.index as usize,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;
+        }
         // Rewrite nodes in tree, then prepare for execution of code
         for module_idx in 0..self.modules.len() {
             self.modules[module_idx].phase = ModuleCompilationPhase::Typed;
             let mut ctx = visitor::Ctx{
                 heap: &mut self.heap,
                 modules: &mut self.modules,
                 module_idx,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_rewriting.visit_module(&mut ctx)?;
             self.pass_stack_size.visit_module(&mut ctx)?;
+        }
         // Write out desired information
         if let Some(filename) = &self.write_ast_to {
             let mut writer = ASTWriter::new();
             let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();
             writer.write_ast(&mut file, &self.heap);
+        }
         Ok(())
+    }
     /// Tries to find the standard library and add the files for parsing.
     fn feed_standard_library(&mut self) -> Result<(), String> {
         use std::env;
         use std::path::{Path, PathBuf};
         use std::fs;
         const FILES: [&'static str; 1] = [
             "std.global.pdl",
         ];
         // Determine base directory
         let (base_path, from_env) = if let Ok(path) = env::var(REOWOLF_PATH_ENV) {
             // Path variable is set
             (path, true)
         } else {
             let mut path = String::with_capacity(REOWOLF_PATH_DIR.len() + 2);
             path.push_str("./");
             path.push_str(REOWOLF_PATH_DIR);
             (path, false)
         };
         // Make sure directory exists
         let path = Path::new(&base_path);
         if !path.exists() {
             return Err(format!("std lib root directory '{}' does not exist", base_path));
+        }
         // Try to load all standard library files. We might need a more unified
         // way to do this in the future (i.e. a "std" package, containing all
         // of the modules)
         let mut file_path = PathBuf::new();
         for file in FILES {
             file_path.push(path);
             file_path.push(file);
             let source = fs::read(file_path.as_path());
             if let Err(err) = source {
                 return Err(format!(
                     "failed to read std lib file '{}' in root directory '{}', because: {}",
                     file, base_path, err
                 ));
+            }
             let source = source.unwrap();
             let input_source = InputSource::new(file.to_string(), source);
             if let Err(err) = self.feed(input_source) {
                 // A bit of a hack, but shouldn't really happen anyway: the
                 // compiler should ship with a decent standard library (at some
                 // point)
                 return Err(format!("{}", err));
+            }
+        }
         return Ok(())
+    }
+}
 fn insert_builtin_type(type_table: &mut TypeTable, parts: Vec<ConcreteTypePart>, has_poly_var: bool, size: usize, alignment: usize) -> TypeId {
     const POLY_VARS: [PolymorphicVariable; 1] = [PolymorphicVariable{
         identifier: Identifier::new_empty(InputSpan::new()),
         is_in_use: false,
     }];
     let concrete_type = ConcreteType{ parts };
     let poly_var = if has_poly_var {
         POLY_VARS.as_slice()
     } else {
         &[]
     };
     return type_table.add_builtin_data_type(concrete_type, poly_var, size, alignment);
+}
 // Note: args and return type need to be a function because we need to know the function ID.
 fn insert_builtin_function<T: Fn(ProcedureDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T
 ) {
     // Insert into AST (to get an ID), also prepare the polymorphic variables
     // we need later for the type table
     let mut ast_poly_vars = Vec::with_capacity(polymorphic.len());
     let mut type_poly_vars = Vec::with_capacity(polymorphic.len());
     for poly_var in polymorphic {
         let identifier = Identifier{ span: InputSpan::new(), value: p.string_pool.intern(poly_var.as_bytes()) } ;
         ast_poly_vars.push(identifier.clone());
         type_poly_vars.push(PolymorphicVariable{ identifier, is_in_use: false });
+    }
     let func_ident_ref = p.string_pool.intern(func_name.as_bytes());
     let procedure_id = p.heap.alloc_procedure_definition(|this| ProcedureDefinition {
         this,
         defined_in: RootId::new_invalid(),
         builtin: true,
         kind: ProcedureKind::Function,
         span: InputSpan::new(),
         identifier: Identifier{ span: InputSpan::new(), value: func_ident_ref.clone() },
         poly_vars: ast_poly_vars,
         return_type: None,
         parameters: Vec::new(),
         scope: ScopeId::new_invalid(),
         body: BlockStatementId::new_invalid(),
         monomorphs: Vec::new(),
     });
     // Modify AST with more information about the procedure
     let (arguments, return_type) = arg_and_return_fn(procedure_id);
     let mut parameters = Vec::with_capacity(arguments.len());
     for (arg_name, arg_type) in arguments {
         let identifier = Identifier{ span: InputSpan::new(), value: p.string_pool.intern(arg_name.as_bytes()) };
         let param_id = p.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Parameter,
             parser_type: arg_type.clone(),
             identifier,
             relative_pos_in_parent: 0,
             unique_id_in_scope: 0
         });
         parameters.push(param_id);
+    }
     let func = &mut p.heap[procedure_id];
     func.parameters = parameters;
     func.return_type = Some(return_type);
     // Insert into symbol table
     p.symbol_table.insert_symbol(SymbolScope::Global, Symbol{
         name: func_ident_ref,
         variant: SymbolVariant::Definition(SymbolDefinition{
             defined_in_module: RootId::new_invalid(),
             defined_in_scope: SymbolScope::Global,
             definition_span: InputSpan::new(),
             identifier_span: InputSpan::new(),
             imported_at: None,
             class: DefinitionClass::Function,
             definition_id: procedure_id.upcast(),
         })
     }).unwrap();
     // Insert into type table
     // let mut concrete_type = ConcreteType::default();
     // concrete_type.parts.push(ConcreteTypePart::Function(procedure_id, type_poly_vars.len() as u32));
     //
     // for _ in 0..type_poly_vars.len() {
     //     concrete_type.parts.push(ConcreteTypePart::Void); // doesn't matter (I hope...)
     // }
     // p.type_table.add_builtin_procedure_type(concrete_type, &type_poly_vars);
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -234,147 +234,204 @@ impl PassDefinitions { @@
                 };
                 Ok(UnionVariantDefinition{
                     span: InputSpan::from_positions(identifier.span.begin, close_pos),
                     identifier,
                     value
                 })
             },
             &mut variants_section, "a union variant", "a list of union variants", None
         )?;
         // Transfer to AST
         let union_def = ctx.heap[definition_id].as_union_mut();
         union_def.variants = variants_section.into_vec();
         Ok(())
+    }
     fn visit_function_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Retrieve function name
         consume_exact_ident(&module.source, iter, KW_FUNCTION)?;
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated DefinitionId
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse function's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume return types
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = self.type_parser.consume_parser_type(
             iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, definition_id,
             module_scope, false, None
         )?;
         // Consume block and the definition's scope
         let body_id = self.consume_block_statement(module, iter, ctx)?;
         // Consume body
         let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, ProcedureKind::Function)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the preallocated AST node
         let function = ctx.heap[definition_id].as_procedure_mut();
         function.source = source;
         function.return_type = Some(parser_type);
         function.parameters = parameters;
         function.scope = scope_id;
         function.body = body_id;
         Ok(())
+    }
     fn visit_component_definition(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<(), ParseError> {
         // Consume component variant and name
         let (_variant_text, _) = consume_any_ident(&module.source, iter)?;
         debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);
         let (ident_text, _) = consume_ident(&module.source, iter)?;
         // Retrieve preallocated definition
         let module_scope = SymbolScope::Module(module.root_id);
         let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)
             .unwrap().variant.as_definition().definition_id;
         self.cur_definition = definition_id;
         consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;
         // Parse component's argument list
         let mut parameter_section = self.variables.start_section();
         consume_parameter_list(
             &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id
         )?;
         let parameters = parameter_section.into_vec();
         // Consume block
         let body_id = self.consume_block_statement(module, iter, ctx)?;
         // Consume body
         let procedure_kind = ctx.heap[definition_id].as_procedure().kind;
         let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, procedure_kind)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_procedure_mut();
         debug_assert!(component.return_type.is_none());
         component.source = source;
         component.parameters = parameters;
         component.scope = scope_id;
         component.body = body_id;
         Ok(())
+    }
     /// Consumes a procedure's body: either a user-defined procedure, which we
     /// parse as normal, or a builtin function, where we'll make sure we expect
     /// the particular builtin.
     ///
     /// We expect that the procedure's name is already stored in the
     /// preallocated AST node.
     fn consume_procedure_body(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, definition_id: DefinitionId, kind: ProcedureKind
     ) -> Result<(BlockStatementId, ProcedureSource), ParseError> {
         if iter.peek() == Some(TokenKind::Pragma) {
             let (pragma, pragma_start, pragma_end) = consume_pragma(&module.source, iter)?;
             if pragma != b"#builtin" {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, InputSpan::from_positions(pragma_start, pragma_end),
                     "expected a '#builtin' pragma, or a function body"
                 ));
+            }
             // Retrieve module and procedure name
             assert!(module.name.is_some(), "compiler error: builtin procedure body in unnamed module");
             let (_, module_name) = module.name.as_ref().unwrap();
             let module_name = module_name.as_str();
             let definition = ctx.heap[definition_id].as_procedure();
             let procedure_name = definition.identifier.value.as_str();
             let source = match (module_name, procedure_name) {
                 ("std.global", "get") => ProcedureSource::FuncGet,
                 ("std.global", "put") => ProcedureSource::FuncPut,
                 ("std.global", "fires") => ProcedureSource::FuncFires,
                 ("std.global", "create") => ProcedureSource::FuncCreate,
                 ("std.global", "length") => ProcedureSource::FuncLength,
                 ("std.global", "assert") => ProcedureSource::FuncAssert,
                 ("std.global", "print") => ProcedureSource::FuncPrint,
                 _ => panic!(
                     "compiler error: unknown builtin procedure '{}' in module '{}'",
                     procedure_name, module_name
                 ),
             };
             return Ok((BlockStatementId::new_invalid(), source));
         } else {
             let body_id = self.consume_block_statement(module, iter, ctx)?;
             let source = match kind {
                 ProcedureKind::Function =>
                     ProcedureSource::FuncUserDefined,
                 ProcedureKind::Primitive | ProcedureKind::Composite =>
                     ProcedureSource::CompUserDefined,
             };
             return Ok((body_id, source))
+        }
+    }
     /// Consumes a statement and returns a boolean indicating whether it was a
     /// block or not.
     fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {
         let next = iter.next().expect("consume_statement has a next token");
         if next == TokenKind::OpenCurly {
             let id = self.consume_block_statement(module, iter, ctx)?;
             return Ok(id.upcast());
         } else if next == TokenKind::Ident {
             let ident = peek_ident(&module.source, iter).unwrap();
             if ident == KW_STMT_IF {
                 // Consume if statement and place end-if statement directly
                 // after it.
                 let id = self.consume_if_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_WHILE {
                 let id = self.consume_while_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_BREAK {
                 let id = self.consume_break_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_CONTINUE {
                 let id = self.consume_continue_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_SYNC {
                 let id = self.consume_synchronous_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_FORK {
                 let id = self.consume_fork_statement(module, iter, ctx)?;
                 let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {
                     this,
                     start_fork: id,
                     next: StatementId::new_invalid(),
                 });
                 let fork_stmt = &mut ctx.heap[id];
                 fork_stmt.end_fork = end_fork;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_SELECT {
                 let id = self.consume_select_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_RETURN {
                 let id = self.consume_return_statement(module, iter, ctx)?;
                 return Ok(id.upcast());
             } else if ident == KW_STMT_GOTO {
                 let id = self.consume_goto_statement(module, iter, ctx)?;
@@ @@ -1534,112 +1591,109 @@ impl PassDefinitions { @@
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = variant.span.end;
                                 let values = if Some(TokenKind::OpenParen) == iter.next() {
                                     self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?
                                 } else {
                                     Vec::new()
                                 };
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
                             },
                             Definition::Procedure(proc_def) => {
                                 // Check whether it is a builtin function
                                 // TODO: Once we start generating bytecode this is unnecessary
                                 let procedure_id = proc_def.this;
                                 let method = if proc_def.builtin {
                                     match proc_def.identifier.value.as_bytes() {
                                         KW_FUNC_GET => Method::Get,
                                         KW_FUNC_PUT => Method::Put,
                                         KW_FUNC_FIRES => Method::Fires,
                                         KW_FUNC_CREATE => Method::Create,
                                         KW_FUNC_LENGTH => Method::Length,
                                         KW_FUNC_ASSERT => Method::Assert,
                                         KW_FUNC_PRINT => Method::Print,
                                         _ => unreachable!(),
+                                    }
                                 } else if proc_def.kind == ProcedureKind::Function {
                                     Method::UserFunction
                                 } else {
                                     Method::UserComponent
                                 let method = match proc_def.source {
                                     ProcedureSource::FuncUserDefined => Method::UserFunction,
                                     ProcedureSource::CompUserDefined => Method::UserComponent,
                                     ProcedureSource::FuncGet => Method::Get,
                                     ProcedureSource::FuncPut => Method::Put,
                                     ProcedureSource::FuncFires => Method::Fires,
                                     ProcedureSource::FuncCreate => Method::Create,
                                     ProcedureSource::FuncLength => Method::Length,
                                     ProcedureSource::FuncAssert => Method::Assert,
                                     ProcedureSource::FuncPrint => Method::Print,
                                     _ => todo!("other proc sources")
                                 };
                                 // Function call: consume the arguments
                                 let func_span = parser_type.full_span;
                                 let mut full_span = func_span;
                                 let arguments = self.consume_expression_list(
                                     module, iter, ctx, Some(&mut full_span.end)
                                 )?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this, func_span, full_span, parser_type, method, arguments,
                                     procedure: procedure_id,
                                     parent: ExpressionParent::None,
                                     type_index: -1,
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.full_span, "unexpected type in expression"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     iter.consume();
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
                         type_index: -1,
                     }).upcast()
                 } else if ident_text == KW_LET {
                     // Binding expression
                     let operator_span = iter.next_span();
                     iter.consume();

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -2029,97 +2029,97 @@ impl PassTyping { @@
         };
         // For all of the expressions look up the TypeId (or create a new one).
         // For function calls and component instantiations figure out if they
         // need to be typechecked
         for infer_node in self.infer_nodes.iter_mut() {
             // Determine type ID
             let expr = &ctx.heap[infer_node.expr_id];
             // TODO: Maybe optimize? Split insertion up into lookup, then clone
             //  if needed?
             let mut concrete_type = ConcreteType::default();
             infer_node.expr_type.write_concrete_type(&mut concrete_type);
             let info_type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete_type)?;
             // Determine procedure type ID, i.e. a called/instantiated
             // procedure's signature.
             let info_variant = if let Expression::Call(expr) = expr {
                 // Construct full function type. If not yet typechecked then
                 // queue it for typechecking.
                 let poly_data = &self.poly_data[infer_node.poly_data_index as usize];
                 debug_assert!(expr.method.is_user_defined() || expr.method.is_public_builtin());
                 let procedure_id = expr.procedure;
                 let num_poly_vars = poly_data.poly_vars.len() as u32;
                 let first_part = match expr.method {
                     Method::UserFunction => ConcreteTypePart::Function(procedure_id, num_poly_vars),
                     Method::UserComponent => ConcreteTypePart::Component(procedure_id, num_poly_vars),
                     _ => ConcreteTypePart::Function(procedure_id, num_poly_vars),
                 };
                 let definition_id = procedure_id.upcast();
                 let signature_type = poly_data_type_to_concrete_type(
                     ctx, infer_node.expr_id, &poly_data.poly_vars, first_part
                 )?;
                 let (type_id, monomorph_index) = if let Some(type_id) = ctx.types.get_procedure_monomorph_type_id(&definition_id, &signature_type.parts) {
                     // Procedure is already typechecked
                     let monomorph_index = ctx.types.get_monomorph(type_id).variant.as_procedure().monomorph_index;
                     (type_id, monomorph_index)
                 } else {
                     // Procedure is not yet typechecked, reserve a TypeID and a monomorph index
                     let procedure_to_check = &mut ctx.heap[procedure_id];
                     let monomorph_index = procedure_to_check.monomorphs.len() as u32;
                     procedure_to_check.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());
                     let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, signature_type, monomorph_index);
-                    if !procedure_to_check.builtin {
+                    if !procedure_to_check.source.is_builtin() {
                         // Only perform typechecking on the user-defined
                         // procedures
                         queue.push_back(ResolveQueueElement{
                             root_id: ctx.heap[definition_id].defined_in(),
                             definition_id,
                             reserved_type_id: type_id,
                             reserved_monomorph_index: monomorph_index,
                         });
+                    }
                     (type_id, monomorph_index)
                 };
                 ExpressionInfoVariant::Procedure(type_id, monomorph_index)
             } else if let Expression::Select(_expr) = expr {
                 ExpressionInfoVariant::Select(infer_node.field_index)
             } else {
                 ExpressionInfoVariant::Generic
             };
             infer_node.info_type_id = info_type_id;
             infer_node.info_variant = info_variant;
+        }
         // Write the types of the arguments
         let procedure = &ctx.heap[self.procedure_id];
         for parameter_id in procedure.parameters.iter().copied() {
             let mut concrete = ConcreteType::default();
             let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();
             var_data.var_type.write_concrete_type(&mut concrete);
             let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;
             monomorph.argument_types.push(type_id)
+        }
         // Determine if we have already assigned type indices to the expressions
         // before (the indices that, for a monomorph, can retrieve the type of
         // the expression).
         let has_type_indices = self.reserved_monomorph_index > 0;
         if has_type_indices {
             // already have indices, so resize and then index into it
             debug_assert!(monomorph.expr_info.is_empty());
             monomorph.expr_info.resize(num_infer_nodes, ExpressionInfo::new_invalid());
             for infer_node in self.infer_nodes.iter() {
                 let type_index = ctx.heap[infer_node.expr_id].type_index();
                 monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();
+            }
         } else {
             // no indices yet, need to be assigned in AST

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -924,105 +924,105 @@ impl TypeTable { @@
         // Check all struct fields and construct internal representation
         let mut fields = Vec::with_capacity(definition.fields.len());
         for field in &definition.fields {
             Self::check_member_parser_type(
                 modules, ctx, root_id, &field.parser_type, false
             )?;
             fields.push(StructField{
                 identifier: field.field.clone(),
                 parser_type: field.parser_type.clone(),
             });
+        }
         // Make sure there are no conflicting variables
         Self::check_identifier_collision(
             modules, root_id, &fields, |field| &field.identifier, "struct field"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct base type in table
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for field in &fields {
             Self::mark_used_polymorphic_variables(&mut poly_vars, &field.parser_type);
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.definition_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Struct(StructType{ fields }),
             poly_vars,
             is_polymorph
         });
         return Ok(())
+    }
     /// Builds base procedure type.
     fn build_base_procedure_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base function already built");
         let definition = ctx.heap[definition_id].as_procedure();
         let root_id = definition.defined_in;
         // Check and construct return types and argument types.
         if let Some(return_type) = &definition.return_type {
             Self::check_member_parser_type(
-                modules, ctx, root_id, return_type, definition.builtin
+                modules, ctx, root_id, return_type, definition.source.is_builtin()
             )?;
+        }
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
             Self::check_member_parser_type(
-                modules, ctx, root_id, &parameter.parser_type, definition.builtin
+                modules, ctx, root_id, &parameter.parser_type, definition.source.is_builtin()
             )?;
             arguments.push(ProcedureArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "procedure argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of function type
         // TODO: Marking used polymorphic variables should take statements in
         //  the body into account. But currently we don't. Hence mark them all
         //  as being in-use. Note to self: true condition should be that the
         //  polymorphic variables are used in places where the resulting types
         //  are themselves truly polymorphic types (e.g. not a phantom type).
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         for poly_var in &mut poly_vars {
             poly_var.is_in_use = true;
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.definition_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Procedure(ProcedureType{
                 kind: definition.kind,
                 return_type: definition.return_type.clone(),
                 arguments
             }),
             poly_vars,
             is_polymorph
         });
         return Ok(());
+    }
     /// Will check if the member type (field of a struct, embedded type in a
     /// union variant) is valid.
     fn check_member_parser_type(
         modules: &[Module], ctx: &PassCtx, base_definition_root_id: RootId,
         member_parser_type: &ParserType, allow_special_compiler_types: bool
     ) -> Result<(), ParseError> {

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -14,97 +14,97 @@ struct TestCtx<'a> { @@
     heap: &'a Heap,
     modules: &'a Vec<Module>,
     types: &'a TypeTable,
     symbols: &'a SymbolTable,
+}
 //------------------------------------------------------------------------------
 // Interface for parsing and compiling
 //------------------------------------------------------------------------------
 pub(crate) struct Tester {
     test_name: String,
     sources: Vec<String>
+}
 impl Tester {
     /// Constructs a new tester, allows adding multiple sources before compiling
     pub(crate) fn new<S: ToString>(test_name: S) -> Self {
         Self{
             test_name: test_name.to_string(),
             sources: Vec::new()
+        }
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to succeed.
     pub(crate) fn new_single_source_expect_ok<T: ToString, S: ToString>(test_name: T, source: S) -> AstOkTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_ok()
+    }
     /// Utility for quick tests that use a single source file and expect the
     /// compilation to fail.
     pub(crate) fn new_single_source_expect_err<T: ToString, S: ToString>(test_name: T, source: S) -> AstErrTester {
         Self::new(test_name)
             .with_source(source)
             .compile()
             .expect_err()
+    }
     pub(crate) fn with_source<S: ToString>(mut self, source: S) -> Self {
         self.sources.push(source.to_string());
         self
+    }
     pub(crate) fn compile(self) -> AstTesterResult {
         let mut parser = Parser::new();
+        let mut parser = Parser::new().unwrap();
         for source in self.sources.into_iter() {
             let source = source.into_bytes();
             let input_source = InputSource::new(String::from(""), source);
             if let Err(err) = parser.feed(input_source) {
                 return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+            }
+        }
         if let Err(err) = parser.parse() {
             return AstTesterResult::Err(AstErrTester::new(self.test_name, err))
+        }
         AstTesterResult::Ok(AstOkTester::new(self.test_name, parser))
+    }
+}
 pub(crate) enum AstTesterResult {
     Ok(AstOkTester),
     Err(AstErrTester)
+}
 impl AstTesterResult {
     pub(crate) fn expect_ok(self) -> AstOkTester {
         match self {
             AstTesterResult::Ok(v) => v,
             AstTesterResult::Err(err) => {
                 let wrapped = ErrorTester{ test_name: &err.test_name, error: &err.error };
                 println!("DEBUG: Full error:\n{}", &err.error);
                 assert!(
                     false,
                     "[{}] Expected compilation to succeed, but it failed with {}",
                     err.test_name, wrapped.assert_postfix()
                 );
                 unreachable!();
+            }
+        }
+    }
     pub(crate) fn expect_err(self) -> AstErrTester {
         match self {
             AstTesterResult::Ok(ok) => {
                 assert!(false, "[{}] Expected compilation to fail, but it succeeded", ok.test_name);
                 unreachable!();
             },
             AstTesterResult::Err(err) => err,
+        }
+    }

src/runtime2/component/component.rs

➞

Show inline comments

 use crate::protocol::eval::EvalError;
 use crate::protocol::eval::*;
 use crate::protocol::*;
 use crate::runtime2::*;
 use super::CompCtx;
+use super::{CompCtx, CompPDL};
 pub enum CompScheduling {
     Immediate,
     Requeue,
     Sleep,
     Exit,
+}
 /// Generic representation of a component (as viewed by a scheduler).
 pub(crate) trait Component {
     /// Called if the component is created by another component and the messages
     /// are being transferred between the two.
     fn adopt_message(&mut self, comp_ctx: &mut CompCtx, message: DataMessage);
     /// Called if the component receives a new message. The component is
     /// responsible for deciding where that messages goes.
     fn handle_message(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx, message: Message);
     /// Called if the component's routine should be executed. The return value
     /// can be used to indicate when the routine should be run again.
     fn run(&mut self, sched_ctx: &mut SchedulerCtx, comp_ctx: &mut CompCtx) -> Result<CompScheduling, EvalError>;
+}
 /// Creates a new component based on its definition. Meaning that if it is a
 /// user-defined component then we set up the PDL code state. Otherwise we
 /// construct a custom component. This does NOT take care of port and message
 /// management.
 pub(crate) fn create_component(
     protocol: &ProtocolDescription,
     definition_id: ProcedureDefinitionId, type_id: TypeId,
     arguments: ValueGroup, num_ports: usize
 ) -> Box<dyn Component> {
     let definition = &protocol.heap[definition_id];
     debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite);
     if definition.source.is_builtin() {
         // Builtin component
         todo!("implement")
     } else {
         // User-defined component
         let prompt = Prompt::new(
             &protocol.types, &protocol.heap,
             definition_id, type_id, arguments
         );
         let component = CompPDL::new(prompt, num_ports);
         return Box::new(component);
+    }
+}
@@ \ No newline at end of file @@

src/runtime2/component/component_pdl.rs

➞

Show inline comments

@@ @@ -762,97 +762,97 @@ impl CompPDL { @@
+            }
+        }
+    }
     // -------------------------------------------------------------------------
     // Handling ports
     // -------------------------------------------------------------------------
     /// Unblocks a port, potentially continuing execution of the component, in
     /// response to a message that told us to unblock a previously blocked
     fn handle_unblock_port_instruction(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &mut CompCtx, port_handle: LocalPortHandle) {
         let port_info = comp_ctx.get_port_mut(port_handle);
         let port_id = port_info.self_id;
         debug_assert!(port_info.state.is_blocked());
         port_info.state = PortState::Open;
         if self.mode == Mode::BlockedPut && port_id == self.mode_port {
             // We were blocked on the port that just became unblocked, so
             // send the message.
             debug_assert_eq!(port_info.kind, PortKind::Putter);
             let mut replacement = ValueGroup::default();
             std::mem::swap(&mut replacement, &mut self.mode_value);
             self.send_data_message_and_wake_up(sched_ctx, comp_ctx, port_handle, replacement);
             self.mode = Mode::Sync;
             self.mode_port = PortId::new_invalid();
+        }
+    }
     fn create_component_and_transfer_ports(
         &mut self,
         sched_ctx: &SchedulerCtx, creator_ctx: &mut CompCtx,
         definition_id: ProcedureDefinitionId, type_id: TypeId, mut arguments: ValueGroup
     ) {
         struct PortPair{
             creator_handle: LocalPortHandle,
             creator_id: PortId,
             created_handle: LocalPortHandle,
             created_id: PortId,
+        }
         let mut port_id_pairs = Vec::new();
         let reservation = sched_ctx.runtime.start_create_pdl_component();
         let mut created_ctx = CompCtx::new(&reservation);
         // Take all the ports ID that are in the `args` (and currently belong to
         // the creator component) and translate them into new IDs that are
         // associated with the component we're about to create
-        let mut arg_iter = ValueGroupIter::new(&mut arguments);
+        let mut arg_iter = ValueGroupPortIter::new(&mut arguments);
         while let Some(port_reference) = arg_iter.next() {
             // Create port entry for new component
             let creator_port_id = port_reference.id;
             let creator_port_handle = creator_ctx.get_port_handle(creator_port_id);
             let creator_port = creator_ctx.get_port(creator_port_handle);
             let created_port_handle = created_ctx.add_port(
                 creator_port.peer_comp_id, creator_port.peer_port_id,
                 creator_port.kind, creator_port.state
             );
             let created_port = created_ctx.get_port(created_port_handle);
             let created_port_id = created_port.self_id;
             port_id_pairs.push(PortPair{
                 creator_handle: creator_port_handle,
                 creator_id: creator_port_id,
                 created_handle: created_port_handle,
                 created_id: created_port_id,
             });
             // Modify value in arguments (bit dirty, but double vec in ValueGroup causes lifetime issues)
             let arg_value = if let Some(heap_pos) = port_reference.heap_pos {
                 &mut arg_iter.group.regions[heap_pos][port_reference.index]
             } else {
                 &mut arg_iter.group.values[port_reference.index]
             };
             match arg_value {
                 Value::Input(id) => *id = port_id_to_eval(created_port_id),
                 Value::Output(id) => *id = port_id_to_eval(created_port_id),
                 _ => unreachable!(),
+            }
+        }
         // For each transferred port pair set their peer components to the
         // correct values. This will only change the values for the ports of
         // the new component.
         let mut created_component_has_remote_peers = false;
         for pair in port_id_pairs.iter() {
             let creator_port_info = creator_ctx.get_port(pair.creator_handle);
             let created_port_info = created_ctx.get_port_mut(pair.created_handle);
             if created_port_info.peer_comp_id == creator_ctx.id {
                 // Port peer is owned by the creator as well
                 let created_peer_port_index = port_id_pairs
                     .iter()
                     .position(|v| v.creator_id == creator_port_info.peer_port_id);
                 match created_peer_port_index {
                     Some(created_peer_port_index) => {
@@ @@ -965,115 +965,115 @@ fn port_id_from_eval(port_id: EvalPortId) -> PortId { @@
+}
 #[inline]
 fn port_id_to_eval(port_id: PortId) -> EvalPortId {
     return EvalPortId{ id: port_id.0 };
+}
 /// Recursively goes through the value group, attempting to find ports.
 /// Duplicates will only be added once.
 pub(crate) fn find_ports_in_value_group(value_group: &ValueGroup, ports: &mut Vec<PortId>) {
     // Helper to check a value for a port and recurse if needed.
     fn find_port_in_value(group: &ValueGroup, value: &Value, ports: &mut Vec<PortId>) {
         match value {
             Value::Input(port_id) | Value::Output(port_id) => {
                 // This is an actual port
                 let cur_port = PortId(port_id.id);
                 for prev_port in ports.iter() {
                     if *prev_port == cur_port {
                         // Already added
                         return;
+                    }
+                }
                 ports.push(cur_port);
             },
             Value::Array(heap_pos) |
             Value::Message(heap_pos) |
             Value::String(heap_pos) |
             Value::Struct(heap_pos) |
             Value::Union(_, heap_pos) => {
                 // Reference to some dynamic thing which might contain ports,
                 // so recurse
                 let heap_region = &group.regions[*heap_pos as usize];
                 for embedded_value in heap_region {
                     find_port_in_value(group, embedded_value, ports);
+                }
             },
             _ => {}, // values we don't care about
+        }
+    }
     // Clear the ports, then scan all the available values
     ports.clear();
     for value in &value_group.values {
         find_port_in_value(value_group, value, ports);
+    }
+}
-struct ValueGroupIter<'a> {
+struct ValueGroupPortIter<'a> {
     group: &'a mut ValueGroup,
     heap_stack: Vec<(usize, usize)>,
     index: usize,
+}
-impl<'a> ValueGroupIter<'a> {
+impl<'a> ValueGroupPortIter<'a> {
     fn new(group: &'a mut ValueGroup) -> Self {
         return Self{ group, heap_stack: Vec::new(), index: 0 }
+    }
+}
 struct ValueGroupPortRef {
     id: PortId,
     heap_pos: Option<usize>, // otherwise: on stack
     index: usize,
+}
-impl<'a> Iterator for ValueGroupIter<'a> {
+impl<'a> Iterator for ValueGroupPortIter<'a> {
     type Item = ValueGroupPortRef;
     fn next(&mut self) -> Option<Self::Item> {
         // Enter loop that keeps iterating until a port is found
         loop {
             if let Some(pos) = self.heap_stack.last() {
                 let (heap_pos, region_index) = *pos;
                 if region_index >= self.group.regions[heap_pos].len() {
                     self.heap_stack.pop();
                     continue;
+                }
                 let value = &self.group.regions[heap_pos][region_index];
                 self.heap_stack.last_mut().unwrap().1 += 1;
                 match value {
                     Value::Input(id) | Value::Output(id) => {
                         let id = PortId(id.id);
                         return Some(ValueGroupPortRef{
                             id,
                             heap_pos: Some(heap_pos),
                             index: region_index,
                         });
                     },
                     _ => {},
+                }
                 if let Some(heap_pos) = value.get_heap_pos() {
                     self.heap_stack.push((heap_pos as usize, 0));
+                }
             } else {
                 if self.index >= self.group.values.len() {
                     return None;
+                }
                 let value = &mut self.group.values[self.index];
                 self.index += 1;
                 match value {
                     Value::Input(id) | Value::Output(id) => {
                         let id = PortId(id.id);
                         return Some(ValueGroupPortRef{
                             id,
                             heap_pos: None,
                             index: self.index - 1
                         });
                     },
                     _ => {},

std/std.global.pdl

➞

Show inline comments

@@ new file 100644 @@
 #module std.global
 func get<T>(in<T>) -> T #builtin
 func put<T>(out<T>, T value) -> #type_void #builtin
 func fires<T>(#type_portlike<T>) -> bool #builtin
 func create<T>(#type_integerlike length) -> T[] #builtin
 func length<T>(#type_arraylike<T> array) -> u32 #builtin
 func assert(bool condition) -> #type_void #builtin
 func print(string message) -> #type_void #builtin
@@ \ No newline at end of file @@

0 comments (0 inline, 0 general)