shithub: rgbds

Download patch

ref: 304bb9f902f2a6a5fb39f19d2be8f4698246c435
parent: 14be01880d1df164268952285f54aa2b206f93ba
author: ISSOtm <eldredhabert0@gmail.com>
date: Sun Sep 6 16:43:13 EDT 2020 

Remove most Hungarian notation in section module

Seriously, it sucks.


--- a/include/asm/fstack.h
+++ b/include/asm/fstack.h
@@ -26,7 +26,7 @@
 struct sContext {
 	YY_BUFFER_STATE FlexHandle;
 	struct Symbol const *pMacro;
-	struct sContext *pNext;
+	struct sContext *next;
 	char tzFileName[_MAX_PATH + 1];
 	struct MacroArgs *macroArgs;
 	uint32_t uniqueID;
--- a/include/asm/section.h
+++ b/include/asm/section.h
@@ -17,17 +17,17 @@
 struct Expression;
 
 struct Section {
-	char *pzName;
-	enum SectionType nType;
+	char *name;
+	enum SectionType type;
 	enum SectionModifier modifier;
 	uint32_t size;
-	uint32_t nOrg;
-	uint32_t nBank;
-	uint8_t nAlign;
+	uint32_t org;
+	uint32_t bank;
+	uint8_t align;
 	uint16_t alignOfs;
-	struct Section *pNext;
-	struct Patch *pPatches;
-	uint8_t *tData;
+	struct Section *next;
+	struct Patch *patches;
+	uint8_t *data;
 };
 
 struct SectionSpec {
@@ -36,8 +36,8 @@
 	uint16_t alignOfs;
 };
 
-struct Section *out_FindSectionByName(const char *pzName);
-void out_NewSection(char const *pzName, uint32_t secttype, uint32_t org,
+struct Section *out_FindSectionByName(const char *name);
+void out_NewSection(char const *name, uint32_t secttype, uint32_t org,
 		    struct SectionSpec const *attributes,
 		    enum SectionModifier mod);
 void out_SetLoadSection(char const *name, uint32_t secttype, uint32_t org,
--- a/include/asm/symbol.h
+++ b/include/asm/symbol.h
@@ -71,7 +71,7 @@
 	if (sym->type == SYM_LABEL) {
 		struct Section const *sect = sym_GetSection(sym);
 
-		return sect && sect->nOrg != -1;
+		return sect && sect->org != -1;
 	}
 	return sym->type == SYM_EQU || sym->type == SYM_SET;
 }
--- a/src/asm/fstack.c
+++ b/src/asm/fstack.c
@@ -74,7 +74,7 @@
 
 	ppFileStack = &pFileStack;
 	while (*ppFileStack)
-		ppFileStack = &((*ppFileStack)->pNext);
+		ppFileStack = &((*ppFileStack)->next);
 
 	*ppFileStack = malloc(sizeof(struct sContext));
 
@@ -82,7 +82,7 @@
 		fatalerror("No memory for context");
 
 	(*ppFileStack)->FlexHandle = CurrentFlexHandle;
-	(*ppFileStack)->pNext = NULL;
+	(*ppFileStack)->next = NULL;
 	strcpy((char *)(*ppFileStack)->tzFileName, (char *)tzCurrentFileName);
 	(*ppFileStack)->nLine = nLineNo;
 
@@ -160,8 +160,8 @@
 		return 1;
 
 	ppLastFile = &pFileStack;
-	while (pLastFile->pNext) {
-		ppLastFile = &(pLastFile->pNext);
+	while (pLastFile->next) {
+		ppLastFile = &(pLastFile->next);
 		pLastFile = *ppLastFile;
 	}
 
@@ -243,8 +243,8 @@
 	pLastFile = pFileStack;
 
 	if (pLastFile != NULL) {
-		while (pLastFile->pNext) {
-			ppLastFile = &(pLastFile->pNext);
+		while (pLastFile->next) {
+			ppLastFile = &(pLastFile->next);
 			pLastFile = *ppLastFile;
 		}
 		return pLastFile->nLine;
@@ -274,7 +274,7 @@
 	while (pLastFile) {
 		fprintf(stderr, "%s(%" PRId32 ") -> ", pLastFile->tzFileName,
 			pLastFile->nLine);
-		pLastFile = pLastFile->pNext;
+		pLastFile = pLastFile->next;
 	}
 
 	fprintf(stderr, "%s(%" PRId32 ")", tzCurrentFileName, nLineNo);
@@ -296,7 +296,7 @@
 			len = 0;
 		else
 			len -= retcode;
-		pLastFile = pLastFile->pNext;
+		pLastFile = pLastFile->next;
 	}
 
 	retcode = snprintf(&buf[buflen - len], len, "%s(%" PRId32 ")",
--- a/src/asm/lexer.c
+++ b/src/asm/lexer.c
@@ -32,7 +32,7 @@
 	char *tzName;
 	uint32_t nToken;
 	uint32_t nNameLength;
-	struct sLexString *pNext;
+	struct sLexString *next;
 };
 
 #define pLexBufferRealStart	(pCurrentBuffer->pBufferRealStart)
@@ -492,7 +492,7 @@
 
 		ppHash = &tLexHash[hash];
 		while (*ppHash)
-			ppHash = &((*ppHash)->pNext);
+			ppHash = &((*ppHash)->next);
 
 		*ppHash = malloc(sizeof(struct sLexString));
 		if (*ppHash == NULL)
@@ -504,7 +504,7 @@
 
 		(*ppHash)->nNameLength = strlen(lex->tzName);
 		(*ppHash)->nToken = lex->nToken;
-		(*ppHash)->pNext = NULL;
+		(*ppHash)->next = NULL;
 
 		upperstring((*ppHash)->tzName);
 
@@ -575,7 +575,7 @@
 				pLongestFixed = lex;
 				break;
 			}
-			lex = lex->pNext;
+			lex = lex->next;
 		}
 	}
 
--- a/src/asm/main.c
+++ b/src/asm/main.c
@@ -69,7 +69,7 @@
 
 struct sOptionStackEntry {
 	struct sOptions Options;
-	struct sOptionStackEntry *pNext;
+	struct sOptionStackEntry *next;
 };
 
 struct sOptionStackEntry *pOptionStack;
@@ -196,7 +196,7 @@
 		fatalerror("No memory for option stack");
 
 	pOpt->Options = CurrentOptions;
-	pOpt->pNext = pOptionStack;
+	pOpt->next = pOptionStack;
 	pOptionStack = pOpt;
 }
 
@@ -209,7 +209,7 @@
 
 	pOpt = pOptionStack;
 	opt_SetCurrentOptions(&(pOpt->Options));
-	pOptionStack = pOpt->pNext;
+	pOptionStack = pOpt->next;
 	free(pOpt);
 }
 
--- a/src/asm/output.c
+++ b/src/asm/output.c
@@ -37,10 +37,10 @@
 	uint32_t nOffset;
 	struct Section *pcSection;
 	uint32_t pcOffset;
-	uint8_t nType;
+	uint8_t type;
 	uint32_t nRPNSize;
 	uint8_t *pRPN;
-	struct Patch *pNext;
+	struct Patch *next;
 };
 
 struct Assertion {
@@ -67,13 +67,13 @@
  */
 static uint32_t countsections(void)
 {
-	struct Section *pSect;
+	struct Section *sect;
 	uint32_t count = 0;
 
-	pSect = pSectionList;
-	while (pSect) {
+	sect = pSectionList;
+	while (sect) {
 		count++;
-		pSect = pSect->pNext;
+		sect = sect->next;
 	}
 
 	return count;
@@ -82,12 +82,12 @@
 /*
  * Count the number of patches used in this object
  */
-static uint32_t countpatches(struct Section const *pSect)
+static uint32_t countpatches(struct Section const *sect)
 {
 	uint32_t r = 0;
 
-	for (struct Patch const *patch = pSect->pPatches; patch != NULL;
-	     patch = patch->pNext)
+	for (struct Patch const *patch = sect->patches; patch != NULL;
+	     patch = patch->next)
 		r++;
 
 	return r;
@@ -132,7 +132,7 @@
 /*
  * Return a section's ID
  */
-static uint32_t getsectid(struct Section const *pSect)
+static uint32_t getsectid(struct Section const *sect)
 {
 	struct Section const *sec;
 	uint32_t ID = 0;
@@ -140,13 +140,13 @@
 	sec = pSectionList;
 
 	while (sec) {
-		if (sec == pSect)
+		if (sec == sect)
 			return ID;
 		ID++;
-		sec = sec->pNext;
+		sec = sec->next;
 	}
 
-	fatalerror("Unknown section '%s'", pSect->pzName);
+	fatalerror("Unknown section '%s'", sect->name);
 }
 
 static uint32_t getSectIDIfAny(struct Section const *sect)
@@ -157,42 +157,42 @@
 /*
  * Write a patch to a file
  */
-static void writepatch(struct Patch const *pPatch, FILE *f)
+static void writepatch(struct Patch const *patch, FILE *f)
 {
-	fputstring(pPatch->tzFilename, f);
-	fputlong(pPatch->nOffset, f);
-	fputlong(getSectIDIfAny(pPatch->pcSection), f);
-	fputlong(pPatch->pcOffset, f);
-	fputc(pPatch->nType, f);
-	fputlong(pPatch->nRPNSize, f);
-	fwrite(pPatch->pRPN, 1, pPatch->nRPNSize, f);
+	fputstring(patch->tzFilename, f);
+	fputlong(patch->nOffset, f);
+	fputlong(getSectIDIfAny(patch->pcSection), f);
+	fputlong(patch->pcOffset, f);
+	fputc(patch->type, f);
+	fputlong(patch->nRPNSize, f);
+	fwrite(patch->pRPN, 1, patch->nRPNSize, f);
 }
 
 /*
  * Write a section to a file
  */
-static void writesection(struct Section const *pSect, FILE *f)
+static void writesection(struct Section const *sect, FILE *f)
 {
-	fputstring(pSect->pzName, f);
+	fputstring(sect->name, f);
 
-	fputlong(pSect->size, f);
+	fputlong(sect->size, f);
 
-	bool isUnion = pSect->modifier == SECTION_UNION;
-	bool isFragment = pSect->modifier == SECTION_FRAGMENT;
+	bool isUnion = sect->modifier == SECTION_UNION;
+	bool isFragment = sect->modifier == SECTION_FRAGMENT;
 
-	fputc(pSect->nType | isUnion << 7 | isFragment << 6, f);
+	fputc(sect->type | isUnion << 7 | isFragment << 6, f);
 
-	fputlong(pSect->nOrg, f);
-	fputlong(pSect->nBank, f);
-	fputc(pSect->nAlign, f);
-	fputlong(pSect->alignOfs, f);
+	fputlong(sect->org, f);
+	fputlong(sect->bank, f);
+	fputc(sect->align, f);
+	fputlong(sect->alignOfs, f);
 
-	if (sect_HasData(pSect->nType)) {
-		fwrite(pSect->tData, 1, pSect->size, f);
-		fputlong(countpatches(pSect), f);
+	if (sect_HasData(sect->type)) {
+		fwrite(sect->data, 1, sect->size, f);
+		fputlong(countpatches(sect), f);
 
-		for (struct Patch const *patch = pSect->pPatches; patch != NULL;
-		     patch = patch->pNext)
+		for (struct Patch const *patch = sect->patches; patch != NULL;
+		     patch = patch->next)
 			writepatch(patch, f);
 	}
 }
@@ -307,39 +307,39 @@
 static struct Patch *allocpatch(uint32_t type, struct Expression const *expr,
 				uint32_t ofs)
 {
-	struct Patch *pPatch = malloc(sizeof(struct Patch));
+	struct Patch *patch = malloc(sizeof(struct Patch));
 	uint32_t rpnSize = expr->isKnown ? 5 : expr->nRPNPatchSize;
 
-	if (!pPatch)
+	if (!patch)
 		fatalerror("No memory for patch: %s", strerror(errno));
-	pPatch->pRPN = malloc(sizeof(*pPatch->pRPN) * rpnSize);
+	patch->pRPN = malloc(sizeof(*patch->pRPN) * rpnSize);
 
-	if (!pPatch->pRPN)
+	if (!patch->pRPN)
 		fatalerror("No memory for patch's RPN expression: %s",
 			   strerror(errno));
 
-	pPatch->nType = type;
-	fstk_DumpToStr(pPatch->tzFilename, sizeof(pPatch->tzFilename));
-	pPatch->nOffset = ofs;
-	pPatch->pcSection = sect_GetSymbolSection();
-	pPatch->pcOffset = sect_GetSymbolOffset();
+	patch->type = type;
+	fstk_DumpToStr(patch->tzFilename, sizeof(patch->tzFilename));
+	patch->nOffset = ofs;
+	patch->pcSection = sect_GetSymbolSection();
+	patch->pcOffset = sect_GetSymbolOffset();
 
 	/* If the expression's value is known, output a constant RPN expression directly */
 	if (expr->isKnown) {
-		pPatch->nRPNSize = rpnSize;
+		patch->nRPNSize = rpnSize;
 		/* Make sure to update `rpnSize` above if modifying this! */
-		pPatch->pRPN[0] = RPN_CONST;
-		pPatch->pRPN[1] = (uint32_t)(expr->nVal) & 0xFF;
-		pPatch->pRPN[2] = (uint32_t)(expr->nVal) >> 8;
-		pPatch->pRPN[3] = (uint32_t)(expr->nVal) >> 16;
-		pPatch->pRPN[4] = (uint32_t)(expr->nVal) >> 24;
+		patch->pRPN[0] = RPN_CONST;
+		patch->pRPN[1] = (uint32_t)(expr->nVal) & 0xFF;
+		patch->pRPN[2] = (uint32_t)(expr->nVal) >> 8;
+		patch->pRPN[3] = (uint32_t)(expr->nVal) >> 16;
+		patch->pRPN[4] = (uint32_t)(expr->nVal) >> 24;
 	} else {
-		pPatch->nRPNSize = 0;
-		writerpn(pPatch->pRPN, &pPatch->nRPNSize, expr->tRPN, expr->nRPNLength);
+		patch->nRPNSize = 0;
+		writerpn(patch->pRPN, &patch->nRPNSize, expr->tRPN, expr->nRPNLength);
 	}
-	assert(pPatch->nRPNSize == rpnSize);
+	assert(patch->nRPNSize == rpnSize);
 
-	return pPatch;
+	return patch;
 }
 
 /*
@@ -347,10 +347,10 @@
  */
 void out_CreatePatch(uint32_t type, struct Expression const *expr, uint32_t ofs)
 {
-	struct Patch *pPatch = allocpatch(type, expr, ofs);
+	struct Patch *patch = allocpatch(type, expr, ofs);
 
-	pPatch->pNext = pCurrentSection->pPatches;
-	pCurrentSection->pPatches = pPatch;
+	patch->next = pCurrentSection->patches;
+	pCurrentSection->patches = patch;
 }
 
 /**
@@ -415,7 +415,7 @@
 	for (struct Symbol const *sym = objectSymbols; sym; sym = sym->next)
 		writesymbol(sym, f);
 
-	for (struct Section *sect = pSectionList; sect; sect = sect->pNext)
+	for (struct Section *sect = pSectionList; sect; sect = sect->next)
 		writesection(sect, f);
 
 	fputlong(countasserts(), f);
--- a/src/asm/rpn.c
+++ b/src/asm/rpn.c
@@ -147,12 +147,12 @@
 	if (!pCurrentSection) {
 		yyerror("PC has no bank outside a section");
 		expr->nVal = 1;
-	} else if (pCurrentSection->nBank == -1) {
+	} else if (pCurrentSection->bank == -1) {
 		makeUnknown(expr, "Current section's bank is not known");
 		expr->nRPNPatchSize++;
 		*reserveSpace(expr, 1) = RPN_BANK_SELF;
 	} else {
-		expr->nVal = pCurrentSection->nBank;
+		expr->nVal = pCurrentSection->bank;
 	}
 }
 
@@ -175,9 +175,9 @@
 			/* If the symbol didn't exist, `sym_Ref` created it */
 			sym = sym_FindSymbol(tzSym);
 
-		if (sym_GetSection(sym) && sym_GetSection(sym)->nBank != -1) {
+		if (sym_GetSection(sym) && sym_GetSection(sym)->bank != -1) {
 			/* Symbol's section is known and bank is fixed */
-			expr->nVal = sym_GetSection(sym)->nBank;
+			expr->nVal = sym_GetSection(sym)->bank;
 		} else {
 			makeUnknown(expr, "\"%s\"'s bank is not known", tzSym);
 			expr->nRPNPatchSize += 5; /* opcode + 4-byte sect ID */
@@ -196,8 +196,8 @@
 
 	struct Section *pSection = out_FindSectionByName(tzSectionName);
 
-	if (pSection && pSection->nBank != -1) {
-		expr->nVal = pSection->nBank;
+	if (pSection && pSection->bank != -1) {
+		expr->nVal = pSection->bank;
 	} else {
 		makeUnknown(expr, "Section \"%s\"'s bank is not known",
 			    tzSectionName);
--- a/src/asm/section.c
+++ b/src/asm/section.c
@@ -20,7 +20,7 @@
 	struct Section *pSection;
 	struct Symbol *pScope; /* Section's symbol scope */
 	uint32_t offset;
-	struct SectionStackEntry *pNext;
+	struct SectionStackEntry *next;
 };
 
 struct SectionStackEntry *pSectionStack;
@@ -51,18 +51,18 @@
 {
 	checksection();
 
-	if (!sect_HasData(pCurrentSection->nType))
+	if (!sect_HasData(pCurrentSection->type))
 		fatalerror("Section '%s' cannot contain code or data (not ROM0 or ROMX)",
-			   pCurrentSection->pzName);
+			   pCurrentSection->name);
 }
 
 static inline void checkSectionSize(struct Section const *sect, uint32_t size)
 {
-	uint32_t maxSize = maxsize[sect->nType];
+	uint32_t maxSize = maxsize[sect->type];
 
 	if (size > maxSize)
 		fatalerror("Section '%s' grew too big (max size = 0x%" PRIX32 " bytes, reached 0x%" PRIX32 ").",
-			   sect->pzName, maxSize, size);
+			   sect->name, maxSize, size);
 }
 
 /*
@@ -81,15 +81,15 @@
 		checkSectionSize(currentLoadSection, curOffset + delta_size);
 }
 
-struct Section *out_FindSectionByName(const char *pzName)
+struct Section *out_FindSectionByName(const char *name)
 {
-	struct Section *pSect = pSectionList;
+	struct Section *sect = pSectionList;
 
-	while (pSect) {
-		if (strcmp(pzName, pSect->pzName) == 0)
-			return pSect;
+	while (sect) {
+		if (strcmp(name, sect->name) == 0)
+			return sect;
 
-		pSect = pSect->pNext;
+		sect = sect->next;
 	}
 
 	return NULL;
@@ -98,7 +98,7 @@
 /*
  * Find a section by name and type. If it doesn't exist, create it
  */
-static struct Section *getSection(char const *pzName, enum SectionType type,
+static struct Section *getSection(char const *name, enum SectionType type,
 				  uint32_t org, struct SectionSpec const *attrs,
 				  enum SectionModifier mod)
 {
@@ -131,11 +131,11 @@
 		if (org != -1) {
 			if ((org - alignOffset) & mask)
 				yyerror("Section \"%s\"'s fixed address doesn't match its alignment",
-					pzName);
+					name);
 			alignment = 0; /* Ignore it if it's satisfied */
 		} else if (startaddr[type] & mask) {
 			yyerror("Section \"%s\"'s alignment cannot be attained in %s",
-				pzName, typeNames[type]);
+				name, typeNames[type]);
 		}
 	}
 
@@ -142,15 +142,15 @@
 	if (org != -1) {
 		if (org < startaddr[type] || org > endaddr(type))
 			yyerror("Section \"%s\"'s fixed address %#" PRIx32 " is outside of range [%#" PRIx16 "; %#" PRIx16 "]",
-				pzName, org, startaddr[type], endaddr(type));
+				name, org, startaddr[type], endaddr(type));
 	}
 
 	if (nbbanks(type) == 1)
 		bank = bankranges[type][0];
 
-	struct Section *pSect = out_FindSectionByName(pzName);
+	struct Section *sect = out_FindSectionByName(name);
 
-	if (pSect) {
+	if (sect) {
 		unsigned int nbSectErrors = 0;
 #define fail(...) \
 	do { \
@@ -158,13 +158,13 @@
 		nbSectErrors++; \
 	} while (0)
 
-		if (type != pSect->nType)
+		if (type != sect->type)
 			fail("Section \"%s\" already exists but with type %s",
-			     pSect->pzName, typeNames[pSect->nType]);
+			     sect->name, typeNames[sect->type]);
 
-		if (pSect->modifier != mod)
+		if (sect->modifier != mod)
 			fail("Section \"%s\" already declared as %s section",
-			     pSect->pzName, sectionModNames[pSect->modifier]);
+			     sect->name, sectionModNames[sect->modifier]);
 		/*
 		 * Normal sections need to have exactly identical constraints;
 		 * but unionized sections only need "compatible" constraints,
@@ -179,105 +179,105 @@
 				fail("Cannot declare ROM sections as UNION");
 			if (org != -1) {
 				/* If both are fixed, they must be the same */
-				if (pSect->nOrg != -1 && pSect->nOrg != org)
+				if (sect->org != -1 && sect->org != org)
 					fail("Section \"%s\" already declared as fixed at different address $%" PRIx32,
-					     pSect->pzName, pSect->nOrg);
-				else if (pSect->nAlign != 0
-				      && (mask(pSect->nAlign)
-						& (org - pSect->alignOfs)))
+					     sect->name, sect->org);
+				else if (sect->align != 0
+				      && (mask(sect->align)
+						& (org - sect->alignOfs)))
 					fail("Section \"%s\" already declared as aligned to %u bytes (offset %" PRIu16 ")",
-					     pSect->pzName, 1U << pSect->nAlign,
-					     pSect->alignOfs);
+					     sect->name, 1U << sect->align,
+					     sect->alignOfs);
 				else
 					/* Otherwise, just override */
-					pSect->nOrg = org;
+					sect->org = org;
 			} else if (alignment != 0) {
 				/* Make sure any fixed address is compatible */
-				if (pSect->nOrg != -1) {
-					if ((pSect->nOrg - alignOffset)
+				if (sect->org != -1) {
+					if ((sect->org - alignOffset)
 							& mask(alignment))
 						fail("Section \"%s\" already declared as fixed at incompatible address $%" PRIx32,
-						     pSect->pzName,
-						     pSect->nOrg);
+						     sect->name,
+						     sect->org);
 				/* Check if alignment offsets are compatible */
-				} else if ((alignOffset & mask(pSect->nAlign))
-					!= (pSect->alignOfs
+				} else if ((alignOffset & mask(sect->align))
+					!= (sect->alignOfs
 							& mask(alignment))) {
 					fail("Section \"%s\" already declared with incompatible %" PRIu8 "-byte alignment (offset %" PRIu16 ")",
-					     pSect->pzName, pSect->nAlign,
-					     pSect->alignOfs);
-				} else if (alignment > pSect->nAlign) {
+					     sect->name, sect->align,
+					     sect->alignOfs);
+				} else if (alignment > sect->align) {
 					/*
 					 * If the section is not fixed,
 					 * its alignment is the largest of both
 					 */
-					pSect->nAlign = alignment;
-					pSect->alignOfs = alignOffset;
+					sect->align = alignment;
+					sect->alignOfs = alignOffset;
 				}
 			}
 			/* If the section's bank is unspecified, override it */
-			if (pSect->nBank == -1)
-				pSect->nBank = bank;
+			if (sect->bank == -1)
+				sect->bank = bank;
 			/* If both specify a bank, it must be the same one */
-			else if (bank != -1 && pSect->nBank != bank)
+			else if (bank != -1 && sect->bank != bank)
 				fail("Section \"%s\" already declared with different bank %" PRIu32,
-				     pSect->pzName, pSect->nBank);
+				     sect->name, sect->bank);
 		} else { /* Section fragments are handled identically in RGBASM */
 			/* However, concaternating non-fragments will be made an error */
-			if (pSect->modifier != SECTION_FRAGMENT || mod != SECTION_FRAGMENT)
+			if (sect->modifier != SECTION_FRAGMENT || mod != SECTION_FRAGMENT)
 				warning(WARNING_OBSOLETE, "Concatenation of non-fragment sections is deprecated");
 
-			if (org != pSect->nOrg) {
-				if (pSect->nOrg == -1)
+			if (org != sect->org) {
+				if (sect->org == -1)
 					fail("Section \"%s\" already declared as floating",
-					     pSect->pzName);
+					     sect->name);
 				else
 					fail("Section \"%s\" already declared as fixed at $%" PRIx32,
-					     pSect->pzName, pSect->nOrg);
+					     sect->name, sect->org);
 			}
-			if (bank != pSect->nBank) {
-				if (pSect->nBank == -1)
+			if (bank != sect->bank) {
+				if (sect->bank == -1)
 					fail("Section \"%s\" already declared as floating bank",
-					     pSect->pzName);
+					     sect->name);
 				else
 					fail("Section \"%s\" already declared as fixed at bank %" PRIu32,
-					     pSect->pzName, pSect->nBank);
+					     sect->name, sect->bank);
 			}
-			if (alignment != pSect->nAlign) {
-				if (pSect->nAlign == 0)
+			if (alignment != sect->align) {
+				if (sect->align == 0)
 					fail("Section \"%s\" already declared as unaligned",
-					     pSect->pzName);
+					     sect->name);
 				else
 					fail("Section \"%s\" already declared as aligned to %u bytes",
-					     pSect->pzName,
-					     1U << pSect->nAlign);
+					     sect->name,
+					     1U << sect->align);
 			}
 		}
 
 		if (nbSectErrors)
 			fatalerror("Cannot create section \"%s\" (%u errors)",
-				   pSect->pzName, nbSectErrors);
+				   sect->name, nbSectErrors);
 #undef fail
-		return pSect;
+		return sect;
 	}
 
-	pSect = malloc(sizeof(*pSect));
-	if (pSect == NULL)
+	sect = malloc(sizeof(*sect));
+	if (sect == NULL)
 		fatalerror("Not enough memory for section");
 
-	pSect->pzName = strdup(pzName);
-	if (pSect->pzName == NULL)
+	sect->name = strdup(name);
+	if (sect->name == NULL)
 		fatalerror("Not enough memory for sectionname");
 
-	pSect->nType = type;
-	pSect->modifier = mod;
-	pSect->size = 0;
-	pSect->nOrg = org;
-	pSect->nBank = bank;
-	pSect->nAlign = alignment;
-	pSect->alignOfs = alignOffset;
-	pSect->pNext = pSectionList;
-	pSect->pPatches = NULL;
+	sect->type = type;
+	sect->modifier = mod;
+	sect->size = 0;
+	sect->org = org;
+	sect->bank = bank;
+	sect->align = alignment;
+	sect->alignOfs = alignOffset;
+	sect->next = pSectionList;
+	sect->patches = NULL;
 
 	/* It is only needed to allocate memory for ROM sections. */
 	if (sect_HasData(type)) {
@@ -284,11 +284,11 @@
 		uint32_t sectsize;
 
 		sectsize = maxsize[type];
-		pSect->tData = malloc(sectsize);
-		if (pSect->tData == NULL)
+		sect->data = malloc(sectsize);
+		if (sect->data == NULL)
 			fatalerror("Not enough memory for section");
 	} else {
-		pSect->tData = NULL;
+		sect->data = NULL;
 	}
 
 	/*
@@ -295,9 +295,9 @@
 	 * Add the new section to the list
 	 * at the beginning because order doesn't matter
 	 */
-	pSectionList = pSect;
+	pSectionList = sect;
 
-	return pSect;
+	return sect;
 #undef mask
 }
 
@@ -315,17 +315,17 @@
 /*
  * Set the current section by name and type
  */
-void out_NewSection(char const *pzName, uint32_t type, uint32_t org,
+void out_NewSection(char const *name, uint32_t type, uint32_t org,
 		    struct SectionSpec const *attribs, enum SectionModifier mod)
 {
 	if (currentLoadSection)
 		fatalerror("Cannot change the section within a `LOAD` block");
 
-	struct Section *pSect = getSection(pzName, type, org, attribs, mod);
+	struct Section *sect = getSection(name, type, org, attribs, mod);
 
 	changeSection();
-	curOffset = mod == SECTION_UNION ? 0 : pSect->size;
-	pCurrentSection = pSect;
+	curOffset = mod == SECTION_UNION ? 0 : sect->size;
+	pCurrentSection = sect;
 }
 
 /*
@@ -339,12 +339,12 @@
 	if (currentLoadSection)
 		fatalerror("`LOAD` blocks cannot be nested");
 
-	struct Section *pSect = getSection(name, type, org, attribs, false);
+	struct Section *sect = getSection(name, type, org, attribs, false);
 
 	loadOffset = curOffset;
 	curOffset = 0; /* curOffset -= loadOffset; */
 	changeSection();
-	currentLoadSection = pSect;
+	currentLoadSection = sect;
 }
 
 void out_EndLoadSection(void)
@@ -380,22 +380,22 @@
 {
 	struct Section *sect = sect_GetSymbolSection();
 
-	if (sect->nOrg != -1) {
+	if (sect->org != -1) {
 		if ((sym_GetPCValue() - offset) % (1 << alignment))
 			yyerror("Section's fixed address fails required alignment (PC = $%04" PRIx32 ")",
 				sym_GetPCValue());
-	} else if (sect->nAlign != 0) {
-		if ((((sect->alignOfs + curOffset) % (1 << sect->nAlign))
+	} else if (sect->align != 0) {
+		if ((((sect->alignOfs + curOffset) % (1 << sect->align))
 						- offset) % (1 << alignment)) {
 			yyerror("Section's alignment fails required alignment (offset from section start = $%04" PRIx32 ")",
 				curOffset);
-		} else if (alignment > sect->nAlign) {
-			sect->nAlign = alignment;
+		} else if (alignment > sect->align) {
+			sect->align = alignment;
 			sect->alignOfs =
 					(offset - curOffset) % (1 << alignment);
 		}
 	} else {
-		sect->nAlign = alignment;
+		sect->align = alignment;
 		sect->alignOfs = offset;
 	}
 }
@@ -411,7 +411,7 @@
 
 static inline void writebyte(uint8_t byte)
 {
-	pCurrentSection->tData[sect_GetOutputOffset()] = byte;
+	pCurrentSection->data[sect_GetOutputOffset()] = byte;
 	growSection(1);
 }
 
@@ -439,7 +439,7 @@
 {
 	if (!pCurrentSection)
 		fatalerror("UNIONs must be inside a SECTION");
-	if (sect_HasData(pCurrentSection->nType))
+	if (sect_HasData(pCurrentSection->type))
 		fatalerror("Cannot use UNION inside of ROM0 or ROMX sections");
 	struct UnionStackEntry *entry = malloc(sizeof(*entry));
 
@@ -513,10 +513,10 @@
 	checksection();
 	reserveSpace(skip);
 
-	if (!ds && sect_HasData(pCurrentSection->nType))
+	if (!ds && sect_HasData(pCurrentSection->type))
 		warning(WARNING_EMPTY_DATA_DIRECTIVE, "db/dw/dl directive without data in ROM");
 
-	if (!sect_HasData(pCurrentSection->nType)) {
+	if (!sect_HasData(pCurrentSection->type)) {
 		growSection(skip);
 	} else {
 		checkcodesection();
@@ -781,17 +781,17 @@
  */
 void out_PushSection(void)
 {
-	struct SectionStackEntry *pSect;
+	struct SectionStackEntry *sect;
 
-	pSect = malloc(sizeof(struct SectionStackEntry));
-	if (pSect == NULL)
+	sect = malloc(sizeof(struct SectionStackEntry));
+	if (sect == NULL)
 		fatalerror("No memory for section stack");
 
-	pSect->pSection = pCurrentSection;
-	pSect->pScope = sym_GetCurrentSymbolScope();
-	pSect->offset = curOffset;
-	pSect->pNext = pSectionStack;
-	pSectionStack = pSect;
+	sect->pSection = pCurrentSection;
+	sect->pScope = sym_GetCurrentSymbolScope();
+	sect->offset = curOffset;
+	sect->next = pSectionStack;
+	pSectionStack = sect;
 	/* TODO: maybe set current section to NULL? */
 }
 
@@ -803,14 +803,14 @@
 	if (currentLoadSection)
 		fatalerror("Cannot change the section within a `LOAD` block!");
 
-	struct SectionStackEntry *pSect;
+	struct SectionStackEntry *sect;
 
-	pSect = pSectionStack;
+	sect = pSectionStack;
 	changeSection();
-	pCurrentSection = pSect->pSection;
-	sym_SetCurrentSymbolScope(pSect->pScope);
-	curOffset = pSect->offset;
+	pCurrentSection = sect->pSection;
+	sym_SetCurrentSymbolScope(sect->pScope);
+	curOffset = sect->offset;
 
-	pSectionStack = pSect->pNext;
-	free(pSect);
+	pSectionStack = sect->next;
+	free(sect);
 }
--- a/src/asm/symbol.c
+++ b/src/asm/symbol.c
@@ -89,7 +89,7 @@
 {
 	struct Section const *section = sect_GetSymbolSection();
 
-	return section ? section->nOrg + sect_GetSymbolOffset() : 0;
+	return section ? section->org + sect_GetSymbolOffset() : 0;
 }
 
 /*
@@ -102,7 +102,7 @@
 
 	if (sym->type == SYM_LABEL)
 		/* TODO: do not use section's org directly */
-		return sym->value + sym_GetSection(sym)->nOrg;
+		return sym->value + sym_GetSection(sym)->org;
 
 	return sym->value;
 }
@@ -222,7 +222,7 @@
 
 	if (!sect)
 		yyerror("PC has no value outside a section");
-	else if (sect->nOrg == -1)
+	else if (sect->org == -1)
 		yyerror("Expected constant PC but section is not fixed");
 	else
 		return CallbackPC();