diff --git a/src/IDs.cpp b/src/IDs.cpp
index 92419b0..a52efa7 100644
--- a/src/IDs.cpp
+++ b/src/IDs.cpp
@@ -35,27 +35,28 @@
 #include"command.h"
 #include"ExpandingArray.h"
 
-class IDs:public Guintp{
+class IDs {
 public:
+	std::vector<uint> flags;
 	SINGLETON(IDs);
 };
 
 IDs::IDs(){
 	FILE*pFile=myfopen(IDs);
-	_p=new uint[MaxFeature()+1];
-	for(uint i=0;i<=MaxFeature();i++)
-		_p[i]=GetCheckWord(IDs);
+	flags.resize(MaxFeature() + 1);
+	for (auto &flag : flags)
+		flag = GetCheckWord(IDs);
 	fclose(pFile);
 }
 
 class TextIDs{
 public:
-	uint idClasses[0x20],numspecials;
+	uint idClasses[0x20];
 	bool CheckID(uint,uint);
 	void Define(uint);
 	bool IsDefined(uint);
 	static void Clear();
-	AUTO_ARRAY(uchar);
+	std::vector<uchar> specials;
 	SINGLETON(TextIDs);
 private:
 	static Expanding0Array<bool> _m;
@@ -67,8 +68,8 @@ TextIDs::TextIDs(){
 	uint i=0;
 	for(;i<0x20;i++)
 		idClasses[i]=GetCheckWord(TextIDs);
-	_p=new uchar[numspecials=GetCheckByte(TextIDs)];
-	myfread(_p,numspecials,TextIDs);
+	specials.resize(GetCheckByte(TextIDs));
+	myfread(specials.data(), specials.size(), TextIDs);
 	fclose(pFile);
 }
 
@@ -79,8 +80,8 @@ bool TextIDs::CheckID(uint feature,uint ID){
 	}
 	if(feature==0x49&&ID==0xC7FF)return true;
 	if(idClasses[ID>>11]==0xFFFF){
-		for(uint i=0;i<numspecials;i++)if(ID>>8==_p[i])return true;
-		return false;
+		auto it = std::ranges::find(specials, ID >> 8);
+		return it != specials.end();
 	}
 	return(ID&0x7FF)<idClasses[ID>>11];
 }
@@ -127,7 +128,7 @@ bool CheckID(uint feature,uint ID){
 	 * is the first new GRF version after that, so use that as minimum
 	 * threshold for allowing the higher IDs. Even though this is not
 	 * actually tied to GRF version 8.*/
-	uint maxID=_grfver>=8&&feature<=0x03?0xFFFF:IDs::Instance()[feature];
+	uint maxID = _grfver >= 8 && feature <= 0x03 ? 0xFFFF : IDs::Instance().flags.at(feature);
 	if(ID>maxID){
 		IssueMessage(ERROR,INVALID_ID,ID,feature==0x0C?0x49:0,maxID);
 		return false;
diff --git a/src/act0.cpp b/src/act0.cpp
index 44a7e0b..577359e 100644
--- a/src/act0.cpp
+++ b/src/act0.cpp
@@ -98,30 +98,30 @@ char FF is undef
 typedef std::basic_string<uchar> ustring;
 typedef std::vector<int> int_str;
 
-class PropData:public auto_array<PropData>{
+class PropData{
 public:
 	PropData(){}
 	void Init(FILE*,bool);
 	uchar GetData(uint)const;
 	uint GetLength()const{return(uint)length.length();}
-	const PropData*GetVarLength(int)const;
+	const PropData &GetVarLength(int) const;
 	uint GetValue(uint&,const int_str&)const;
-	uint maxfirst(int prop){return idRange[prop]&0xFF;}
-	uint maxlast(int prop){return (idRange[prop]>>8)&0xFF;}
+	uint maxfirst(int prop) const { return idRange[prop] & 0xFF; }
+	uint maxlast(int prop) const { return (idRange[prop] >> 8) & 0xFF; }
+	std::vector<PropData> data;
 private:
 	ustring length;
 	std::vector<uint> idRange;
 	void readString(FILE*,bool);
 	int CountFE();
-	void operator=(const PropData&);
-	PropData(const PropData&);
 };
 
-class Check0:public auto_array<PropData>{
+class Check0 {
 public:
 	void Check(PseudoSprite&);
 	static Check0&Instance(){static Check0 obj;return obj;}
-	uint GetFeat8(){return _p[8].GetLength();}
+	uint GetFeat8() { return data.at(8).GetLength(); }
+	std::vector<PropData> data;
 private:
 	Check0();
 	bool CheckVar(uint&,PseudoSprite&,const PropData&,bool addblank,bool,int_str =int_str())const;
@@ -137,11 +137,11 @@ uchar PropData::GetData(unsigned int prop)const{
 	return prop<length.length()?length[prop]:(uchar)0xFF;
 }
 
-const PropData*PropData::GetVarLength(int prop)const{
-	PropData*ret=_p;
+const PropData &PropData::GetVarLength(int prop) const {
+	auto ret = data.begin();
 	for(int i=0;i<prop;i++)
 		if(length[i]==0xFE)ret++;
-	return ret;
+	return *ret;
 }
 
 uint PropData::GetValue(uint&len_off,const int_str&decoded)const{
@@ -172,9 +172,9 @@ void PropData::Init(FILE*pFile, bool withIDs){
 	readString(pFile, withIDs);
 	int j=CountFE();
 	if(j){
-		_p=new PropData[j];
+		data.clear();
 		for(int k=0;k<j;k++)
-			_p[k].Init(pFile, false);
+			data.emplace_back().Init(pFile, false);
 	}
 }
 
@@ -355,7 +355,7 @@ void Check0::Check(PseudoSprite&str){
 			}
 			if(feature==8 && prop==9)
 				CargoTransTable(IDs-1);
-			len=_p[feature].GetData(prop);
+			len = data.at(feature).GetData(prop);
 			if(prop==8)// Mark prop 08 as set, if necessary.
 				for(uint i=firstID;i<=maxID;i++)
 					Prop08Tracking::Set(feature,i);
@@ -373,18 +373,19 @@ void Check0::Check(PseudoSprite&str){
 				return;
 			}
 			if(feature==8){
-				if(firstID>_p[feature].maxfirst(prop))
-					IssueMessage(ERROR,INVALID_ID,firstID,0,_p[feature].maxfirst(prop));
-				if(IDs&&maxID>_p[feature].maxlast(prop))
-					IssueMessage(ERROR,INVALID_ID,maxID,0,_p[feature].maxlast(prop));
+				const PropData &prop_data = data.at(feature);
+				if (firstID > prop_data.maxfirst(prop))
+					IssueMessage(ERROR, INVALID_ID, firstID, 0, prop_data. maxfirst(prop));
+				if (IDs && maxID > prop_data.maxlast(prop))
+					IssueMessage(ERROR, INVALID_ID, maxID, 0, prop_data. maxlast(prop));
 			}
 			if(propLoc[prop]&&!(len&0x80))
 				IssueMessage(WARNING2,REPEATED_PROP,i,prop,propLoc[prop]);
 			propLoc[prop]=i++;
 			if(len==0xFE){
-				const PropData*data=_p[feature].GetVarLength(prop);
+				const PropData &prop_data = data.at(feature).GetVarLength(prop);
 				for(j=0;j<IDs;j++){
-					if(!CheckVar(i,str,*data,j+1<IDs,true))return;
+					if (!CheckVar(i, str, prop_data, j + 1 < IDs, true)) return;
 					while (lengthlist.size()) {
 						const uint loc = lengthlist.back(),
 							val = str.ExtractDword(loc),
@@ -408,7 +409,7 @@ void Check0::Check(PseudoSprite&str){
 			IssueMessage(ERROR,INSUFFICIENT_DATA2,i-str.Length(),prop);
 		else{
 			if(i<str.Length()){
-				len=_p[feature].GetData(str.ExtractByte(4+str.ExtendedLen(4)));
+				len = data.at(feature).GetData(str.ExtractByte(4 + str.ExtendedLen(4)));
 				if(_autocorrect&&str.ExtractByte(2)==1&&GetWidth(len)<5){
 					// If setting one property, assume setting same prop for more IDs
 					while(i+(GetWidth(len)==3?str.ExtendedLen(i):GetWidth(len))<=str.Length()&&IDs<0xFF){
@@ -426,14 +427,15 @@ void Check0::Check(PseudoSprite&str){
 			}
 			if(!GetState(LINEBREAKS))return;
 			bool linebreaks=(IDs>1||GetState(LINEBREAKS)==3)&&str.ExtractByte(2)>1;
+			const PropData &prop_data = data.at(feature);
 			uint data;
 			for(i=0;i<propLoc.size();i++)
-				linebreaks |= propLoc[i] && _p[feature].GetData(i)==0xFE;
+				linebreaks |= propLoc[i] && prop_data.GetData(i) == 0xFE;
 			if(!linebreaks)return;
 			for(i=0;i<propLoc.size();i++){
 				if(!propLoc[i])continue;
 				str.SetEol(propLoc[i]-1,1);
-				if((data=_p[feature].GetData(i))==0xFE)continue;
+				if ((data = prop_data.GetData(i)) == 0xFE) continue;
 				for(uint j=IDs;j;j--)
 					str.ColumnAfter(propLoc[i]+GetWidth(data)*j);
 			}
@@ -457,9 +459,9 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 			continue;
 		}
 		switch(ch){
-		case'|':return true;
-		case'l':
-		case'm':{
+		case '|':return true;
+		case 'l':
+		case 'm':{
 			uint len=(ch=='m'?vdata.GetData(++i):1);
 			for(uint k=0;k<len;k++){
 				/* Check for a specific raw data value.
@@ -475,11 +477,11 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 			}
 			break;
 		}
-		case'e':
-		case'n':{
+		case 'e':
+		case 'n':{
 			uint lhs=vdata.GetValue(++i,decoded);
 			uint rhs=vdata.GetValue(++i,decoded);
-			const PropData*vdata2=vdata.GetVarLength(i);
+			const PropData &vdata2 = vdata.GetVarLength(i);
 			uchar data=vdata.GetData(++i);
 			if ((lhs == rhs) == (ch == 'n')) break;
 			if(data=='a'){
@@ -489,7 +491,7 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 				str_loc=orig_loc;
 				findPipe=true;
 			}else if(data==0xFE){
-				if(!CheckVar(str_loc,str,*vdata2,false,false,pass))return false;
+				if (!CheckVar(str_loc, str, vdata2, false, false, pass)) return false;
 			}else if(GetWidth(data)<5){
 				FormatSprite(str,str_loc,data,1);
 			}else{
@@ -498,13 +500,13 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 			}
 			break;
 		}
-		case'r':{
-			const PropData*vdata2=vdata.GetVarLength(i);
+		case 'r':{
+			const PropData &vdata2 = vdata.GetVarLength(i);
 			uchar repeat_data=vdata.GetData(++i);
 			uint times=vdata.GetValue(++i,decoded);
 			if(repeat_data==0xFE){
 				for(uint j=0;j<times;j++)
-					if(!CheckVar(str_loc,str,*vdata2,false,false,pass))return false;
+					if (!CheckVar(str_loc, str, vdata2, false, false, pass)) return false;
 			}else if(GetWidth(repeat_data)<5){
 				FormatSprite(str,str_loc,repeat_data,times);
 			}else{
@@ -512,8 +514,9 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 				exit(EDATA);
 			}
 			break;
-		}case'*':{
-			const PropData*vdata2=vdata.GetVarLength(i);
+		}
+		case '*':{
+			const PropData &vdata2 = vdata.GetVarLength(i);
 			uchar repeat_data=vdata.GetData(++i);
 			int term_len=vdata.GetData(++i);
 			uint term;
@@ -542,7 +545,7 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 			try{
 				if(repeat_data==0xFE){
 					while((str.*ExtractTerm)(str_loc)!=term)
-						if(!CheckVar(str_loc,str,*vdata2,false,false,pass))return false;
+						if (!CheckVar(str_loc, str, vdata2, false, false, pass)) return false;
 				}else if(GetWidth(repeat_data)<5){
 					while((str.*ExtractTerm)(str_loc)!=term)
 						FormatSprite(str,str_loc,repeat_data);
@@ -561,7 +564,7 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 			pass.push_back(vdata.GetValue(++i,decoded));
 			break;
 		case 0xFE:
-			CheckVar(str_loc,str,*vdata.GetVarLength(i),false,false,pass);
+			CheckVar(str_loc, str, vdata.GetVarLength(i), false, false, pass);
 			break;
 		default:
 			switch(GetWidth(ch)){
@@ -594,8 +597,8 @@ bool Check0::CheckVar(uint&str_loc,PseudoSprite&str,const PropData&vdata,bool ca
 
 Check0::Check0(){
 	FILE*pFile=myfopen(0);
-	_p=new PropData[MaxFeature()+1];
-	for(uint i=0;i<=MaxFeature();i++)
-		_p[i].Init(pFile,i==8);
+	data.resize(MaxFeature() + 1);
+	for (uint i = 0; i < data.size(); i++)
+		data[i].Init(pFile, i == 8);
 	fclose(pFile);
 }
diff --git a/src/act123.cpp b/src/act123.cpp
index 080e2ad..ba5f875 100644
--- a/src/act123.cpp
+++ b/src/act123.cpp
@@ -107,7 +107,7 @@ void invalidate_act3(){
 
 void CheckCallback(uint offs,uint feature,uint cb){
 	Callbacks&cbs=Callbacks::Instance();
-	if(cb&&(cb>=cbs.numcallbacks||cb<0x10||(cbs[cb]&0x80000000?!(cbs[cb]&(1<<feature)):feature!=cbs[cb])))
+	if (cb && (cb >= cbs.flags.size() || cb < 0x10 || (cbs.flags.at(cb) & 0x80000000 ? !(cbs.flags.at(cb) & (1 << feature)) : feature != cbs.flags.at(cb))))
 		IssueMessage(ERROR,INVALID_CALLBACK,offs,cb);
 }
 
diff --git a/src/act123.h b/src/act123.h
index a1abbdf..653ffe6 100644
--- a/src/act123.h
+++ b/src/act123.h
@@ -19,6 +19,7 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+#include <vector>
 #include "singleton.h"
 #include "message_mgr.h"
 
@@ -86,7 +87,7 @@ class Check2v{
 	SINGLETON(Check2v)
 private:
 	ExpandingArray<VarData>globvars;
-	auto_array<FeatData>_p;
+	std::vector<FeatData> data;
 	uint maxop;
 	uint MaxParam(uint feature, uint var)const;
 	uint GetWidth(uint feature, uint var)const;
@@ -119,7 +120,7 @@ class rand2{
 	struct rand2info{
 		uint bits[2],numtriggers;
 	};
-	auto_array<rand2info>_p;
+	std::vector<rand2info> data;
 public:
 	void CheckRand(uint feat,uint type,uint triggers,uint first,uint nrand);
 	SINGLETON(rand2);
@@ -137,9 +138,9 @@ class Define2{
 	bool checks1C;
 };
 
-class Callbacks:public auto_array<uint>{
+class Callbacks {
 public:
-	uint numcallbacks;
+	std::vector<uint> flags;
 	SINGLETON(Callbacks);
 };
 
diff --git a/src/act123_classes.cpp b/src/act123_classes.cpp
index f24ccbd..e31a1ff 100644
--- a/src/act123_classes.cpp
+++ b/src/act123_classes.cpp
@@ -89,20 +89,20 @@ Check2v::Check2v(){
 		if(var==-1)break;
 		globvars[var]=tempvar;
 	}
-	_p=new FeatData[MaxFeature()+1];
-	for(uint i=0;i<=MaxFeature();i++){
-		_p[i].last80=0xFF;
-		_p[i].featfor82=GetCheckByte(2v);
+	data.resize(MaxFeature() + 1);
+	for (FeatData &featdata : data) {
+		featdata.last80 = 0xFF;
+		featdata.featfor82 = GetCheckByte(2v);
 		while(true){
 			var=tempvar.Load(pFile);
 			if(var==-1)break;
 			if(tempvar.width==0x80){
-				_p[i].last80=var-1;
+				featdata.last80 = var - 1;
 				break;
 			}
 			if(var==0xFF&&tempvar.width==0xF0)break;
-			if(var&0x80)_p[i].var80[var&0x7F]=tempvar;
-			else _p[i].vars[var]=tempvar;
+			if (var & 0x80) featdata.var80[var & 0x7F] = tempvar;
+			else featdata.vars[var] = tempvar;
 		}
 	}
 	fclose(pFile);
@@ -110,30 +110,30 @@ Check2v::Check2v(){
 
 bool Check2v::IsValid(uint feature, uint var)const{
 	if(var>=0x80)
-		return _p[feature].var80[var&0x7F].width != 0;
+		return data.at(feature).var80[var & 0x7F].width != 0;
 	else
-		return _p[feature].vars[var].width || globvars[var].width;
+		return data.at(feature).vars[var].width || globvars[var].width;
 }
 
 uint Check2v::MaxParam(uint feature, uint var)const{
 	assert((var&0xE0)==0x60);
 	assert(IsValid(feature, var));
-	if(_p[feature].vars[var].width)
-		return _p[feature].vars[var].maxparam;
+	if (data.at(feature).vars[var].width)
+		return data.at(feature).vars[var].maxparam;
 	else
 		return globvars[var].maxparam;
 }
 
 uint Check2v::GetWidth(uint feature, uint var)const{
 	assert(IsValid(feature, var));
-	if(_p[feature].vars[var].width)
-		return _p[feature].vars[var].width;
+	if (data.at(feature).vars[var].width)
+		return data.at(feature).vars[var].width;
 	else
 		return globvars[var].width & ~0x40;
 }
 
 uint Check2v::GetEffFeature(uint feature,uint type){
-	if((type&3)==2)return Instance()._p[feature].featfor82;
+	if((type & 3) == 2) return Instance().data.at(feature).featfor82;
 	return feature;
 }
 
@@ -145,9 +145,9 @@ void Check2v::Check(uint feature,uint var,uint offs,uint param,uint shift)const{
 		if(var<0x60 || var>=0x80) IssueMessage(WARNING1,INDIRECT_VAR_NOT_6X,offs);
 	}
 	if(var&0x80){
-		if(var>_p[feature].last80) IssueMessage(ERROR,NONEXISTENT_VARIABLE,offs,var);
+		if (var > data.at(feature).last80) IssueMessage(ERROR, NONEXISTENT_VARIABLE, offs, var);
 		else if(!IsValid(feature, var)) IssueMessage(WARNING1,NONEXISTENT_VARIABLE,offs,var);
-		else if(shift>=_p[feature].var80[var&0x7F].width<<3)IssueMessage(WARNING4,SHIFT_TOO_FAR,offs+1,var);
+		else if (shift >= data.at(feature).var80[var & 0x7F].width << 3) IssueMessage(WARNING4, SHIFT_TOO_FAR, offs + 1, var);
 	}else if(!IsValid(feature,var))
 		IssueMessage(WARNING1,NONEXISTENT_VARIABLE,offs,var);
 	else{
@@ -375,13 +375,13 @@ void varRange::AddRangeInternal(uint min,uint max,RenumMessageId unreachable){
 
 rand2::rand2(){
 	FILE*pFile=myfopen(2r);
-	_p=new rand2info[MaxFeature()+1];
-	for(uint i=0;i<=MaxFeature();i++){
-		_p[i].bits[0]=fgetc(pFile);
-		_p[i].bits[1]=fgetc(pFile);
-		_p[i].numtriggers=fgetc(pFile);
+	data.resize(MaxFeature() + 1);
+	for (rand2info &info : data) {
+		info.bits[0] = fgetc(pFile);
+		info.bits[1] = fgetc(pFile);
+		info.numtriggers = fgetc(pFile);
 	}
-	CheckEOF(_p[MaxFeature()].numtriggers,2r);
+	CheckEOF(data[MaxFeature()].numtriggers, 2r);
 	fclose(pFile);
 }
 
@@ -390,10 +390,10 @@ void rand2::CheckRand(uint feat,uint type,uint triggers,uint first,uint nrand){
 	type&=1;
 	uint bits=0;
 	while(nrand>>=1)bits++;
-	if(first>_p[feat].bits[type])IssueMessage(ERROR,OUT_OF_RANGE_BITS,5,_p[feat].bits[type]);
-	else if(first+bits>_p[feat].bits[type])IssueMessage(ERROR,OUT_OF_RANGE_BITS,6,_p[feat].bits[type]);
+	if (first > data.at(feat).bits[type]) IssueMessage(ERROR, OUT_OF_RANGE_BITS, 5, data.at(feat). bits[type]);
+	else if (first + bits > data.at(feat).bits[type]) IssueMessage(ERROR, OUT_OF_RANGE_BITS, 6 ,data.at(feat). bits[type]);
 	triggers&=0x7F;
-	if(triggers>>_p[feat].numtriggers)IssueMessage(WARNING1,UNDEFINED_TRIGGER);
+	if(triggers >> data.at(feat).numtriggers) IssueMessage(WARNING1, UNDEFINED_TRIGGER);
 }
 
 //****************************************
@@ -416,13 +416,13 @@ void Define2::ChangeFeature(uint feat){
 
 Callbacks::Callbacks(){
 	FILE*pFile=myfopen(callbacks);
-	_p=new uint[numcallbacks=GetCheckWord(callbacks)];
-	for(uint i=0;i<numcallbacks;i++){
+	flags.resize(GetCheckWord(callbacks));
+	for (uint &flag : flags) {
 		uint temp=GetCheckByte(callbacks);
 		if(temp==0x7F)
 			temp = GetCheckWord(callbacks) | (1<<31);
 		else if(temp&0x80)temp ^= (1<<31 | 0x80);
-		_p[i]=temp;
+		flag = temp;
 	}
 	fclose(pFile);
 }
diff --git a/src/act79D.cpp b/src/act79D.cpp
index b214c64..3f3245a 100644
--- a/src/act79D.cpp
+++ b/src/act79D.cpp
@@ -33,42 +33,43 @@
 #include"pseudo.h"
 #include"command.h"
 
-uint numvars;
 class Vars{
 public:
-	bool canRead7(uint v){return(v<0x80||(v<numvars&&_p[v&0x7F]&0x80));}
-	bool canReadD(uint v){return(v<0x80||v==0xFF||(v<numvars&&_p[v&0x7F]&0x40));}
-	bool canWriteD(uint v){return(v<0x80||(v<numvars&&_p[v&0x7F]&0x20));}
-	bool isBitmask(uint v){return(v<numvars&&_p[v&0x7F]&7)==0;}
+	bool canRead7(uint v) const { return (v < 0x80 || (v < numvars && data.at(v & 0x7F) & 0x80)); }
+	bool canReadD(uint v) const { return (v < 0x80 || v == 0xFF || (v < numvars && data.at(v & 0x7F) & 0x40)); }
+	bool canWriteD(uint v) const { return (v < 0x80 || (v < numvars && data.at(v & 0x7F) & 0x20)); }
+	bool isBitmask(uint v) const { return (v < numvars && data.at(v & 0x7F) & 7) == 0; }
 	bool lenOK(uint v,uint len){
 		if(len==4)len--;
-		return(_p[v&0x7F]&(1<<(len-1)))!=0;
+		return (data.at(v & 0x7F) & (1 << (len - 1))) != 0;
 	}
-	AUTO_ARRAY(uchar)
+	std::vector<uchar> data;
+	uint numvars;
 	SINGLETON(Vars)
 };
 
-class D:public Guintp{
+class D {
 public:
+	std::vector<uint> flags;
 	uint maxpatchvar,maxop;
 	SINGLETON(D)
 };
 
 Vars::Vars(){
 	FILE*pFile=myfopen(79Dv);
-	_p=new uchar[numvars=GetCheckByte(79Dv)];
-	myfread(_p,numvars,79Dv);
+	data.resize(GetCheckByte(79Dv));
+	myfread(data.data(), data.size(), 79Dv);
 	fclose(pFile);
-	numvars|=0x80;
+	numvars = static_cast<uint>(data.size()) | 0x80;
 }
 
 D::D(){
 	FILE*pFile=myfopen(D);
 	maxpatchvar=GetCheckByte(D);
 	maxop=GetCheckByte(D);
-	_p=new uint[MaxFeature()+1];
-	for(uint i=0;i<=MaxFeature();i++)
-		_p[i]=GetCheckWord(D);
+	flags.resize(MaxFeature() + 1);
+	for (uint &flag : flags)
+		flag = GetCheckWord(D);
 	fclose(pFile);
 }
 
@@ -190,8 +191,8 @@ bool CheckD(PseudoSprite&data,uint length){
 				data.SetPositionalOpByte(3, 'D');
 				uint feat=(info>>8)&0xFF,count=info>>16;
 				if(src1>6)IssueMessage(ERROR,INVALID_SRC,1);
-				if(feat>MaxFeature()||!D::Instance()[feat])IssueMessage(ERROR,INVALID_FEATURE);
-				else if(count>D::Instance()[feat])IssueMessage(WARNING1,OOR_COUNT);
+				if (feat > MaxFeature() || !D::Instance().flags.at(feat)) IssueMessage(ERROR, INVALID_FEATURE);
+				else if (count > D::Instance().flags.at(feat)) IssueMessage(WARNING1, OOR_COUNT);
 				return true;
 			}
 		}
diff --git a/src/actB.cpp b/src/actB.cpp
index d5b659a..714adfe 100644
--- a/src/actB.cpp
+++ b/src/actB.cpp
@@ -34,16 +34,16 @@
 
 class B{
 public:
-	uint maxSeverity,numMessages;
-	AUTO_ARRAY(uchar);
+	uint maxSeverity;
+	std::vector<uchar> data;
 	SINGLETON(B);
 };
 
 B::B(){
 	FILE*pFile=myfopen(B);
 	maxSeverity=GetCheckByte(B);
-	_p=new uchar[numMessages=GetCheckByte(B)];
-	myfread(_p,numMessages,B);
+	data.resize(GetCheckByte(B));
+	myfread(data.data(), data.size(), B);
 	fclose(pFile);
 }
 
@@ -61,14 +61,14 @@ void CheckB(PseudoSprite&data){
 		CheckLangID(lang,2);
 		_grfver=0;
 	}
-	if(messageid!=0xFF&&messageid>=B::Instance().numMessages){
+	if (messageid != 0xFF && messageid >= B::Instance().data.size()) {
 		IssueMessage(FATAL,INVALID_MESSAGEID);
 		return;
 	}
 	if(messageid==0xFF)
 		specials=CheckString(data,offset,CTRL_NEWLINE,false,MakeStack(4,STACK_TEXT,STACK_TEXT,STACK_DWORD,STACK_DWORD),RETURN_STACK);
 	else
-		specials=B::Instance()[messageid];
+		specials=B::Instance().data.at(messageid);
 	if(specials==-1)return;
 	if(specials>1){
 		try{
diff --git a/src/data.cpp b/src/data.cpp
index f05c17b..73dd88a 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -1303,7 +1303,7 @@ int _GetCheckWord(FILE*pFile,files file,const char*src,int line){
 	return ret|(_CheckEOF(fgetc(pFile),file,src,line)<<8);
 }
 
-void _myfread(FILE*pFile,uchar*target,uint count,files file,const char*src,int line){
+void _myfread(FILE*pFile,uchar*target,size_t count,files file,const char*src,int line){
 	if(fread(target,1,count,pFile)!=count){
 		IssueMessage(0,DATAFILE_ERROR,LOAD,datafiles[file].name+NFORENUM_DIR_LEN,FILELINE,src,line);
 		assert(false);
diff --git a/src/data.h b/src/data.h
index 2c549ef..cade9fd 100644
--- a/src/data.h
+++ b/src/data.h
@@ -81,7 +81,7 @@ END_DATA()
 FILE*_myfopen(files, bool);
 int _CheckEOF(int,files,const char*,int);
 int _GetCheckWord(FILE*,files,const char*,int);
-void _myfread(FILE*,uchar*,uint,files,const char*,int);
+void _myfread(FILE*,uchar*,size_t,files,const char*,int);
 
 #define CheckEOF(ch,name) _CheckEOF(ch,dat##name,__FILE__,__LINE__)
 #define GetCheckByte(name) CheckEOF(fgetc(pFile),name)
diff --git a/src/sanity.cpp b/src/sanity.cpp
index 66d7132..e2e5475 100644
--- a/src/sanity.cpp
+++ b/src/sanity.cpp
@@ -42,41 +42,38 @@ bool _base_grf = false;
 
 class features{
 public:
-	uint maxFeat;
 	struct featdat{
 		uchar validbits;
 		uchar act2type;
 	};
-	AUTO_ARRAY(featdat);
+	std::vector<featdat> data;
 	SINGLETON(features)
 };
 
 features::features(){
 	FILE*pFile=myfopen(feat);
-	maxFeat=GetCheckByte(feat);
-	_p=new features::featdat[maxFeat+1];
-	uint i=0;
-	for(;i<=maxFeat;i++) _p[i].validbits=(uchar)GetCheckByte(feat);
-	for(i=0;i<=maxFeat;i++) _p[i].act2type=(uchar)GetCheckByte(feat);
+	data.resize(GetCheckByte(feat));
+	for (featdat &f : data) f.validbits = (uchar)GetCheckByte(feat);
+	for (featdat &f : data) f.act2type = (uchar)GetCheckByte(feat);
 	fclose(pFile);
 }
 
 bool IsValidFeature(int act,uint feat){
-	if(feat>features::Instance().maxFeat)return false;
-	return(features::Instance()[feat].validbits&act)!=0;
+	if (feat > features::Instance().data.size()) return false;
+	return (features::Instance().data[feat].validbits & act) != 0;
 }
 
 bool IsValid2Feature(uint feat){
-	if(feat>features::Instance().maxFeat)return false;
-	return features::Instance()[feat].act2type!=0xFF;
+	if (feat > features::Instance().data.size()) return false;
+	return features::Instance().data[feat].act2type != 0xFF;
 }
 
 uchar Get2Type(uint feat){
-	if(feat>features::Instance().maxFeat)return 0xFF;
-	return features::Instance()[feat].act2type;
+	if (feat > features::Instance().data.size()) return 0xFF;
+	return features::Instance().data[feat].act2type;
 }
 
-uint MaxFeature(){return features::Instance().maxFeat;}
+uint MaxFeature() { return static_cast<uint>(features::Instance().data.size()); }
 
 #define MAX_TTD_SPRITE 4894
 
diff --git a/src/sanity_defines.h b/src/sanity_defines.h
index 413055d..1acc874 100644
--- a/src/sanity_defines.h
+++ b/src/sanity_defines.h
@@ -53,25 +53,4 @@ bool IsProp08Set(uint feat,uint id);
 uchar Get2Type(uint feat);
 uint MaxFeature();
 
-template<typename _Ty>class auto_array{//can't use auto_ptr because I use new[]/delete[]
-public:
-	auto_array():_p(NULL){}
-	~auto_array(){delete[]_p;}
-	operator _Ty*&(){return _p;}
-	operator const _Ty*()const{return _p;}
-	const _Ty* operator=(_Ty*p){return _p=p;}
-protected:
-	_Ty*_p;
-private:
-	void operator=(const auto_array<_Ty>&);
-	auto_array(const auto_array&);
-};
-
-typedef auto_array<uint> Guintp;
-
-#define AUTO_ARRAY(type)\
-	auto_array<type>_p;\
-	type&operator[](uint x){return _p[x];}\
-	type operator[](uint x)const{return _p[x];}\
-
 #endif//_RENUM_SANITY_DEFS_H_INCLUDED_
diff --git a/src/strings.cpp b/src/strings.cpp
index b62cb7b..344c72d 100644
--- a/src/strings.cpp
+++ b/src/strings.cpp
@@ -36,26 +36,26 @@
 #include"messages.h"
 #include"command.h"
 
-class check4:public Guintp{
+class check4{
 public:
 	int GetGenericPerms(int feature);
 	int GetNamePerms(int feature);
 	SINGLETON(check4)
+	std::vector<uint> features;
 };
 
 check4::check4(){
 	FILE*pFile=myfopen(4);
-	_p=new uint[MaxFeature()+1];
-	uint i=0;
-	for(;i<=MaxFeature();i++)
-		_p[i]=fgetc(pFile);
-	for(i=0;i<=MaxFeature();i++)
-		_p[i]|=GetCheckByte(4)<<8;
+	features.resize(MaxFeature() + 1);
+	for (auto &flags : features)
+		flags = GetCheckByte(4);
+	for (auto &flags : features)
+		flags |= GetCheckByte(4) << 8;
 	fclose(pFile);
 }
 
-int check4::GetGenericPerms(int feature){return _p[feature]>>8;}
-int check4::GetNamePerms(int feature){return _p[feature]&0xFF;}
+int check4::GetGenericPerms(int feature) { return features.at(feature) >> 8; }
+int check4::GetNamePerms(int feature) { return features.at(feature) & 0xFF; }
 
 void Check4(PseudoSprite&data){
 	const uint feature=data.ExtractByte(1),lang=data.ExtractByte(2);