support declarations in function body

src/ast/types.ts

@@ -132,6 +132,9 @@ export interface TypedDeclaration extends BaseNode {
   declaratorList: TypedInitDeclarator[];
 }
 
+export const isTypedDeclaration = (i: TypedBlockItem): i is TypedDeclaration =>
+  i.type === "Declaration";
+
 export interface TypedefDeclaration extends BaseNode {
   type: "TypedefDeclaration";
   declaratorList: Typedef[];
@@ -185,6 +188,7 @@ export interface InitDeclarator extends BaseNode {
 export interface TypedInitDeclarator extends BaseNode {
   type: "InitDeclarator";
   identifier: Identifier;
+  qualifiedIdentifier?: Identifier;
   typeInfo: ObjectTypeInfo;
   initializer: TypedInitializer | null;
 }
@@ -338,6 +342,10 @@ export interface TypedCompoundStatement extends BaseNode {
   value: TypedBlockItem[];
 }
 
+export const isTypedCompoundStatement = (
+  i: TypedStatement,
+): i is TypedCompoundStatement => i.type === "CompoundStatement";
+
 export type BlockItem = Statement | Declaration;
 
 export type TypedBlockItem =

src/interpreter/evaluators.ts

@@ -68,6 +68,7 @@ import {
   branchInstruction,
   callInstruction,
   castInstruction,
+  exitBlockInstruction,
   isMarkInstruction,
   markInstruction,
   popInstruction,
@@ -88,6 +89,7 @@ import { Endianness } from "../config";
 import { RuntimeStack } from "./stack";
 import { SHRT_SIZE } from "../constants";
 import { checkSimpleAssignmentConstraint, getMember } from "../typing/utils";
+import { NO_EFFECTIVE_TYPE } from "./effectiveTypeTable";
 
 export const ASTNodeEvaluator: {
   [NodeType in TypedASTNode["type"]]: (
@@ -134,18 +136,22 @@ export const ASTNodeEvaluator: {
   TypedefDeclaration: () => {},
   InitDeclarator: (
     rt: Runtime,
-    { identifier, typeInfo, initializer }: TypedInitDeclarator,
+    { identifier, typeInfo, initializer, qualifiedIdentifier }: TypedInitDeclarator,
   ) => {
-    if (!rt.symbolTable.inFileScope) {
-      throw new Error("declarations in functions not implemented");
+    let address: number;
+    if (rt.symbolTable.inFileScope) {
+      address = rt.allocateAndZeroData(typeInfo);
+      const o = new RuntimeObject(typeInfo, address, identifier, rt.memory);
+      o.initialized = true;
+      rt.textAndData.push(o);
+    } else {
+      if (!qualifiedIdentifier) throw new Error("missing call to calculateStackFrame");
+      const frame = rt.stack.peek();
+      address = rt.stack.rbp + frame[qualifiedIdentifier].address;
     }
 
-    const address = rt.allocateAndZeroData(typeInfo);
-    const o = new RuntimeObject(typeInfo, address, identifier, rt.memory);
-    rt.textAndData.push(o);
     rt.symbolTable.addAddress(identifier, address);
     rt.effectiveTypeTable.add(address, typeInfo);
-
     if (initializer) evaluateInitializer(initializer, address, typeInfo, rt);
   },
   InitializerList: () => {
@@ -155,6 +161,8 @@ export const ASTNodeEvaluator: {
     rt: Runtime,
     { value: stmts }: TypedCompoundStatement,
   ) => {
+    rt.symbolTable.enterBlock();
+    rt.agenda.push(exitBlockInstruction());
     for (let i = stmts.length - 1; i >= 0; i--) {
       rt.agenda.push(stmts[i]);
     }
@@ -712,6 +720,7 @@ export const instructionEvaluator: {
           rt.config.endianness,
         );
         rt.memory.setScalar(address, n, typeInfo, rt.config.endianness);
+        rt.initTable.add(address, typeInfo);
         rt.stash.pushWithoutConversions(
           new TemporaryObject(
             typeInfo,
@@ -722,7 +731,9 @@ export const instructionEvaluator: {
       }
       if (isStructure(typeInfo) && isStructure(o.typeInfo)) {
         rt.memory.setObjectBytes(address, o.bytes, typeInfo);
+        rt.initTable.add(address, typeInfo);
         rt.stash.pushWithoutConversions(o);
+        return;
       }
     }
 
@@ -731,7 +742,7 @@ export const instructionEvaluator: {
   [InstructionType.MARK]: (rt: Runtime) => {
     const idx = rt.functionCalls.peek();
     if (rt.getFunctions()[idx][0] !== "main") {
-      throw new Error("mark encountered without return");
+      throw new Error("mark encountered without return (are you missing a return statement?)");
     }
     // main implicitly returns 0 if no return statement
     rt.stash.pushWithoutConversions(
@@ -794,8 +805,10 @@ export const instructionEvaluator: {
     const [fnBody, fnType] = rt.getFunction(Number(fnIdx));
     rt.functionCalls.push(Number(fnIdx));
     rt.agenda.push(markInstruction());
-    if (fnBody.value.length === 1) rt.agenda.push(fnBody.value[0]);
-    else rt.agenda.push(fnBody);
+    const stmts = fnBody.value
+    for (let i = stmts.length - 1; i >= 0; i--) {
+      rt.agenda.push(stmts[i]);
+    }
 
     const frame = RuntimeStack.calculateStackFrame(
       fnType.parameterTypes,
@@ -833,7 +846,11 @@ export const instructionEvaluator: {
     while (!isMarkInstruction(rt.agenda.peek())) rt.agenda.pop();
     rt.agenda.pop();
     const block = rt.symbolTable.exitBlock();
-    Object.values(block).forEach((addr) => rt.effectiveTypeTable.remove(addr));
+    Object.values(block).forEach((addr) => {
+      const t = rt.effectiveTypeTable.get(addr)
+      if (t !== NO_EFFECTIVE_TYPE) rt.initTable.remove(addr, t.size)
+      rt.effectiveTypeTable.remove(addr)
+    });
     rt.stack.pop();
     rt.functionCalls.pop();
   },
@@ -960,6 +977,14 @@ export const instructionEvaluator: {
       );
     }
   },
+  [InstructionType.EXIT_BLOCK]: (rt:Runtime) => {
+    const block = rt.symbolTable.exitBlock();
+    Object.values(block).forEach((addr) => {
+      const t = rt.effectiveTypeTable.get(addr)
+      if (t !== NO_EFFECTIVE_TYPE) rt.initTable.remove(addr, t.size)
+      rt.effectiveTypeTable.remove(addr)
+    });
+  }
 };
 
 const convertValue = (

src/interpreter/initializedTable.ts

@@ -0,0 +1,25 @@
+import { cloneDeep } from "lodash";
+import { ObjectTypeInfo } from "../typing/types";
+
+export class InitializedTable {
+    private table: Record<number, boolean> = {};
+
+    public add(addr: number, t: ObjectTypeInfo): void {
+        for (let i = addr; i < addr + t.size; i++) this.table[i] = true;
+    }
+
+    public check(addr: number, t: ObjectTypeInfo): boolean {
+        for (let i = addr; i < addr + t.size; i++) if (!(i in this.table)) return false;
+        return true;
+    }
+
+    public remove(addr: number, size: number): void {
+        for (let i = addr; i < addr + size; i++) {
+            if (i in this.table) delete this.table[i]
+        }
+    }
+
+    public getTable() {
+        return cloneDeep(this.table)
+    }
+}

src/interpreter/instructions.ts

@@ -17,6 +17,7 @@ export enum InstructionType {
   ARITHMETIC_CONVERSION = "ArithmeticConversion",
   CAST = "Cast",
   ARRAY_SUBSCRIPT = "ArraySubscript",
+  EXIT_BLOCK ="ExitBlock"
 }
 
 export interface BaseInstruction {
@@ -163,6 +164,12 @@ export const arraySubscriptInstruction = (
   evaluateAsLvalue,
 });
 
+export interface ExitBlockInstruction extends BaseInstruction {
+  type: InstructionType.EXIT_BLOCK;
+}
+
+export const exitBlockInstruction = () :ExitBlockInstruction => ({type:InstructionType.EXIT_BLOCK});
+
 export type Instruction =
   | UnaryOpInstruction
   | BinaryOpInstruction
@@ -176,4 +183,5 @@ export type Instruction =
   | AssignInstruction
   | ArithmeticConversionInstruction
   | CastInstruction
-  | ArraySubscriptInstruction;
+  | ArraySubscriptInstruction
+  | ExitBlockInstruction

src/interpreter/object.ts

@@ -76,8 +76,9 @@ export class RuntimeObject
   implements IdentifiableAndAddressable
 {
   public readonly address: number;
-  public readonly identifier: Identifier;
+  public initialized: boolean;
   private readonly memory: Memory;
+  private _identifier: Identifier;
 
   public constructor(
     typeInfo: ObjectTypeInfo,
@@ -95,11 +96,20 @@ export class RuntimeObject
         typeInfo.alignment +
         ")"
       );
-    this.identifier = identifier;
+    this._identifier = identifier;
     this.memory = memory;
+    this.initialized = false;
   }
 
   public get bytes() {
     return this.memory.getObjectBytes(this.address, this.typeInfo);
   }
+
+  public get identifier() {
+    return this._identifier;
+  }
+
+  public setIdentifier(i: Identifier) {
+    this._identifier = i;
+  }
 }

src/interpreter/runtime.ts

@@ -20,6 +20,7 @@ import {
   EffectiveTypeTable,
   EffectiveTypeTableEntry,
 } from "./effectiveTypeTable";
+import { InitializedTable } from "./initializedTable";
 
 export type TextAndDataEntry = FunctionDesignator | RuntimeObject;
 
@@ -43,6 +44,7 @@ export class RuntimeView {
   rbpArr: number[];
   heap: Record<number, HeapEntry>;
   effectiveTypeTable: Record<number, EffectiveTypeTableEntry>;
+  initTable: InitializedTable;
 
   constructor(rt: Runtime) {
     this.agenda = rt.agenda.getArr();
@@ -59,6 +61,7 @@ export class RuntimeView {
     this.rbpArr.push(rt.stack.rbp);
     this.heap = rt.heap.getAllocations();
     this.effectiveTypeTable = rt.effectiveTypeTable.getTable();
+    this.initTable = cloneDeep(rt.initTable)
   }
 }
 
@@ -73,6 +76,7 @@ export class Runtime {
   public readonly stack: RuntimeStack;
   public readonly functionCalls: Stack<number>;
   public readonly heap: Heap;
+  public readonly initTable: InitializedTable;
 
   private functions: [string, TypedCompoundStatement, FunctionType][];
   private builtinFunctions: BuiltinFunction[];
@@ -94,6 +98,7 @@ export class Runtime {
       config.memory.heap.baseAddress,
       config.memory.heap.baseAddress + config.memory.heap.size,
     );
+    this.initTable = new InitializedTable()
 
     this.functions = [];
     this.builtinFunctions = [];

src/interpreter/stack.ts

@@ -1,4 +1,10 @@
-import { Identifier, TypedCompoundStatement } from "../ast/types";
+import {
+  Identifier,
+  TypedCompoundStatement,
+  isTypedCompoundStatement,
+  isTypedDeclaration,
+  isTypedefDeclaration,
+} from "../ast/types";
 import { ObjectTypeInfo, ParameterTypeAndIdentifier } from "../typing/types";
 import { Stack, roundUpM } from "../utils";
 
@@ -54,11 +60,11 @@ export class RuntimeStack extends Stack<StackFrame> {
 
   static calculateStackFrame(
     params: ParameterTypeAndIdentifier[],
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     body: TypedCompoundStatement,
   ): StackFrame {
     const res: StackFrame = {};
     let ptr = 0;
+
     for (const p of params) {
       if (!p.identifier) throw new Error("param missing identifier");
       ptr = roundUpM(ptr, p.type.alignment);
@@ -68,6 +74,33 @@ export class RuntimeStack extends Stack<StackFrame> {
       };
       ptr += p.type.size;
     }
+
+    const identifierPrefix: string[] = [];
+    const scan = (stmts: TypedCompoundStatement): void => {
+      let blockNo = 0;
+      stmts.value.forEach((i) => {
+        if (isTypedDeclaration(i)) {
+          i.declaratorList.forEach((j) => {
+            const typeInfo = j.typeInfo;
+            const qid =
+              identifierPrefix.join("::") +
+              (identifierPrefix.length ? "::" : "") +
+              j.identifier;
+            j.qualifiedIdentifier = qid; 
+            ptr = roundUpM(ptr, typeInfo.alignment);
+            res[qid] = { address: ptr, typeInfo };
+            ptr += typeInfo.size;
+          });
+        } else if (!isTypedefDeclaration(i) && isTypedCompoundStatement(i)) {
+          identifierPrefix.push("block" + blockNo);
+          scan(i);
+          identifierPrefix.pop();
+          blockNo++;
+        }
+      });
+    };
+    scan(body);
+
     return res;
   }