fix: library compiles again — two spec defects + regenerated gen/rust

gen/rust/access_control.rs

@@ -1,3 +1,3 @@
 // Generated from .t27 spec
 // DO NOT EDIT — generated by t27c
 
@@ -65,7 +65,7 @@
 
 pub fn check_access(policy: u32, role: u32) -> u32 {
     let min_role = get_min_role(policy);
-    if !(role_meets_minimum(role, min_role)) {
+    if ((role_meets_minimum(role, min_role)) == 0) {
         return DENY;
     }
     if (role == ROLE_GUEST) {
@@ -111,7 +111,7 @@
 }
 
 pub fn check_resource_access(creds: u32, policy: u32, provided_token: u32) -> u32 {
-    if !(verify_creds(creds, provided_token)) {
+    if ((verify_creds(creds, provided_token)) == 0) {
         return DENY;
     }
     let role = get_role(creds);

gen/rust/adaptive_retry.rs

@@ -24,6 +24,7 @@ pub fn base_probability(quality_q8: u8) -> u8 { unimplemented!() }
 
 pub fn retry_success_probability(attempt: u8, quality_q8: u8) -> u8 {
     let base_prob: u8 = base_probability(quality_q8);
+    let decay: u8 = ((base_prob / 4) * attempt);
 }
 
 pub fn total_retry_time(max_retries: u8) -> u16 { unimplemented!() }

gen/rust/anomaly_detector.rs

@@ -67,12 +67,12 @@ pub const TYPE_PATTERN: u32 = 2;
 
 pub const TYPE_TREND: u32 = 3;
 
-pub fn calculate_baseline(history: Vec, count: u32) -> u32 {
+pub fn calculate_baseline(history: [u32; MAX_METRICS as usize], count: u32) -> u32 {
     let mut sum: u32 = 0;
     let mut valid_count: u32 = 0;
     let mut i: u32 = 0;
     while (i < count) {
-        let value: u32 = get_metric_value(history[i]);
+        let value: u32 = get_metric_value(history[(i) as usize]);
         sum = (sum + value);
         valid_count = (valid_count + 1);
         i = (i + 1);
@@ -84,11 +84,11 @@ pub fn calculate_baseline(history: Vec, count: u32) -> u32 {
     }
 }
 
-pub fn calculate_variance(history: Vec, count: u32, baseline: u32) -> u32 {
+pub fn calculate_variance(history: [u32; MAX_METRICS as usize], count: u32, baseline: u32) -> u32 {
     let mut sum_diff: u32 = 0;
     let mut i: u32 = 0;
     while (i < count) {
-        let value: u32 = get_metric_value(history[i]);
+        let value: u32 = get_metric_value(history[(i) as usize]);
         let mut diff: u32 = 0;
         if (value > baseline) {
             diff = (value - baseline);
@@ -139,16 +139,16 @@ pub fn detect_drop(current: u32, baseline: u32, variance: u32) -> u32 {
     return 0;
 }
 
-pub fn detect_pattern(history: Vec, count: u32) -> u32 {
+pub fn detect_pattern(history: [u32; MAX_METRICS as usize], count: u32) -> u32 {
     if (count < 4) {
         return 0;
     }
     let mut pattern_count: u32 = 0;
     let mut i: u32 = 0;
     while (i < (count - 2)) {
-        let val1: u32 = get_metric_value(history[i]);
-        let val2: u32 = get_metric_value(history[(i + 1)]);
-        let val3: u32 = get_metric_value(history[(i + 2)]);
+        let val1: u32 = get_metric_value(history[(i) as usize]);
+        let val2: u32 = get_metric_value(history[(i + 1) as usize]);
+        let val3: u32 = get_metric_value(history[(i + 2) as usize]);
         if (((val1 > val2) && (val2 < val3)) || ((val1 < val2) && (val2 > val3))) {
             pattern_count = (pattern_count + 1);
         }
@@ -161,16 +161,16 @@ pub fn detect_pattern(history: Vec, count: u32) -> u32 {
     }
 }
 
-pub fn detect_trend(history: Vec, count: u32) -> u32 {
+pub fn detect_trend(history: [u32; MAX_METRICS as usize], count: u32) -> u32 {
     if (count < 4) {
         return 0;
     }
     let mut increases: u32 = 0;
     let mut decreases: u32 = 0;
     let mut i: u32 = 0;
     while (i < (count - 1)) {
-        let current: u32 = get_metric_value(history[i]);
-        let next: u32 = get_metric_value(history[(i + 1)]);
+        let current: u32 = get_metric_value(history[(i) as usize]);
+        let next: u32 = get_metric_value(history[(i + 1) as usize]);
         if (next > current) {
             increases = (increases + 1);
         } else {
@@ -209,7 +209,11 @@ pub fn calculate_severity(current: u32, baseline: u32) -> u32 {
     }
 }
 
-pub fn detect_anomaly(history: Vec, count: u32, current_reading: u32) -> u32 {
+pub fn detect_anomaly(
+    history: [u32; MAX_METRICS as usize],
+    count: u32,
+    current_reading: u32,
+) -> u32 {
     if (count < BASELINE_WINDOW) {
         return 0;
     }
@@ -278,8 +282,8 @@ pub fn get_anomaly_description(report: u32) -> u32 {
 pub fn correlate_metrics(
     metric1_id: u32,
     metric2_id: u32,
-    history1: Vec,
-    history2: Vec,
+    history1: [u32; MAX_METRICS as usize],
+    history2: [u32; MAX_METRICS as usize],
     count: u32,
 ) -> u32 {
     if (count < 4) {
@@ -288,10 +292,10 @@ pub fn correlate_metrics(
     let mut same_direction: u32 = 0;
     let mut i: u32 = 0;
     while (i < (count - 1)) {
-        let val1_current: u32 = get_metric_value(history1[i]);
-        let val1_next: u32 = get_metric_value(history1[(i + 1)]);
-        let val2_current: u32 = get_metric_value(history2[i]);
-        let val2_next: u32 = get_metric_value(history2[(i + 1)]);
+        let val1_current: u32 = get_metric_value(history1[(i) as usize]);
+        let val1_next: u32 = get_metric_value(history1[(i + 1) as usize]);
+        let val2_current: u32 = get_metric_value(history2[(i) as usize]);
+        let val2_next: u32 = get_metric_value(history2[(i + 1) as usize]);
         let mut direction1: u32 = 0;
         if (val1_next > val1_current) {
             direction1 = 1;
@@ -320,11 +324,11 @@ pub fn correlate_metrics(
     }
 }
 
-pub fn detect_coordinated_attack(anomalies: Vec, count: u32) -> u32 {
+pub fn detect_coordinated_attack(anomalies: [u32; MAX_METRICS as usize], count: u32) -> u32 {
     let mut critical_count: u32 = 0;
     let mut i: u32 = 0;
     while (i < count) {
-        if (is_critical_anomaly(anomalies[i]) == 1) {
+        if (is_critical_anomaly(anomalies[(i) as usize]) == 1) {
             critical_count = (critical_count + 1);
         }
         i = (i + 1);

gen/rust/api_documenter.rs

@@ -92,8 +92,10 @@ pub fn get_example_explanation(example: u32) -> u32 {
 pub fn generate_function_example(func_doc: u32) -> u32 {
     let func_id: u32 = get_doc_function_id(func_doc);
     let param_count: u32 = get_doc_param_count(func_doc);
+    let return_type: u32 = get_doc_return_type(func_doc);
     let example_input: u32 = (param_count * 10);
     let example_output: u32 = (example_input + 5);
+    let explanation: u32 = 1;
     return create_function_example(func_id, example_input, example_output, 1);
 }
 
@@ -119,10 +121,14 @@ pub fn get_description_category(desc: u32) -> u32 {
 
 pub fn generate_function_description(func_doc: u32, complexity: u32) -> u32 {
     let func_id: u32 = get_doc_function_id(func_doc);
+    let param_count: u32 = get_doc_param_count(func_doc);
+    let return_type: u32 = get_doc_return_type(func_doc);
     let mut desc_length: u32 = (50 + (complexity * 10));
     if (desc_length > 255) {
         desc_length = 255;
     }
+    let importance: u32 = 1;
+    let category: u32 = 0;
     return create_description_text(func_id, desc_length, 1, 0);
 }
 
@@ -178,11 +184,11 @@ pub fn get_module_description(module_doc: u32) -> u32 {
     return (module_doc & 0xFF);
 }
 
-pub fn calculate_average_complexity(func_docs: Vec<>, func_count: u32) -> u32 {
+pub fn calculate_average_complexity(func_docs: [u32; MAX_FUNCTIONS as usize], func_count: u32) -> u32 {
     let mut total_complexity: u32 = 0;
     let mut i: u32 = 0;
     while (i < func_count) {
-        total_complexity = (total_complexity + get_doc_complexity(func_docs[i]));
+        total_complexity = (total_complexity + get_doc_complexity(func_docs[(i) as usize]));
         i = (i + 1);
     }
     if (func_count > 0) {
@@ -192,12 +198,12 @@ pub fn calculate_average_complexity(func_docs: Vec<>, func_count: u32) -> u32 {
     }
 }
 
-pub fn generate_api_documentation(func_docs: Vec<>, func_count: u32, param_docs: Vec<>, param_count: u32) -> u32 {
+pub fn generate_api_documentation(func_docs: [u32; MAX_FUNCTIONS as usize], func_count: u32, param_docs: [u32; MAX_PARAMETERS as usize], param_count: u32) -> u32 {
     let mut total_complexity: u32 = 0;
     let mut documented_funcs: u32 = 0;
     let mut i: u32 = 0;
     while (i < func_count) {
-        let func_doc: u32 = func_docs[i];
+        let func_doc: u32 = func_docs[(i) as usize];
         total_complexity = (total_complexity + get_doc_complexity(func_doc));
         let description: u32 = generate_function_description(func_doc, get_doc_complexity(func_doc));
         let example: u32 = generate_function_example(func_doc);
@@ -223,12 +229,12 @@ pub fn generate_usage_example(func_doc: u32, context: u32) -> u32 {
     return create_function_example(func_id, usage_pattern, (usage_pattern + 10), 2);
 }
 
-pub fn create_dependency_graph(xrefs: Vec<>, xref_count: u32) -> u32 {
+pub fn create_dependency_graph(xrefs: [u32; MAX_FUNCTIONS as usize], xref_count: u32) -> u32 {
     let mut total_connections: u32 = 0;
     let mut strong_connections: u32 = 0;
     let mut i: u32 = 0;
     while (i < xref_count) {
-        let strength: u32 = get_xref_strength(xrefs[i]);
+        let strength: u32 = get_xref_strength(xrefs[(i) as usize]);
         total_connections = (total_connections + 1);
         if (strength > 70) {
             strong_connections = (strong_connections + 1);
@@ -242,12 +248,13 @@ pub fn create_dependency_graph(xrefs: Vec<>, xref_count: u32) -> u32 {
     return (((((total_connections & 0xFF) << 24) | ((strong_connections & 0xFF) << 16)) | ((avg_strength & 0xFF) << 8)) | (xref_count & 0xFF));
 }
 
-pub fn validate_documentation(func_docs: Vec<>, func_count: u32) -> u32 {
+pub fn validate_documentation(func_docs: [u32; MAX_FUNCTIONS as usize], func_count: u32) -> u32 {
     let mut missing_descriptions: u32 = 0;
+    let missing_examples: u32 = 0;
     let mut missing_params: u32 = 0;
     let mut i: u32 = 0;
     while (i < func_count) {
-        let func_doc: u32 = func_docs[i];
+        let func_doc: u32 = func_docs[(i) as usize];
         let complexity: u32 = get_doc_complexity(func_doc);
         if (complexity == 0) {
             missing_descriptions = (missing_descriptions + 1);
@@ -265,12 +272,13 @@ pub fn validate_documentation(func_docs: Vec<>, func_count: u32) -> u32 {
     return (((((missing_descriptions & 0xFF) << 24) | 0) | ((missing_params & 0xFF) << 8)) | (quality_score & 0xFF));
 }
 
-pub fn generate_documentation_report(func_docs: Vec<>, func_count: u32, xrefs: Vec<>, xref_count: u32) -> u32 {
+pub fn generate_documentation_report(func_docs: [u32; MAX_FUNCTIONS as usize], func_count: u32, xrefs: [u32; MAX_FUNCTIONS as usize], xref_count: u32) -> u32 {
     let doc_summary: u32 = generate_api_documentation(func_docs, func_count, func_docs, 0);
     let documented_funcs: u32 = ((doc_summary >> 24) & 0xFF);
     let coverage: u32 = calculate_documentation_coverage(documented_funcs, func_count);
     let validation: u32 = validate_documentation(func_docs, func_count);
     let quality_score: u32 = (validation & 0xFF);
+    let dependency_graph: u32 = create_dependency_graph(xrefs, xref_count);
     let doc_complexity: u32 = ((doc_summary >> 8) & 0xFF);
     return (((((coverage & 0xFF) << 24) | ((quality_score & 0xFF) << 16)) | ((doc_complexity & 0xFF) << 8)) | (xref_count & 0xFF));
 }