Struct VB6Project

pub struct VB6Project<'a> {

    pub project_type: CompileTargetType,
    pub references: Vec<VB6ProjectReference<'a>>,
    pub objects: Vec<VB6ObjectReference<'a>>,
    pub modules: Vec<VB6ProjectModule<'a>>,
    pub classes: Vec<VB6ProjectClass<'a>>,
    pub related_documents: Vec<&'a BStr>,
    pub designers: Vec<&'a BStr>,
    pub forms: Vec<&'a BStr>,
    pub user_controls: Vec<&'a BStr>,
    pub user_documents: Vec<&'a BStr>,
    pub other_properties: HashMap<&'a BStr, HashMap<&'a BStr, &'a BStr>>,
    pub unused_control_info: UnusedControlInfo,
    pub upgrade_controls: UpgradeControls,
    pub res_file_32_path: Option<&'a BStr>,
    pub icon_form: Option<&'a BStr>,
    pub startup: Option<&'a BStr>,
    pub help_file_path: Option<&'a BStr>,
    pub title: Option<&'a BStr>,
    pub exe_32_file_name: Option<&'a BStr>,
    pub exe_32_compatible: Option<&'a BStr>,
    pub dll_base_address: u32,
    pub path_32: Option<&'a BStr>,
    pub command_line_arguments: Option<&'a BStr>,
    pub name: Option<&'a BStr>,
    pub description: Option<&'a BStr>,
    pub debug_startup_component: Option<&'a BStr>,
    pub help_context_id: Option<&'a BStr>,
    pub compatibility_mode: CompatibilityMode,
    pub version_32_compatibility: Option<&'a BStr>,
    pub version_info: VersionInformation<'a>,
    pub server_support_files: ServerSupportFiles,
    pub conditional_compile: Option<&'a BStr>,
    pub compilation_type: CompilationType,
    pub start_mode: StartMode,
    pub unattended: Unattended,
    pub retained: Retained,
    pub thread_per_object: Option<u16>,
    pub threading_model: ThreadingModel,
    pub max_number_of_threads: u16,
    pub debug_startup_option: DebugStartupOption,
    pub use_existing_browser: UseExistingBrowser,
    pub property_page: Option<&'a BStr>,
}

Fields

project_type: CompileTargetType

references: Vec<VB6ProjectReference<'a>>

objects: Vec<VB6ObjectReference<'a>>

modules: Vec<VB6ProjectModule<'a>>

classes: Vec<VB6ProjectClass<'a>>

related_documents: Vec<&'a BStr>

designers: Vec<&'a BStr>

forms: Vec<&'a BStr>

user_controls: Vec<&'a BStr>

user_documents: Vec<&'a BStr>

other_properties: HashMap<&'a BStr, HashMap<&'a BStr, &'a BStr>>

unused_control_info: UnusedControlInfo

upgrade_controls: UpgradeControls

res_file_32_path: Option<&'a BStr>

icon_form: Option<&'a BStr>

startup: Option<&'a BStr>

help_file_path: Option<&'a BStr>

title: Option<&'a BStr>

exe_32_file_name: Option<&'a BStr>

exe_32_compatible: Option<&'a BStr>

dll_base_address: u32

path_32: Option<&'a BStr>

command_line_arguments: Option<&'a BStr>

name: Option<&'a BStr>

description: Option<&'a BStr>

debug_startup_component: Option<&'a BStr>

help_context_id: Option<&'a BStr>

compatibility_mode: CompatibilityMode

version_32_compatibility: Option<&'a BStr>

version_info: VersionInformation<'a>

server_support_files: ServerSupportFiles

conditional_compile: Option<&'a BStr>

compilation_type: CompilationType

start_mode: StartMode

unattended: Unattended

retained: Retained

thread_per_object: Option<u16>

threading_model: ThreadingModel

max_number_of_threads: u16

debug_startup_option: DebugStartupOption

use_existing_browser: UseExistingBrowser

property_page: Option<&'a BStr>

Implementations

impl<'a> VB6Project<'a>

pub fn parse( file_name: impl Into<String>, source_code: &'a [u8], ) -> Result<Self, VB6Error>

Parses a VB6 project file.

Arguments

• input - The input to parse.

Returns

A Result containing the parsed project or an error.

Errors

This function can return a VB6Error if the input is not a valid VB6 project file.

Panics

This function can panic if the input is not a valid VB6 project file.

Example

use crate::vb6parse::VB6Project;
use crate::vb6parse::parsers::CompileTargetType;
use crate::vb6parse::parsers::project::CompatibilityMode;
use bstr::BStr;

let input = r#"Type=Exe
Reference=*\G{00020430-0000-0000-C000-000000000046}#2.0#0#C:\Windows\System32\stdole2.tlb#OLE Automation
Object={00020430-0000-0000-C000-000000000046}#2.0#0; stdole2.tlb
Module=Module1; Module1.bas
Class=Class1; Class1.cls
Form=Form1.frm
Form=Form2.frm
UserControl=UserControl1.ctl
UserDocument=UserDocument1.uds
ExeName32="Project1.exe"
Command32=""
Path32=""
Name="Project1"
HelpContextID="0"
CompatibleMode="0"
MajorVer=1
MinorVer=0
RevisionVer=0
AutoIncrementVer=0
StartMode=0
Unattended=0
Retained=0
ThreadPerObject=0
MaxNumberOfThreads=1
DebugStartupOption=0
NoControlUpgrade=0
ServerSupportFiles=0
VersionCompanyName="Company Name"
VersionFileDescription="File Description"
VersionLegalCopyright="Copyright"
VersionLegalTrademarks="Trademark"
VersionProductName="Product Name"
VersionComments="Comments"
CompilationType=0
OptimizationType=0
FavorPentiumPro(tm)=0
CodeViewDebugInfo=0
NoAliasing=0
BoundsCheck=0
OverflowCheck=0
FlPointCheck=0
FDIVCheck=0
UnroundedFP=0
CondComp=""
ResFile32=""
IconForm=""
Startup="Form1"
HelpFile=""
Title="Project1"

[MS Transaction Server]
AutoRefresh=1
"#;

let project = VB6Project::parse("project1.vbp", input.as_bytes()).unwrap();

assert_eq!(project.project_type, CompileTargetType::Exe);
assert_eq!(project.references.len(), 1);
assert_eq!(project.objects.len(), 1);
assert_eq!(project.modules.len(), 1);
assert_eq!(project.classes.len(), 1);
assert_eq!(project.designers.len(), 0);
assert_eq!(project.forms.len(), 2);
assert_eq!(project.user_controls.len(), 1);
assert_eq!(project.user_documents.len(), 1);
assert_eq!(project.startup, Some(BStr::new(b"Form1")));
assert_eq!(project.title, Some(BStr::new(b"Project1")));
assert_eq!(project.exe_32_file_name, Some(BStr::new(b"Project1.exe")));

pub fn get_subproject_references(&self) -> Vec<&VB6ProjectReference<'_>>

pub fn get_compiled_references(&self) -> Vec<&VB6ProjectReference<'_>>

Trait Implementations

impl<'a> Clone for VB6Project<'a>

fn clone(&self) -> VB6Project<'a>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for VB6Project<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> PartialEq for VB6Project<'a>

fn eq(&self, other: &VB6Project<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for VB6Project<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for VB6Project<'a>

impl<'a> StructuralPartialEq for VB6Project<'a>