From 9155a3b19d01150caf361780099c8e73c4bdf662 Mon Sep 17 00:00:00 2001
From: Etienne Brateau <etienne.brateau@ensiie.fr>
Date: Tue, 8 Jan 2019 14:30:57 +0100
Subject: [PATCH] Rename variables to make it more lisible and make some
 cleaning.

---
 log/include/gate.h |  36 ++---
 log/src/gate.c     | 386 ++++++++++++++++++++++-----------------------
 2 files changed, 208 insertions(+), 214 deletions(-)

diff --git a/log/include/gate.h b/log/include/gate.h
index 1840c45..7702285 100644
--- a/log/include/gate.h
+++ b/log/include/gate.h
@@ -24,34 +24,34 @@ void uaddgate(short x, short y, short gtype);
 
 void addgate1(short x, short y, short gtype);
 
-void pconnectgate(log_grec *g, int *success);
+void pconnectgate(log_grec *gate, int *success);
 
-void delgate(log_grec *g);
+void delgate(log_grec *gate);
 
-void disconnectgate(log_grec *g);
+void disconnectgate(log_grec *gate);
 
 void closergate(short x, short y);
 
-void disposegate(log_grec **g);
+void disposegate(log_grec **gate);
 
-void copygate(log_grec *old, log_grec **g);
+void copygate(log_grec *old, log_grec **gate);
 
-void newgate(log_grec **g, short gt);
+void newgate(log_grec **gate, short gt);
 
-void eragate(log_grec *g);
+void eragate(log_grec *gate);
 
 int addgate(short gtype, short sig, log_gattrrec *attrs);
-int insidegate(log_grec *g, short x, short y);
-int connectgate(log_grec *g);
-void linkgate(log_grec **g);
-void newgptr(log_grec **g);
-void newgate2(log_grec **g, short gt, short sig, log_gattrrec *attrs);
-void unlkgate(log_grec **g);
-void disposegptr(log_grec **g);
-void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n);
-void chggatepin(log_grec *g, short i, log_nrec **oldnode, log_nrec **savenode);
-void frygate(log_grec *g);
-void initpinpos(log_grec *g);
+int insidegate(log_grec *gate, short x, short y);
+int connectgate(log_grec *gate);
+void linkgate(log_grec **gate);
+void newgptr(log_grec **gate);
+void newgate2(log_grec **gate, short gt, short sig, log_gattrrec *attrs);
+void unlkgate(log_grec **gate);
+void disposegptr(log_grec **gate);
+void chggate(log_grec *gate, int i, log_nrec *oldnode, log_nrec *n);
+void chggatepin(log_grec *gate, short i, log_nrec **oldnode, log_nrec **savenode);
+void frygate(log_grec *gate);
+void initpinpos(log_grec *gate);
 void addgate2(short x, short y, short gtype, short sig, log_gattrrec *attrs);
 void movexorgate(short x, short y, short g, short sig, short yy);
 
diff --git a/log/src/gate.c b/log/src/gate.c
index 44a8402..5fa490c 100644
--- a/log/src/gate.c
+++ b/log/src/gate.c
@@ -1,7 +1,6 @@
 
 #include <p2c/p2c.h>
 #include <p2c/newci.h>
-#include <p2c/newkbd.h>
 #include "logfont.h"
 #include "logglobals.h"
 #include "logstructs.h"
@@ -25,25 +24,25 @@
 
 static log_grec *freegate = NULL;
 
-int insidegate(log_grec *g, short x, short y)
+int insidegate(log_grec *gate, short x, short y)
 {
 	short xx1, xx2, yy1, yy2, z;
 	short loc_x1, loc_x2;
 	log_krec *WITH;
 
-	x = (x - g->x) * log_scale0;
-	y = (y - g->y) * log_scale0;
-	WITH = g->kind;
+	x = (x - gate->x) * log_scale0;
+	y = (y - gate->y) * log_scale0;
+	WITH = gate->kind;
 	loc_x1 = WITH->x1;
 	loc_x2 = WITH->x2;
 
 	/* Modify x1 position for length of text on TO/FROM-type gates */
 
-	if (WITH->flag.U3.named && g->sig > 0)
+	if (WITH->flag.U3.named && gate->sig > 0)
 	{
 		char STR1[256];
 		short xwid = m_strwidth(NULL, strrtrim(strcpy(STR1,
-						gg.signaltab[g->sig - 1].name))) - NAMEGAP;
+						gg.signaltab[gate->sig - 1].name))) - NAMEGAP;
 
 		if (WITH->flag.U3.nright)
 		{
@@ -55,13 +54,13 @@ int insidegate(log_grec *g, short x, short y)
 		}
 	}
 
-	if (g->rot == 0)
+	if (gate->rot == 0)
 	{
 		return (loc_x1 <= x && x <= loc_x2 && WITH->y1 <= y && y <= WITH->y2);
 	}
 	else
 	{
-		z = g->rot;
+		z = gate->rot;
 		xx1 = loc_x1 * log_rotxx[z] + WITH->y1 * log_rotyx[z];
 		xx2 = loc_x2 * log_rotxx[z] + WITH->y2 * log_rotyx[z];
 		sortshints(&xx1, &xx2);
@@ -72,8 +71,6 @@ int insidegate(log_grec *g, short x, short y)
 	}
 }
 
-#define rtn             "ERAGATE"
-
 /*==================  ERAGATE  ===================*/
 /*=                                              =*/
 /*=  Erase a gate (including LED's and other     =*/
@@ -81,54 +78,56 @@ int insidegate(log_grec *g, short x, short y)
 /*=                                              =*/
 /*================================================*/
 
-void eragate(log_grec *g)
+void eragate(log_grec *gate)
 {
 	log_grec *g1, *g2;
 
-	if (g->conflict || g->oconflict)
+	if (gate->conflict || gate->oconflict)
 	{
 		g1 = gateconflictbase;
 		g2 = NULL;
-		while (g1 != NULL && g1 != g)
+		while (g1 != NULL && g1 != gate)
 		{
 			g2 = g1;
 			g1 = g1->confnext;
 		}
 
 		if (g1 == NULL)
-			report(10, rtn);
+			report(10, "ERAGATE");
 		else if (g2 == NULL)
-			gateconflictbase = g->confnext;
+			gateconflictbase = gate->confnext;
 		else
-			g2->confnext = g->confnext;
-		g->conflict = false;
-		g->conflict1 = false;
-		g->conflict2 = false;
-		g->oconflict = false;
-	}
-	drawgatec(g->x, g->y, g->g, gg.color.backgr);
-	gsignallabel(g->x, g->y, g, gg.color.backgr);
-	if (g->kind->numpnums > 0)
-		drawpnums(g, gg.color.backgr);
-	drawgatedotsc(g->x, g->y, g->g, gg.color.backgr);
-	calltoolgate(g, act_erasegate);
+			g2->confnext = gate->confnext;
+
+		gate->conflict = false;
+		gate->conflict1 = false;
+		gate->conflict2 = false;
+		gate->oconflict = false;
+	}
+	
+	drawgatec(gate->x, gate->y, gate->g, gg.color.backgr);
+	gsignallabel(gate->x, gate->y, gate, gg.color.backgr);
+	
+	if (gate->kind->numpnums > 0)
+		drawpnums(gate, gg.color.backgr);
+
+	drawgatedotsc(gate->x, gate->y, gate->g, gg.color.backgr);
+	calltoolgate(gate, act_erasegate);
 }
 
-#undef rtn
-
 /*==================  LINKGATE  ==================*/
 /*=                                              =*/
 /*=  Add a gate to the gate list.                =*/
 /*=                                              =*/
 /*================================================*/
 
-void linkgate(log_grec **g)
+void linkgate(log_grec **gate)
 {
-	(*g)->next = gg.gbase[gg.curpage - 1];
-	gg.gbase[gg.curpage - 1] = *g;
-	chpageplace((int)gg.curpage, (*g)->x - (*g)->kind->bbmax,
-			(*g)->y - (*g)->kind->bbmax, (*g)->x + (*g)->kind->bbmax,
-			(*g)->y + (*g)->kind->bbmax);
+	(*gate)->next = gg.gbase[gg.curpage - 1];
+	gg.gbase[gg.curpage - 1] = *gate;
+	chpageplace((int)gg.curpage, (*gate)->x - (*gate)->kind->bbmax,
+			(*gate)->y - (*gate)->kind->bbmax, (*gate)->x + (*gate)->kind->bbmax,
+			(*gate)->y + (*gate)->kind->bbmax);
 }
 
 /*===================  NEWGATE  ==================*/
@@ -137,72 +136,72 @@ void linkgate(log_grec **g)
 /*=                                              =*/
 /*================================================*/
 
-void newgptr(log_grec **g)
+void newgptr(log_grec **gate)
 {
 	if (freegate == NULL)
 	{
-		*g = (log_grec *)Malloc(sizeof(log_grec));
+		*gate = (log_grec *)Malloc(sizeof(log_grec));
 	}
 	else
 	{
-		*g = freegate;
+		*gate = freegate;
 		freegate = freegate->next;
 	}
 }
 
 
-void newgate2(log_grec **g, short gt, short sig, log_gattrrec *attrs)
+void newgate2(log_grec **gate, short gt, short sig, log_gattrrec *attrs)
 {
-	short i;
 	char name[256];
 
-	newgptr(g);
-	(*g)->g = gt;
-	(*g)->rot = gt / log_kindoffset;
-	(*g)->kind = kind[(gt & (log_kindoffset - 1)) - 1];
-	(*g)->vars = (na_long)0;
-	(*g)->conflict = false;
-	(*g)->conflict1 = false;
-	(*g)->conflict2 = false;
-	(*g)->oconflict = false;
-	(*g)->dimcolor = false;
-	(*g)->pin = (log_nrec **)Malloc((*g)->kind->numpins * sizeof(log_nrec *));
-	(*g)->pinpos = (log_pinposrec *)
-		Malloc((*g)->kind->numpins * sizeof(log_pinposrec));
+	newgptr(gate);
+	(*gate)->g = gt;
+	(*gate)->rot = gt / log_kindoffset;
+	(*gate)->kind = kind[(gt & (log_kindoffset - 1)) - 1];
+	(*gate)->vars = (na_long)0;
+	(*gate)->conflict = false;
+	(*gate)->conflict1 = false;
+	(*gate)->conflict2 = false;
+	(*gate)->oconflict = false;
+	(*gate)->dimcolor = false;
+	(*gate)->pin = (log_nrec **)Malloc((*gate)->kind->numpins * sizeof(log_nrec *));
+	(*gate)->pinpos = (log_pinposrec *)
+		Malloc((*gate)->kind->numpins * sizeof(log_pinposrec));
 	if (attrs != NULL)
-		copyattrs(&(*g)->attr, attrs, (*g)->kind->numattrs, (*g)->kind->attr);
+		copyattrs(&(*gate)->attr, attrs, (*gate)->kind->numattrs, (*gate)->kind->attr);
 	else
-		newattrs(&(*g)->attr, (*g)->kind->numattrs, (*g)->kind->attr);
+		newattrs(&(*gate)->attr, (*gate)->kind->numattrs, (*gate)->kind->attr);
 
 	if (sig != 0)
 	{
-		(*g)->sig = sig;
+		(*gate)->sig = sig;
 	}
-	else if ((*g)->kind->simtype == simtype_common)
+	else if ((*gate)->kind->simtype == simtype_common)
 	{
 		*name = '\0';
-		i = 1;
-		while ((*g)->kind->proc[i - 1] != '\0')
+		short i = 1;
+		while ((*gate)->kind->proc[i - 1] != '\0')
 		{
-			sprintf(name + strlen(name), "%c", (*g)->kind->proc[i - 1]);
+			sprintf(name + strlen(name), "%c", (*gate)->kind->proc[i - 1]);
 			i++;
 		}
-		(*g)->sig = getsignal(0, name);
+		(*gate)->sig = getsignal(0, name);
 	}
 	else
 	{
-		(*g)->sig = 0;
+		(*gate)->sig = 0;
 	}
-	(*g)->info = (na_long)0;
-	(*g)->temp = (na_long)0;
+
+	(*gate)->info = (na_long)0;
+	(*gate)->temp = (na_long)0;
 	gg.actflag = (attrs != NULL);
-	calltoolgate(*g, act_newgate);
+	calltoolgate(*gate, act_newgate);
 }
 
 
-void newgate(log_grec **g, short gt)
+void newgate(log_grec **gate, short gt)
 {
-	newgate2(g, gt, 0, NULL);
+	newgate2(gate, gt, 0, NULL);
 }
 
 
@@ -212,30 +211,32 @@ void newgate(log_grec **g, short gt)
 /*=                                              =*/
 /*================================================*/
 
-void copygate(log_grec *old, log_grec **g)
+void copygate(log_grec *old, log_grec **gate)
 {
-	long i, FORLIM;
-
-	newgptr(g);
-	**g = *old;
-	if ((*g)->conflict || (*g)->oconflict)
-	{
-		(*g)->confnext = gateconflictbase;
-		gateconflictbase = *g;
-	}
-	(*g)->pin = (log_nrec **)Malloc((*g)->kind->numpins * sizeof(log_nrec *));
-	FORLIM = (*g)->kind->numpins;
-	for (i = 0; i < FORLIM; i++)
-		(*g)->pin[i] = old->pin[i];
-	(*g)->pinpos = (log_pinposrec *)
-		Malloc((*g)->kind->numpins * sizeof(log_pinposrec));
-	FORLIM = (*g)->kind->numpins;
-	for (i = 0; i < FORLIM; i++)
-		(*g)->pinpos[i] = old->pinpos[i];
-	copyattrs(&(*g)->attr, old->attr, (*g)->kind->numattrs, (*g)->kind->attr);
-	(*g)->info = (na_long)0;
+	newgptr(gate);
+	**gate = *old;
+	if ((*gate)->conflict || (*gate)->oconflict)
+	{
+		(*gate)->confnext = gateconflictbase;
+		gateconflictbase = *gate;
+	}
+	(*gate)->pin = (log_nrec **)Malloc((*gate)->kind->numpins * sizeof(log_nrec *));
+	
+	long numpins = (*gate)->kind->numpins;
+	for (long i = 0; i < numpins; i++)
+		(*gate)->pin[i] = old->pin[i];
+	
+	(*gate)->pinpos = (log_pinposrec *)
+		Malloc((*gate)->kind->numpins * sizeof(log_pinposrec));
+
+	numpins = (*gate)->kind->numpins;
+	for (long i = 0; i < numpins; i++)
+		(*gate)->pinpos[i] = old->pinpos[i];
+
+	copyattrs(&(*gate)->attr, old->attr, (*gate)->kind->numattrs, (*gate)->kind->attr);
+	(*gate)->info = (na_long)0;
 	gg.actgate2 = old;
-	calltoolgate(*g, act_copygate);
+	calltoolgate(*gate, act_copygate);
 }
 
 
@@ -245,20 +246,20 @@ void copygate(log_grec *old, log_grec **g)
 /*=                                              =*/
 /*================================================*/
 
-void unlkgate(log_grec **g)
+void unlkgate(log_grec **gate)
 {
 	log_grec *g1;
 
 	g1 = gg.gbase[gg.curpage - 1];
-	while (g1 != NULL && g1->next != *g)
+	while (g1 != NULL && g1->next != *gate)
 		g1 = g1->next;
 	if (g1 == NULL)
-		gg.gbase[gg.curpage - 1] = (*g)->next;
+		gg.gbase[gg.curpage - 1] = (*gate)->next;
 	else
-		g1->next = (*g)->next;
-	chpageplace((int)gg.curpage, (*g)->x - (*g)->kind->bbmax,
-			(*g)->y - (*g)->kind->bbmax, (*g)->x + (*g)->kind->bbmax,
-			(*g)->y + (*g)->kind->bbmax);
+		g1->next = (*gate)->next;
+	chpageplace((int)gg.curpage, (*gate)->x - (*gate)->kind->bbmax,
+			(*gate)->y - (*gate)->kind->bbmax, (*gate)->x + (*gate)->kind->bbmax,
+			(*gate)->y + (*gate)->kind->bbmax);
 }
 
 
@@ -268,47 +269,42 @@ void unlkgate(log_grec **g)
 /*=                                              =*/
 /*================================================*/
 
-void disposegptr(log_grec **g)
+void disposegptr(log_grec **gate)
 {
-	(*g)->next = freegate;
-	freegate = *g;
+	(*gate)->next = freegate;
+	freegate = *gate;
 }
 
 
-#define rtn             "DISPOSEGATE"
-
-
-void disposegate(log_grec **g)
+void disposegate(log_grec **gate)
 {
 	log_grec *g1, *g2;
 
-	if ((*g)->conflict || (*g)->oconflict)
+	if ((*gate)->conflict || (*gate)->oconflict)
 	{
 		g1 = gateconflictbase;
 		g2 = NULL;
-		while (g1 != NULL && g1 != *g)
+		while (g1 != NULL && g1 != *gate)
 		{
 			g2 = g1;
 			g1 = g1->confnext;
 		}
 		if (g1 == NULL)
-			report(10, rtn);
+			report(10, "DISPOSEGATE");
 		else if (g2 == NULL)
-			gateconflictbase = (*g)->confnext;
+			gateconflictbase = (*gate)->confnext;
 		else
-			g2->confnext = (*g)->confnext;
+			g2->confnext = (*gate)->confnext;
 	}
-	if (*g == gg.probegate)
+	if (*gate == gg.probegate)
 		gg.probegate = NULL;
-	calltoolgate(*g, act_disposegate);
-	disposeattrs(&(*g)->attr, (*g)->kind->numattrs, (*g)->kind->attr);
-	Free((*g)->pin);
-	Free((*g)->pinpos);
-	disposegptr(g);
+	calltoolgate(*gate, act_disposegate);
+	disposeattrs(&(*gate)->attr, (*gate)->kind->numattrs, (*gate)->kind->attr);
+	Free((*gate)->pin);
+	Free((*gate)->pinpos);
+	disposegptr(gate);
 }
 
-#undef rtn
-
 /*================  CLOSERGATE  ==================*/
 /*=                                              =*/
 /*=  Find which gate (if any) is under cursor.   =*/
@@ -355,10 +351,8 @@ void closergate(short x, short y)
 		gg.neargate = gg.neargate->next;
 }
 
-#define rtn             "CHGGATE"
 
-
-void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
+void chggate(log_grec *gate, int i, log_nrec *oldnode, log_nrec *n)
 {
 	log_hwrec *hw;
 	log_vwrec *vw;
@@ -366,18 +360,16 @@ void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
 	short j, k, savepg, pg, x, y, FORLIM;
 
 	if (gg.traceflag)
-		fprintf(tracefile, "Change gate %ld pin %d to node %ld\n",
-				(long)g, i, (long)n);
+		fprintf(tracefile, "Change gate %p pin %d to node %p\n",
+				gate, i, n);
 	j = i;
 	do
 	{
-		if (g->pin[j - 1] == oldnode)
+		if (gate->pin[j - 1] == oldnode)
 		{
-			switchnode(&g->pin[j - 1], n);
-			/* if (j <> i) then  */
-			/*unsafe optimization*/
-			x = g->pinpos[j - 1].x;
-			y = g->pinpos[j - 1].y;
+			switchnode(&gate->pin[j - 1], n);
+			x = gate->pinpos[j - 1].x;
+			y = gate->pinpos[j - 1].y;
 			hw = gg.hwbase[gg.curpage - 1];
 			while (hw != NULL)
 			{
@@ -395,10 +387,12 @@ void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
 			g1 = gg.gbase[gg.curpage - 1];
 			while (g1 != NULL)
 			{
-				if (g1 != g && P_imax2((long)abs(g1->x - x), (long)abs(g1->y - y)) <=
-						g1->kind->bbmax) {
+				if (g1 != gate && P_imax2((long)abs(g1->x - x), (long)abs(g1->y - y)) <=
+						g1->kind->bbmax)
+				{
 					FORLIM = g1->kind->numpins;
-					for (k = 1; k <= FORLIM; k++) {
+					for (k = 1; k <= FORLIM; k++)
+					{
 						if (x == g1->pinpos[k - 1].x && y == g1->pinpos[k - 1].y &&
 								g1->pin[k - 1] == oldnode)
 							chggate(g1, k, oldnode, n);
@@ -407,12 +401,12 @@ void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
 				g1 = g1->next;
 			}
 		}
-		j = g->kind->pin[j - 1].c;
+		j = gate->kind->pin[j - 1].c;
 	} while (j != i && j != 0);
-	if (i != 1 || g->kind->simtype != simtype_common || g->sig == 0 ||
-			gg.signaltab[g->sig - 1].np != oldnode)
+	if (i != 1 || gate->kind->simtype != simtype_common || gate->sig == 0 ||
+			gg.signaltab[gate->sig - 1].np != oldnode)
 		return;
-	switchnode(&gg.signaltab[g->sig - 1].np, n);
+	switchnode(&gg.signaltab[gate->sig - 1].np, n);
 	savepg = gg.curpage;
 	FORLIM = gg.numpages;
 	for (pg = 1; pg <= FORLIM; pg++)
@@ -421,7 +415,7 @@ void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
 		g1 = gg.gbase[gg.curpage - 1];
 		while (g1 != NULL)
 		{
-			if (g1->kind->simtype == simtype_common && g1->sig == g->sig &&
+			if (g1->kind->simtype == simtype_common && g1->sig == gate->sig &&
 					g1->pin[0] == oldnode)
 				chggate(g1, 1, oldnode, n);
 			g1 = g1->next;
@@ -430,9 +424,8 @@ void chggate(log_grec *g, int i, log_nrec *oldnode, log_nrec *n)
 	gg.curpage = savepg;
 }
 
-#undef rtn
 
-void chggatepin(log_grec *g, short i, log_nrec **oldnode, log_nrec **savenode)
+void chggatepin(log_grec *gate, short i, log_nrec **oldnode, log_nrec **savenode)
 {
 	log_nrec *n;
 	log_hwrec *hw;
@@ -441,10 +434,10 @@ void chggatepin(log_grec *g, short i, log_nrec **oldnode, log_nrec **savenode)
 	short j, x, y, FORLIM;
 
 	if (gg.traceflag)
-		fprintf(tracefile, "Change gate %ld pin %d from node %ld\n",
-				(long)g, i, (long)(*oldnode));
-	x = g->pinpos[i - 1].x;
-	y = g->pinpos[i - 1].y;
+		fprintf(tracefile, "Change gate %p pin %d from node %p\n",
+				gate, i, *oldnode);
+	x = gate->pinpos[i - 1].x;
+	y = gate->pinpos[i - 1].y;
 	hw = gg.hwbase[gg.curpage - 1];
 	while (hw != NULL)
 	{
@@ -470,7 +463,7 @@ void chggatepin(log_grec *g, short i, log_nrec **oldnode, log_nrec **savenode)
 	g1 = gg.gbase[gg.curpage - 1];
 	while (g1 != NULL)
 	{
-		if (g1 != g &&
+		if (g1 != gate &&
 				P_imax2((long)abs(g1->x - x), (long)abs(g1->y - y)) <= g1->kind->bbmax)
 		{
 			FORLIM = g1->kind->numpins;
@@ -489,7 +482,7 @@ void chggatepin(log_grec *g, short i, log_nrec **oldnode, log_nrec **savenode)
 }
 
 
-void disconnectgate(log_grec *g)
+void disconnectgate(log_grec *gate)
 {
 	log_nrec *savenode;
 	short i, j;
@@ -498,49 +491,49 @@ void disconnectgate(log_grec *g)
 	short FORLIM;
 
 	if (gg.traceflag)
-		fprintf(tracefile, "Disconnect gate %ld\n", (long)g);
-	stamp(&g->kind->simtype->netstamp);
-	calltoolgate(g, act_disconnectgate);
-	oldnode = (log_nrec **)Malloc(g->kind->numpins * sizeof(log_nrec *));
-	FORLIM = g->kind->numpins;
+		fprintf(tracefile, "Disconnect gate %p\n", gate);
+	stamp(&gate->kind->simtype->netstamp);
+	calltoolgate(gate, act_disconnectgate);
+	oldnode = (log_nrec **)Malloc(gate->kind->numpins * sizeof(log_nrec *));
+	FORLIM = gate->kind->numpins;
 	for (i = 0; i < FORLIM; i++)
 	{
-		oldnode[i] = g->pin[i];
+		oldnode[i] = gate->pin[i];
 		stamp(&oldnode[i]->simtype->netstamp);
-		switchnode(&g->pin[i], NULL);
+		switchnode(&gate->pin[i], NULL);
 	}
 	P_expset(done, 0L);
-	FORLIM = g->kind->numpins;
+	FORLIM = gate->kind->numpins;
 	for (i = 1; i <= FORLIM; i++)
 	{
 		if (!P_inset(i, done))
 		{
 			j = i;
-			if (i == 1 && g->kind->simtype == simtype_common && g->sig != 0)
+			if (i == 1 && gate->kind->simtype == simtype_common && gate->sig != 0)
 				savenode = NULL;
 			else
 				savenode = oldnode[i - 1];
 			do {
-				chggatepin(g, j, &oldnode[i - 1], &savenode);
+				chggatepin(gate, j, &oldnode[i - 1], &savenode);
 				P_addset(done, j);
-				j = g->kind->pin[j - 1].c;
+				j = gate->kind->pin[j - 1].c;
 			} while (j != i && j != 0);
 		}
 	}
-	unlkgate(&g);
+	unlkgate(&gate);
 }
 
 
-void delgate(log_grec *g)
+void delgate(log_grec *gate)
 {
 	clipon();
-	eragate(g);
-	disconnectgate(g);
-	disposegate(&g);
+	eragate(gate);
+	disconnectgate(gate);
+	disposegate(&gate);
 	clipoff();
 }
 
-void frygate(log_grec *g)
+void frygate(log_grec *gate)
 {
 	long t0;
 
@@ -549,8 +542,8 @@ void frygate(log_grec *g)
 	t0 = timers_sysclock();
 	while (labs(timers_sysclock() - t0) < frytime)
 	{
-		drawgatec(g->x, g->y, g->g, gg.color.conflict);
-		eragate(g);
+		drawgatec(gate->x, gate->y, gate->g, gg.color.conflict);
+		eragate(gate);
 	}
 	clipoff();
 	refreshsoon();
@@ -563,27 +556,27 @@ void frygate(log_grec *g)
 /*=                                              =*/
 /*================================================*/
 
-void initpinpos(log_grec *g)
+void initpinpos(log_grec *gate)
 {
 	short i, rxx, rxy, ryx, ryy;
 	log_krec *WITH;
 	short FORLIM;
 
-	rxx = log_rotxx[g->rot];
-	rxy = log_rotxy[g->rot];
-	ryx = log_rotyx[g->rot];
-	ryy = log_rotyy[g->rot];
-	WITH = g->kind;
+	rxx = log_rotxx[gate->rot];
+	rxy = log_rotxy[gate->rot];
+	ryx = log_rotyx[gate->rot];
+	ryy = log_rotyy[gate->rot];
+	WITH = gate->kind;
 	FORLIM = WITH->numpins;
 	for (i = 0; i < FORLIM; i++)
 	{
-		g->pinpos[i].x = g->x + WITH->pin[i].x * rxx + WITH->pin[i].y * ryx;
-		g->pinpos[i].y = g->y + WITH->pin[i].x * rxy + WITH->pin[i].y * ryy;
+		gate->pinpos[i].x = gate->x + WITH->pin[i].x * rxx + WITH->pin[i].y * ryx;
+		gate->pinpos[i].y = gate->y + WITH->pin[i].x * rxy + WITH->pin[i].y * ryy;
 	}
 }
 
 
-int connectgate(log_grec *g)
+int connectgate(log_grec *gate)
 {
 	int Result;
 	cnrec *cnbase;
@@ -597,22 +590,22 @@ int connectgate(log_grec *g)
 	short FORLIM, FORLIM1;
 
 	if (gg.traceflag)
-		fprintf(tracefile, "Connect gate %ld, type %s\n", (long)g, g->kind->name);
-	linkgate(&g);
-	initpinpos(g);
-	FORLIM = g->kind->numpins;
+		fprintf(tracefile, "Connect gate %p, type %s\n", gate, gate->kind->name);
+	linkgate(&gate);
+	initpinpos(gate);
+	FORLIM = gate->kind->numpins;
 	for (i = 0; i < FORLIM; i++)
 	{
 		ptrs[i] = 0;
-		g->pin[i] = NULL;
+		gate->pin[i] = NULL;
 	}
-	FORLIM = g->kind->numpins;
+	FORLIM = gate->kind->numpins;
 	for (i = 1; i <= FORLIM; i++)
 	{
 		if (ptrs[i - 1] == 0)
 		{
-			newnoderef(&g->pin[i - 1], g->kind->pin[i - 1].s, 1L);
-			if (g->pin[i - 1] == NULL)
+			newnoderef(&gate->pin[i - 1], gate->kind->pin[i - 1].s, 1L);
+			if (gate->pin[i - 1] == NULL)
 			{
 				Result = false;
 				goto _L1;   /*return*/
@@ -621,16 +614,16 @@ int connectgate(log_grec *g)
 			do
 			{
 				ptrs[j - 1] = i;
-				j = g->kind->pin[j - 1].c;
+				j = gate->kind->pin[j - 1].c;
 			} while (j != i && j != 0);
 		}
 	}
 	cnbase = NULL;
-	FORLIM = g->kind->numpins;
+	FORLIM = gate->kind->numpins;
 	for (i = 0; i < FORLIM; i++)
 	{
-		xp = g->pinpos[i].x;
-		yp = g->pinpos[i].y;
+		xp = gate->pinpos[i].x;
+		yp = gate->pinpos[i].y;
 		n1 = NULL;
 		hw = gg.hwbase[gg.curpage - 1];
 		while (hw != NULL && n1 == NULL)
@@ -649,7 +642,7 @@ int connectgate(log_grec *g)
 		g1 = gg.gbase[gg.curpage - 1];
 		while (g1 != NULL && n1 == NULL)
 		{
-			if (g1 != g && P_imax2((long)abs(g1->x - xp), (long)abs(g1->y - yp)) <=
+			if (g1 != gate && P_imax2((long)abs(g1->x - xp), (long)abs(g1->y - yp)) <=
 					g1->kind->bbmax)
 			{
 				FORLIM1 = g1->kind->numpins;
@@ -662,20 +655,20 @@ int connectgate(log_grec *g)
 			g1 = g1->next;
 		}
 		if (n1 != NULL)
-			queuecombine(&cnbase, &g->pin[ptrs[i] - 1], n1);
+			queuecombine(&cnbase, &gate->pin[ptrs[i] - 1], n1);
 	}
-	if (g->kind->simtype == simtype_common && g->sig != 0)
-		queuecombine(&cnbase, &gg.signaltab[g->sig - 1].np, g->pin);
+	if (gate->kind->simtype == simtype_common && gate->sig != 0)
+		queuecombine(&cnbase, &gg.signaltab[gate->sig - 1].np, gate->pin);
 	gg.actflag = true;
-	calltoolgate(g, act_connectgate);
+	calltoolgate(gate, act_connectgate);
 	success = gg.actflag;
 	if (success && checkcombine(&cnbase))
 	{
-		FORLIM = g->kind->numpins;
+		FORLIM = gate->kind->numpins;
 		for (i = 0; i < FORLIM; i++)
 		{
 			if (ptrs[i] != i + 1)
-				g->pin[i] = refnode(g->pin[ptrs[i] - 1]);
+				gate->pin[i] = refnode(gate->pin[ptrs[i] - 1]);
 		}
 		Result = true;
 	}
@@ -687,21 +680,21 @@ int connectgate(log_grec *g)
 	if (!success)
 	{
 		Result = false;
-		FORLIM = g->kind->numpins;
+		FORLIM = gate->kind->numpins;
 		for (i = 1; i <= FORLIM; i++) {
 			if (ptrs[i - 1] == i)
-				unrefnode(&g->pin[i - 1]);
+				unrefnode(&gate->pin[i - 1]);
 		}
-		unlkgate(&g);
+		unlkgate(&gate);
 	}
 _L1:
 	return Result;
 }
 
 
-void pconnectgate(log_grec *g, int *success)
+void pconnectgate(log_grec *gate, int *success)
 {
-	*success = connectgate(g);
+	*success = connectgate(gate);
 }
 
 /*=================  ADDGATE1  ===================*/
@@ -868,3 +861,4 @@ int addgate(short gtype, short sig, log_gattrrec *attrs)
 	gg.startpoint = false;
 	return Result;
 }
+
-- 
GitLab