yenru0/2025-02-Compiler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some changes to cminus for symtab

Browse Source
This commit is contained in:
yenru0
2025-12-01 03:35:09 +09:00
parent a9855535cb
commit 1204abb4f9
3 changed files with 173 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
src/symtab.c
View File

@@ -8,74 +8,57 @@
/* Kenneth C. Louden */
/****************************************************/
#include "symtab.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "symtab.h"
/* SIZE is the size of the hash table */
#define SIZE 211
/* SHIFT is the power of two used as multiplier
in hash function */
#define SHIFT 4
/* the hash function */
static int hash ( char * key )
{ int temp = 0;
static int hash(char *key) {
int temp = 0;
int i = 0;
while (key[i] != '\0')
{ temp = ((temp << SHIFT) + key[i]) % SIZE;
while (key[i] != '\0') {
temp = ((temp << SHIFT) + key[i]) % SYMTAB_SIZE;
++i;
}
return temp;
}
/* the list of line numbers of the source
* code in which a variable is referenced
*/
typedef struct LineListRec
{ int lineno;
struct LineListRec * next;
} * LineList;
/* The record in the bucket lists for
* each variable, including name,
* assigned memory location, and
* the list of line numbers in which
* it appears in the source code
*/
typedef struct BucketListRec
{ char * name;
LineList lines;
int memloc ; /* memory location for variable */
struct BucketListRec * next;
} * BucketList;
/* the hash table */
static BucketList hashTable[SIZE];
Scope curr_scope(void) {
if (top_stack == -1) {
return NULL;
} else {
return scope_stack[top_stack];
}
}
/* Procedure st_insert inserts line numbers and
* memory locations into the symbol table
* loc = memory location is inserted only the
* first time, otherwise ignored
*/
void st_insert( char * name, int lineno, int loc )
{ int h = hash(name);
void st_insert(char *name, int lineno, int loc) {
int h = hash(name);
BucketList l = hashTable[h];
while ((l != NULL) && (strcmp(name,l->name) != 0))
while ((l != NULL) && (strcmp(name, l->name) != 0))
l = l->next;
if (l == NULL) /* variable not yet in table */
{ l = (BucketList) malloc(sizeof(struct BucketListRec));
{
l = (BucketList) malloc(sizeof(struct BucketListRec));
l->name = name;
l->lines = (LineList) malloc(sizeof(struct LineListRec));
l->lines->lineno = lineno;
l->memloc = loc;
l->lines->next = NULL;
l->next = hashTable[h];
hashTable[h] = l; }
else /* found in table, so just add line number */
{ LineList t = l->lines;
hashTable[h] = l;
} else /* found in table, so just add line number */
{
LineList t = l->lines;
while (t->next != NULL) t = t->next;
t->next = (LineList) malloc(sizeof(struct LineListRec));
t->next->lineno = lineno;
@@ -86,35 +69,36 @@ void st_insert( char * name, int lineno, int loc )
/* Function st_lookup returns the memory
* location of a variable or -1 if not found
*/
int st_lookup ( char * name )
{ int h = hash(name);
int st_lookup(char *name) {
int h = hash(name);
BucketList l = hashTable[h];
while ((l != NULL) && (strcmp(name,l->name) != 0))
while ((l != NULL) && (strcmp(name, l->name) != 0))
l = l->next;
if (l == NULL) return -1;
else return l->memloc;
else
return l->memloc;
}
/* Procedure printSymTab prints a formatted
* listing of the symbol table contents
* to the listing file
*/
void printSymTab(FILE * listing)
{ int i;
fprintf(listing,"Variable Name Location Line Numbers\n");
fprintf(listing,"------------- -------- ------------\n");
for (i=0;i<SIZE;++i)
{ if (hashTable[i] != NULL)
{ BucketList l = hashTable[i];
while (l != NULL)
{ LineList t = l->lines;
fprintf(listing,"%-14s ",l->name);
fprintf(listing,"%-8d ",l->memloc);
while (t != NULL)
{ fprintf(listing,"%4d ",t->lineno);
void printSymTab(FILE *listing) {
int i;
fprintf(listing, "Variable Name Location Line Numbers\n");
fprintf(listing, "------------- -------- ------------\n");
for (i = 0; i < SYMTAB_SIZE; ++i) {
if (hashTable[i] != NULL) {
BucketList l = hashTable[i];
while (l != NULL) {
LineList t = l->lines;
fprintf(listing, "%-14s ", l->name);
fprintf(listing, "%-8d ", l->memloc);
while (t != NULL) {
fprintf(listing, "%4d ", t->lineno);
t = t->next;
}
fprintf(listing,"\n");
fprintf(listing, "\n");
l = l->next;
}
}

122
src/symtab.h
View File

@@ -1,9 +1,7 @@
/****************************************************/
/* File: symtab.h */
/* Symbol table interface for the TINY compiler */
/* (allows only one symbol table) */
/* Compiler Construction: Principles and Practice */
/* Kenneth C. Louden */
/* Symbol table interface for the CMINUS COMPILER */
/* Modified by Yenru0 */
/****************************************************/
#ifndef _SYMTAB_H_
@@ -11,22 +9,116 @@
#include "globals.h"
/* Procedure st_insert inserts line numbers and
* memory locations into the symbol table
* loc = memory location is inserted only the
* first time, otherwise ignored
*/
void st_insert( char * name, int lineno, int loc );
/* SYMTAB_SIZE is the size of the hash table */
#define SYMTAB_SIZE 211
/* Function st_lookup returns the memory
* location of a variable or -1 if not found
/* the list of line numbers of the source
* code in which a variable is referenced
*/
int st_lookup ( char * name );
typedef struct LineListRec {
int lineno;
struct LineListRec *next;
} *LineList;
/* Procedure printSymTab prints a formatted
/* The record in the bucket lists for
* each variable, including name,
* assigned memory location, and
* the list of line numbers in which
* it appears in the source code
*/
typedef struct BucketListRec {
char *name;
TreeNode *treeNode;
LineList lines;
ExpType type;
int memloc; /* memory location for variable */
struct BucketListRec *next;
} *BucketList;
typedef struct ScopeListRec {
char *name;
int depth;
struct ScopeListRec *parent;
BucketList hashTable[SYMTAB_SIZE];
} *Scope;
Scope scope_global;
static Scope scope_list[SYMTAB_SIZE];
static int size_list = 0;
static Scope scope_stack[SYMTAB_SIZE];
static int top_stack = -1;
/**
* create a new scope with given name
* @param scope_name: name of the scope
* @return the created scope
*/
Scope scope_new(char *scope_name);
/**
* pop the current scope from the scope stack
*/
void pop_scope(void);
/**
* push a scope into the scope stack
* @param scope: the scope to be pushed
*/
void push_scope(Scope scope);
/**
* insert a scope into the scope list
*/
void insert_scope_to_list(Scope scope);
/**
* get the top of the scope stack
* @return the current scope or NULL if the stack is empty
*/
Scope curr_scope(void);
/**
* insert a variable into the symbol table
* or update a variable if it already exists
* @param scope_name name of the scope
* @param name name of the variable
* @param type type of the variable
* @param treeNode syntax tree node
* @param lineno line number of the variable
* @param loc memory location of the variable
* @return 0 if success, -1 if failure
*/
int st_try_insert(
char *scope_name,
char *name,
ExpType type,
TreeNode *treeNode,
int loc);
/**
* lookup a variable in the current scope
* @param name name of the variable to lookup
* @return the bucket list entry of the variable or NULL if not found
*/
BucketList st_lookup_current(char *name);
/**
* lookup a variable from the given scope
* @param name name of the variable to lookup
* @return the bucket list entry of the variable or NULL if not found
*/
BucketList st_lookup(char *name);
/**
* find a scope from the scope list
* @param scope_name name of the scope to find
* @return the scope or NULL if not found
*/
Scope find_scope(char *scope_name);
/**
* Procedure printSymTab prints a formatted
* listing of the symbol table contents
* to the listing file
*/
void printSymTab(FILE * listing);
void printSymTab(FILE *listing);
#endif