Add ProgramBuilder::add_pcode(path) and --pcode CLI

Author: Dinnerbone

crates/cli/src/main.rs

@@ -11,13 +11,23 @@ struct Opt {
     /// A loose script (not class file) to add to the compiled program.
     ///
     /// Multiple scripts may be added to one program.
-    /// Scripts will be executed in order that they are added, before any classes are loaded.
+    /// Scripts will be executed in order that they are added, before any classes are loaded and after any raw pcode.
     ///
     /// It is valid to not specify any scripts - if so, the entry point of the program will be the first
     /// class (see `--class`) that contains a `static function main()` method.
     #[arg(name = "SCRIPT", help_heading = "Inputs")]
     script: Vec<PathBuf>,
 
+    /// Path to some raw pcode to add to the compiled program.
+    ///
+    /// Multiple pcodes may be added to one program.
+    /// Pcodes will be executed in order that they are added, before any scripts are executed.
+    ///
+    /// It is valid to not specify any scripts - if so, the entry point of the program will be the first
+    /// class (see `--class`) that contains a `static function main()` method.
+    #[arg(long, help_heading = "Inputs")]
+    pcode: Vec<PathBuf>,
+
     /// Output file path. This will be overwritten if it already exists.
     ///
     /// If not specified:
@@ -71,8 +81,11 @@ fn main() -> Result<()> {
     let provider = FileSystemSourceProvider::with_roots(opt.classpath);
     let mut builder = ProgramBuilder::new(provider);
 
+    for src in &opt.pcode {
+        builder.add_pcode(&src.to_string_lossy());
+    }
     for src in &opt.script {
-        builder.add_script(&src.file_name().unwrap().to_string_lossy());
+        builder.add_script(&src.to_string_lossy());
     }
     for class in &opt.class {
         builder.add_class(class);

crates/rascal/src/internal/as2/error.rs

@@ -31,3 +31,16 @@ impl From<ParseError<Tokens<'_>, ContextError>> for ParsingError {
         }
     }
 }
+
+impl From<ParseError<crate::internal::as2_pcode::Tokens<'_>, ContextError>> for ParsingError {
+    fn from(error: ParseError<crate::internal::as2_pcode::Tokens, ContextError>) -> Self {
+        Self {
+            error: error.inner().to_string(),
+            span: error
+                .input()
+                .get(error.offset())
+                .map(|t| t.span)
+                .unwrap_or_default(),
+        }
+    }
+}

crates/rascal/src/internal/as2_pcode.rs

@@ -1,6 +1,8 @@
-use crate::internal::as2_pcode::lexer::Lexer;
+pub use crate::internal::as2_pcode::lexer::Lexer;
 use crate::internal::as2_pcode::lexer::tokens::Token;
 use crate::internal::as2_pcode::parser::PCodeError;
+pub use crate::internal::as2_pcode::parser::Tokens;
+pub use crate::internal::as2_pcode::parser::parse_actions;
 pub use crate::internal::as2_pcode::pcode::Action;
 pub use crate::internal::as2_pcode::pcode::Actions;
 pub use crate::internal::as2_pcode::pcode::CatchTarget;

crates/rascal/src/internal/as2_pcode/parser.rs

@@ -8,10 +8,10 @@ mod error;
 #[cfg(test)]
 mod tests;
 
-pub(crate) type Tokens<'i> = TokenSlice<'i, Token<'i>>;
+pub type Tokens<'i> = TokenSlice<'i, Token<'i>>;
 
 pub use crate::internal::as2_pcode::parser::error::PCodeError;
-use crate::internal::as2_pcode::pcode::Actions;
+pub use crate::internal::as2_pcode::pcode::Actions;
 
 pub fn parse_actions<'a>(
     source: &'a [Token],

crates/rascal/src/program.rs

@@ -14,6 +14,7 @@ pub struct Program {
     pub(crate) initial_script: Vec<hir::StatementKind>,
     pub(crate) interfaces: Vec<hir::Interface>,
     pub(crate) classes: Vec<hir::Class>,
+    pub(crate) custom_pcodes: Vec<Actions>,
 }
 
 impl Program {
@@ -36,6 +37,7 @@ impl Program {
             initializer,
             extra_modules,
             swf_version,
+            custom_pcodes: self.custom_pcodes.clone(),
         }
     }
 }
@@ -45,6 +47,7 @@ pub struct CompiledProgram {
     pub(crate) initializer: Option<Actions>,
     pub(crate) extra_modules: Vec<(String, Actions)>,
     pub(crate) swf_version: u8,
+    pub(crate) custom_pcodes: Vec<Actions>,
 }
 
 impl CompiledProgram {
@@ -56,6 +59,7 @@ impl CompiledProgram {
 pub struct ProgramBuilder<P> {
     provider: P,
     scripts: Vec<String>,
+    pcodes: Vec<String>,
     classes: Vec<String>,
 }
 
@@ -64,6 +68,10 @@ impl<P> ProgramBuilder<P> {
         self.scripts.push(path.to_owned());
     }
 
+    pub fn add_pcode(&mut self, path: &str) {
+        self.pcodes.push(path.to_owned());
+    }
+
     pub fn add_class(&mut self, path: &str) {
         self.classes.push(path.to_owned());
     }
@@ -74,6 +82,7 @@ impl<P: SourceProvider> ProgramBuilder<P> {
         Self {
             provider,
             scripts: vec![],
+            pcodes: vec![],
             classes: vec![],
         }
     }
@@ -85,8 +94,9 @@ impl<P: SourceProvider> ProgramBuilder<P> {
         let mut errors = ErrorSet::new();
         let mut loaded_classes = IndexSet::new();
         let mut pending_classes = self.classes;
+        let mut custom_pcodes = vec![];
 
-        fn load_file<P: SourceProvider>(
+        fn load_actionscript<P: SourceProvider>(
             provider: &P,
             errors: &mut ErrorSet,
             loaded_classes: &mut IndexSet<String>,
@@ -126,8 +136,32 @@ impl<P: SourceProvider> ProgramBuilder<P> {
             Some(hir)
         }
 
+        fn load_pcode<P: SourceProvider>(
+            provider: &P,
+            errors: &mut ErrorSet,
+            path: &str,
+            custom_pcodes: &mut Vec<Actions>,
+        ) {
+            let source = match provider.load(path) {
+                Ok(source) => source,
+                Err(e) => {
+                    errors.add_io_error(path, e);
+                    return;
+                }
+            };
+            let tokens = crate::internal::as2_pcode::Lexer::new(&source).into_vec();
+            match crate::internal::as2_pcode::parse_actions(&tokens) {
+                Ok(actions) => custom_pcodes.push(actions),
+                Err(e) => errors.add_parsing_error(path, &source, e.into()),
+            }
+        }
+
+        for path in self.pcodes {
+            load_pcode(&self.provider, &mut errors, &path, &mut custom_pcodes);
+        }
+
         for path in self.scripts {
-            if let Some(document) = load_file(
+            if let Some(document) = load_actionscript(
                 &self.provider,
                 &mut errors,
                 &mut loaded_classes,
@@ -145,7 +179,7 @@ impl<P: SourceProvider> ProgramBuilder<P> {
 
         while let Some(type_name) = pending_classes.pop() {
             let filename = type_path_to_file_path(&type_name);
-            if let Some(document) = load_file(
+            if let Some(document) = load_actionscript(
                 &self.provider,
                 &mut errors,
                 &mut loaded_classes,
@@ -186,6 +220,7 @@ impl<P: SourceProvider> ProgramBuilder<P> {
             initial_script,
             interfaces,
             classes,
+            custom_pcodes,
         })
     }
 }

crates/rascal/src/snapshots/rascal__program__tests__all_samples@AnEmptyInterface.as.snap

@@ -10,3 +10,4 @@ Ok:
       extends: ~
       functions: {}
   classes: []
+  custom_pcodes: []

crates/rascal/src/snapshots/rascal__program__tests__all_samples@AnExtendingInterface.as.snap

@@ -21,3 +21,4 @@ Ok:
       extends: ~
       functions: {}
   classes: []
+  custom_pcodes: []

crates/rascal/src/snapshots/rascal__program__tests__all_samples@ClassMembersTest.as.snap

@@ -979,3 +979,4 @@ Ok:
           args: []
           return_type: ~
         body: []
+  custom_pcodes: []

crates/rascal/src/snapshots/rascal__program__tests__all_samples@DynamicClass.as.snap

@@ -23,3 +23,4 @@ Ok:
           args: []
           return_type: ~
         body: []
+  custom_pcodes: []

crates/rascal/src/snapshots/rascal__program__tests__all_samples@EmptyClass.as.snap

@@ -23,3 +23,4 @@ Ok:
           args: []
           return_type: ~
         body: []
+  custom_pcodes: []