Add fortran-parser crate with recursive descent parser

- Implement recursive descent parser for FORTRAN programs
- Parse program units: PROGRAM, SUBROUTINE, FUNCTION, MODULE
- Parse declarations: variable declarations, type specs, attributes
- Parse statements: IF, DO, READ, WRITE, PRINT, RETURN, STOP, etc.
- Parse expressions: arithmetic, logical, comparison, function calls
- Error handling with location information
- Basic example demonstrating usage
- Add README documentation

Author: MarsZDF

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 members = ["fortran-ast",
-    "fortran-lexer",
+    "fortran-lexer", "fortran-parser",
 ]
 resolver = "2"
 

fortran-parser/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "fortran-parser"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+edition.workspace = true
+description = "Recursive descent parser for FORTRAN source code"
+keywords = ["fortran", "parser", "compiler", "ast"]
+categories = ["parsing", "development-tools"]
+
+[dependencies]
+fortran-lexer = { path = "../fortran-lexer" }
+fortran-ast = { path = "../fortran-ast" }

fortran-parser/README.md

@@ -0,0 +1,46 @@
+# fortran-parser
+
+Recursive descent parser for FORTRAN source code that converts tokens into an Abstract Syntax Tree (AST).
+
+## Features
+
+- ✅ Parses FORTRAN program units (PROGRAM, SUBROUTINE, FUNCTION, MODULE)
+- ✅ Parses declarations (variable declarations, type specifications, attributes)
+- ✅ Parses executable statements (IF, DO, READ, WRITE, PRINT, etc.)
+- ✅ Parses expressions (arithmetic, logical, comparison, function calls)
+- ✅ Error reporting with location information
+- ✅ Handles whitespace and comments gracefully
+
+## Usage
+
+```rust
+use fortran_parser::parse;
+
+let source = r#"
+program hello
+    implicit none
+    integer :: i
+    print *, 'Hello, World!'
+end program hello
+"#;
+
+let program = parse(source)?;
+println!("Parsed: {:?}", program);
+```
+
+## Examples
+
+See [examples/basic_parse.rs](examples/basic_parse.rs) for a complete example.
+
+```bash
+cargo run --example basic_parse
+```
+
+## Status
+
+Basic parsing implemented. More FORTRAN constructs are being added.
+
+## License
+
+MIT
+

fortran-parser/examples/basic_parse.rs

@@ -0,0 +1,32 @@
+use fortran_parser::parse;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let source = r#"
+program hello_world
+    implicit none
+    integer :: i
+    real :: x
+    
+    x = 3.14159
+    do i = 1, 10
+        if (i .gt. 5) then
+            print *, 'Greater than 5: ', i
+        else
+            print *, 'Less than or equal to 5: ', i
+        end if
+    end do
+    
+    print *, 'Hello, World!'
+end program hello_world
+"#;
+
+    println!("Parsing FORTRAN source...\n");
+    
+    let program = parse(source)?;
+    
+    println!("Successfully parsed program!");
+    println!("Program unit: {:?}", program.program_unit);
+    
+    Ok(())
+}
+

fortran-parser/src/error.rs

@@ -0,0 +1,72 @@
+use fortran_lexer::LexError;
+use fortran_lexer::Token;
+
+/// Parser error.
+#[derive(Debug, Clone, PartialEq)]
+pub enum ParseError {
+    /// Unexpected token found.
+    UnexpectedToken {
+        expected: Vec<String>,
+        found: Token,
+    },
+    /// Unexpected end of file.
+    UnexpectedEof {
+        expected: Vec<String>,
+    },
+    /// Lexer error.
+    LexerError(LexError),
+    /// Invalid syntax.
+    InvalidSyntax {
+        message: String,
+        line: usize,
+        column: usize,
+    },
+}
+
+pub type ParseResult<T> = Result<T, ParseError>;
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::UnexpectedToken { expected, found } => {
+                write!(
+                    f,
+                    "Unexpected token {:?} at line {}, column {}. Expected: {}",
+                    found.token_type,
+                    found.line,
+                    found.column,
+                    expected.join(" or ")
+                )
+            }
+            ParseError::UnexpectedEof { expected } => {
+                write!(
+                    f,
+                    "Unexpected end of file. Expected: {}",
+                    expected.join(" or ")
+                )
+            }
+            ParseError::LexerError(err) => {
+                write!(f, "Lexer error: {}", err)
+            }
+            ParseError::InvalidSyntax { message, line, column } => {
+                write!(f, "Invalid syntax at line {}, column {}: {}", line, column, message)
+            }
+        }
+    }
+}
+
+impl std::error::Error for ParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            ParseError::LexerError(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl From<LexError> for ParseError {
+    fn from(err: LexError) -> Self {
+        ParseError::LexerError(err)
+    }
+}
+

fortran-parser/src/lib.rs

@@ -0,0 +1,10 @@
+//! FORTRAN parser library.
+//!
+//! Provides a recursive descent parser for FORTRAN source code that converts
+//! tokens into an Abstract Syntax Tree (AST).
+
+pub mod error;
+pub mod parser;
+
+pub use error::{ParseError, ParseResult};
+pub use parser::{parse, Parser};