metasm 1.0.1 → 1.0.2

data/{lib/metasm → metasm}/os/windows_exports.rb

@@ -740,6 +740,147 @@ EOL
 	end
 
 	patch_rubylib_to_current_interpreter
+
+	# mandiant import hash crap with ordinal imports (from pefile.py)
+	ih_ws232 = {
+1 => 'accept', 2 => 'bind', 3 => 'closesocket', 4 => 'connect',
+5 => 'getpeername', 6 => 'getsockname', 7 => 'getsockopt', 8 => 'htonl',
+9 => 'htons', 10 => 'ioctlsocket', 11 => 'inet_addr', 12 => 'inet_ntoa',
+13 => 'listen', 14 => 'ntohl', 15 => 'ntohs', 16 => 'recv',
+17 => 'recvfrom', 18 => 'select', 19 => 'send', 20 => 'sendto',
+21 => 'setsockopt', 22 => 'shutdown', 23 => 'socket', 24 => 'GetAddrInfoW',
+25 => 'GetNameInfoW', 26 => 'WSApSetPostRoutine', 27 => 'FreeAddrInfoW', 28 => 'WPUCompleteOverlappedRequest',
+29 => 'WSAAccept', 30 => 'WSAAddressToStringA', 31 => 'WSAAddressToStringW', 32 => 'WSACloseEvent',
+33 => 'WSAConnect', 34 => 'WSACreateEvent', 35 => 'WSADuplicateSocketA', 36 => 'WSADuplicateSocketW',
+37 => 'WSAEnumNameSpaceProvidersA', 38 => 'WSAEnumNameSpaceProvidersW', 39 => 'WSAEnumNetworkEvents', 40 => 'WSAEnumProtocolsA',
+41 => 'WSAEnumProtocolsW', 42 => 'WSAEventSelect', 43 => 'WSAGetOverlappedResult', 44 => 'WSAGetQOSByName',
+45 => 'WSAGetServiceClassInfoA', 46 => 'WSAGetServiceClassInfoW', 47 => 'WSAGetServiceClassNameByClassIdA', 48 => 'WSAGetServiceClassNameByClassIdW',
+49 => 'WSAHtonl', 50 => 'WSAHtons', 51 => 'gethostbyaddr', 52 => 'gethostbyname',
+53 => 'getprotobyname', 54 => 'getprotobynumber', 55 => 'getservbyname', 56 => 'getservbyport',
+57 => 'gethostname', 58 => 'WSAInstallServiceClassA', 59 => 'WSAInstallServiceClassW', 60 => 'WSAIoctl',
+61 => 'WSAJoinLeaf', 62 => 'WSALookupServiceBeginA', 63 => 'WSALookupServiceBeginW', 64 => 'WSALookupServiceEnd',
+65 => 'WSALookupServiceNextA', 66 => 'WSALookupServiceNextW', 67 => 'WSANSPIoctl', 68 => 'WSANtohl',
+69 => 'WSANtohs', 70 => 'WSAProviderConfigChange', 71 => 'WSARecv', 72 => 'WSARecvDisconnect',
+73 => 'WSARecvFrom', 74 => 'WSARemoveServiceClass', 75 => 'WSAResetEvent', 76 => 'WSASend',
+77 => 'WSASendDisconnect', 78 => 'WSASendTo', 79 => 'WSASetEvent', 80 => 'WSASetServiceA',
+81 => 'WSASetServiceW', 82 => 'WSASocketA', 83 => 'WSASocketW', 84 => 'WSAStringToAddressA',
+85 => 'WSAStringToAddressW', 86 => 'WSAWaitForMultipleEvents', 87 => 'WSCDeinstallProvider', 88 => 'WSCEnableNSProvider',
+89 => 'WSCEnumProtocols', 90 => 'WSCGetProviderPath', 91 => 'WSCInstallNameSpace', 92 => 'WSCInstallProvider',
+93 => 'WSCUnInstallNameSpace', 94 => 'WSCUpdateProvider', 95 => 'WSCWriteNameSpaceOrder', 96 => 'WSCWriteProviderOrder',
+97 => 'freeaddrinfo', 98 => 'getaddrinfo', 99 => 'getnameinfo', 101 => 'WSAAsyncSelect',
+102 => 'WSAAsyncGetHostByAddr', 103 => 'WSAAsyncGetHostByName', 104 => 'WSAAsyncGetProtoByNumber', 105 => 'WSAAsyncGetProtoByName',
+106 => 'WSAAsyncGetServByPort', 107 => 'WSAAsyncGetServByName', 108 => 'WSACancelAsyncRequest', 109 => 'WSASetBlockingHook',
+110 => 'WSAUnhookBlockingHook', 111 => 'WSAGetLastError', 112 => 'WSASetLastError', 113 => 'WSACancelBlockingCall',
+114 => 'WSAIsBlocking', 115 => 'WSAStartup', 116 => 'WSACleanup', 151 => '__WSAFDIsSet',
+500 => 'WEP',
+	}
+
+	IMPORT_HASH = {
+		'ws2_32' => ih_ws232,
+		'wsock2' => ih_ws232,
+		'oleaut' => {
+2 => 'SysAllocString', 3 => 'SysReAllocString', 4 => 'SysAllocStringLen', 5 => 'SysReAllocStringLen',
+6 => 'SysFreeString', 7 => 'SysStringLen', 8 => 'VariantInit', 9 => 'VariantClear',
+10 => 'VariantCopy', 11 => 'VariantCopyInd', 12 => 'VariantChangeType', 13 => 'VariantTimeToDosDateTime',
+14 => 'DosDateTimeToVariantTime', 15 => 'SafeArrayCreate', 16 => 'SafeArrayDestroy', 17 => 'SafeArrayGetDim',
+18 => 'SafeArrayGetElemsize', 19 => 'SafeArrayGetUBound', 20 => 'SafeArrayGetLBound', 21 => 'SafeArrayLock',
+22 => 'SafeArrayUnlock', 23 => 'SafeArrayAccessData', 24 => 'SafeArrayUnaccessData', 25 => 'SafeArrayGetElement',
+26 => 'SafeArrayPutElement', 27 => 'SafeArrayCopy', 28 => 'DispGetParam', 29 => 'DispGetIDsOfNames',
+30 => 'DispInvoke', 31 => 'CreateDispTypeInfo', 32 => 'CreateStdDispatch', 33 => 'RegisterActiveObject',
+34 => 'RevokeActiveObject', 35 => 'GetActiveObject', 36 => 'SafeArrayAllocDescriptor', 37 => 'SafeArrayAllocData',
+38 => 'SafeArrayDestroyDescriptor', 39 => 'SafeArrayDestroyData', 40 => 'SafeArrayRedim', 41 => 'SafeArrayAllocDescriptorEx',
+42 => 'SafeArrayCreateEx', 43 => 'SafeArrayCreateVectorEx', 44 => 'SafeArraySetRecordInfo', 45 => 'SafeArrayGetRecordInfo',
+46 => 'VarParseNumFromStr', 47 => 'VarNumFromParseNum', 48 => 'VarI2FromUI1', 49 => 'VarI2FromI4',
+50 => 'VarI2FromR4', 51 => 'VarI2FromR8', 52 => 'VarI2FromCy', 53 => 'VarI2FromDate',
+54 => 'VarI2FromStr', 55 => 'VarI2FromDisp', 56 => 'VarI2FromBool', 57 => 'SafeArraySetIID',
+58 => 'VarI4FromUI1', 59 => 'VarI4FromI2', 60 => 'VarI4FromR4', 61 => 'VarI4FromR8',
+62 => 'VarI4FromCy', 63 => 'VarI4FromDate', 64 => 'VarI4FromStr', 65 => 'VarI4FromDisp',
+66 => 'VarI4FromBool', 67 => 'SafeArrayGetIID', 68 => 'VarR4FromUI1', 69 => 'VarR4FromI2',
+70 => 'VarR4FromI4', 71 => 'VarR4FromR8', 72 => 'VarR4FromCy', 73 => 'VarR4FromDate',
+74 => 'VarR4FromStr', 75 => 'VarR4FromDisp', 76 => 'VarR4FromBool', 77 => 'SafeArrayGetVartype',
+78 => 'VarR8FromUI1', 79 => 'VarR8FromI2', 80 => 'VarR8FromI4', 81 => 'VarR8FromR4',
+82 => 'VarR8FromCy', 83 => 'VarR8FromDate', 84 => 'VarR8FromStr', 85 => 'VarR8FromDisp',
+86 => 'VarR8FromBool', 87 => 'VarFormat', 88 => 'VarDateFromUI1', 89 => 'VarDateFromI2',
+90 => 'VarDateFromI4', 91 => 'VarDateFromR4', 92 => 'VarDateFromR8', 93 => 'VarDateFromCy',
+94 => 'VarDateFromStr', 95 => 'VarDateFromDisp', 96 => 'VarDateFromBool', 97 => 'VarFormatDateTime',
+98 => 'VarCyFromUI1', 99 => 'VarCyFromI2', 100 => 'VarCyFromI4', 101 => 'VarCyFromR4',
+102 => 'VarCyFromR8', 103 => 'VarCyFromDate', 104 => 'VarCyFromStr', 105 => 'VarCyFromDisp',
+106 => 'VarCyFromBool', 107 => 'VarFormatNumber', 108 => 'VarBstrFromUI1', 109 => 'VarBstrFromI2',
+110 => 'VarBstrFromI4', 111 => 'VarBstrFromR4', 112 => 'VarBstrFromR8', 113 => 'VarBstrFromCy',
+114 => 'VarBstrFromDate', 115 => 'VarBstrFromDisp', 116 => 'VarBstrFromBool', 117 => 'VarFormatPercent',
+118 => 'VarBoolFromUI1', 119 => 'VarBoolFromI2', 120 => 'VarBoolFromI4', 121 => 'VarBoolFromR4',
+122 => 'VarBoolFromR8', 123 => 'VarBoolFromDate', 124 => 'VarBoolFromCy', 125 => 'VarBoolFromStr',
+126 => 'VarBoolFromDisp', 127 => 'VarFormatCurrency', 128 => 'VarWeekdayName', 129 => 'VarMonthName',
+130 => 'VarUI1FromI2', 131 => 'VarUI1FromI4', 132 => 'VarUI1FromR4', 133 => 'VarUI1FromR8',
+134 => 'VarUI1FromCy', 135 => 'VarUI1FromDate', 136 => 'VarUI1FromStr', 137 => 'VarUI1FromDisp',
+138 => 'VarUI1FromBool', 139 => 'VarFormatFromTokens', 140 => 'VarTokenizeFormatString', 141 => 'VarAdd',
+142 => 'VarAnd', 143 => 'VarDiv', 144 => 'DllCanUnloadNow', 145 => 'DllGetClassObject',
+146 => 'DispCallFunc', 147 => 'VariantChangeTypeEx', 148 => 'SafeArrayPtrOfIndex', 149 => 'SysStringByteLen',
+150 => 'SysAllocStringByteLen', 151 => 'DllRegisterServer', 152 => 'VarEqv', 153 => 'VarIdiv',
+154 => 'VarImp', 155 => 'VarMod', 156 => 'VarMul', 157 => 'VarOr',
+158 => 'VarPow', 159 => 'VarSub', 160 => 'CreateTypeLib', 161 => 'LoadTypeLib',
+162 => 'LoadRegTypeLib', 163 => 'RegisterTypeLib', 164 => 'QueryPathOfRegTypeLib', 165 => 'LHashValOfNameSys',
+166 => 'LHashValOfNameSysA', 167 => 'VarXor', 168 => 'VarAbs', 169 => 'VarFix',
+170 => 'OaBuildVersion', 171 => 'ClearCustData', 172 => 'VarInt', 173 => 'VarNeg',
+174 => 'VarNot', 175 => 'VarRound', 176 => 'VarCmp', 177 => 'VarDecAdd',
+178 => 'VarDecDiv', 179 => 'VarDecMul', 180 => 'CreateTypeLib2', 181 => 'VarDecSub',
+182 => 'VarDecAbs', 183 => 'LoadTypeLibEx', 184 => 'SystemTimeToVariantTime', 185 => 'VariantTimeToSystemTime',
+186 => 'UnRegisterTypeLib', 187 => 'VarDecFix', 188 => 'VarDecInt', 189 => 'VarDecNeg',
+190 => 'VarDecFromUI1', 191 => 'VarDecFromI2', 192 => 'VarDecFromI4', 193 => 'VarDecFromR4',
+194 => 'VarDecFromR8', 195 => 'VarDecFromDate', 196 => 'VarDecFromCy', 197 => 'VarDecFromStr',
+198 => 'VarDecFromDisp', 199 => 'VarDecFromBool', 200 => 'GetErrorInfo', 201 => 'SetErrorInfo',
+202 => 'CreateErrorInfo', 203 => 'VarDecRound', 204 => 'VarDecCmp', 205 => 'VarI2FromI1',
+206 => 'VarI2FromUI2', 207 => 'VarI2FromUI4', 208 => 'VarI2FromDec', 209 => 'VarI4FromI1',
+210 => 'VarI4FromUI2', 211 => 'VarI4FromUI4', 212 => 'VarI4FromDec', 213 => 'VarR4FromI1',
+214 => 'VarR4FromUI2', 215 => 'VarR4FromUI4', 216 => 'VarR4FromDec', 217 => 'VarR8FromI1',
+218 => 'VarR8FromUI2', 219 => 'VarR8FromUI4', 220 => 'VarR8FromDec', 221 => 'VarDateFromI1',
+222 => 'VarDateFromUI2', 223 => 'VarDateFromUI4', 224 => 'VarDateFromDec', 225 => 'VarCyFromI1',
+226 => 'VarCyFromUI2', 227 => 'VarCyFromUI4', 228 => 'VarCyFromDec', 229 => 'VarBstrFromI1',
+230 => 'VarBstrFromUI2', 231 => 'VarBstrFromUI4', 232 => 'VarBstrFromDec', 233 => 'VarBoolFromI1',
+234 => 'VarBoolFromUI2', 235 => 'VarBoolFromUI4', 236 => 'VarBoolFromDec', 237 => 'VarUI1FromI1',
+238 => 'VarUI1FromUI2', 239 => 'VarUI1FromUI4', 240 => 'VarUI1FromDec', 241 => 'VarDecFromI1',
+242 => 'VarDecFromUI2', 243 => 'VarDecFromUI4', 244 => 'VarI1FromUI1', 245 => 'VarI1FromI2',
+246 => 'VarI1FromI4', 247 => 'VarI1FromR4', 248 => 'VarI1FromR8', 249 => 'VarI1FromDate',
+250 => 'VarI1FromCy', 251 => 'VarI1FromStr', 252 => 'VarI1FromDisp', 253 => 'VarI1FromBool',
+254 => 'VarI1FromUI2', 255 => 'VarI1FromUI4', 256 => 'VarI1FromDec', 257 => 'VarUI2FromUI1',
+258 => 'VarUI2FromI2', 259 => 'VarUI2FromI4', 260 => 'VarUI2FromR4', 261 => 'VarUI2FromR8',
+262 => 'VarUI2FromDate', 263 => 'VarUI2FromCy', 264 => 'VarUI2FromStr', 265 => 'VarUI2FromDisp',
+266 => 'VarUI2FromBool', 267 => 'VarUI2FromI1', 268 => 'VarUI2FromUI4', 269 => 'VarUI2FromDec',
+270 => 'VarUI4FromUI1', 271 => 'VarUI4FromI2', 272 => 'VarUI4FromI4', 273 => 'VarUI4FromR4',
+274 => 'VarUI4FromR8', 275 => 'VarUI4FromDate', 276 => 'VarUI4FromCy', 277 => 'VarUI4FromStr',
+278 => 'VarUI4FromDisp', 279 => 'VarUI4FromBool', 280 => 'VarUI4FromI1', 281 => 'VarUI4FromUI2',
+282 => 'VarUI4FromDec', 283 => 'BSTR_UserSize', 284 => 'BSTR_UserMarshal', 285 => 'BSTR_UserUnmarshal',
+286 => 'BSTR_UserFree', 287 => 'VARIANT_UserSize', 288 => 'VARIANT_UserMarshal', 289 => 'VARIANT_UserUnmarshal',
+290 => 'VARIANT_UserFree', 291 => 'LPSAFEARRAY_UserSize', 292 => 'LPSAFEARRAY_UserMarshal', 293 => 'LPSAFEARRAY_UserUnmarshal',
+294 => 'LPSAFEARRAY_UserFree', 295 => 'LPSAFEARRAY_Size', 296 => 'LPSAFEARRAY_Marshal', 297 => 'LPSAFEARRAY_Unmarshal',
+298 => 'VarDecCmpR8', 299 => 'VarCyAdd', 300 => 'DllUnregisterServer', 301 => 'OACreateTypeLib2',
+303 => 'VarCyMul', 304 => 'VarCyMulI4', 305 => 'VarCySub', 306 => 'VarCyAbs',
+307 => 'VarCyFix', 308 => 'VarCyInt', 309 => 'VarCyNeg', 310 => 'VarCyRound',
+311 => 'VarCyCmp', 312 => 'VarCyCmpR8', 313 => 'VarBstrCat', 314 => 'VarBstrCmp',
+315 => 'VarR8Pow', 316 => 'VarR4CmpR8', 317 => 'VarR8Round', 318 => 'VarCat',
+319 => 'VarDateFromUdateEx', 322 => 'GetRecordInfoFromGuids', 323 => 'GetRecordInfoFromTypeInfo', 325 => 'SetVarConversionLocaleSetting',
+326 => 'GetVarConversionLocaleSetting', 327 => 'SetOaNoCache', 329 => 'VarCyMulI8', 330 => 'VarDateFromUdate',
+331 => 'VarUdateFromDate', 332 => 'GetAltMonthNames', 333 => 'VarI8FromUI1', 334 => 'VarI8FromI2',
+335 => 'VarI8FromR4', 336 => 'VarI8FromR8', 337 => 'VarI8FromCy', 338 => 'VarI8FromDate',
+339 => 'VarI8FromStr', 340 => 'VarI8FromDisp', 341 => 'VarI8FromBool', 342 => 'VarI8FromI1',
+343 => 'VarI8FromUI2', 344 => 'VarI8FromUI4', 345 => 'VarI8FromDec', 346 => 'VarI2FromI8',
+347 => 'VarI2FromUI8', 348 => 'VarI4FromI8', 349 => 'VarI4FromUI8', 360 => 'VarR4FromI8',
+361 => 'VarR4FromUI8', 362 => 'VarR8FromI8', 363 => 'VarR8FromUI8', 364 => 'VarDateFromI8',
+365 => 'VarDateFromUI8', 366 => 'VarCyFromI8', 367 => 'VarCyFromUI8', 368 => 'VarBstrFromI8',
+369 => 'VarBstrFromUI8', 370 => 'VarBoolFromI8', 371 => 'VarBoolFromUI8', 372 => 'VarUI1FromI8',
+373 => 'VarUI1FromUI8', 374 => 'VarDecFromI8', 375 => 'VarDecFromUI8', 376 => 'VarI1FromI8',
+377 => 'VarI1FromUI8', 378 => 'VarUI2FromI8', 379 => 'VarUI2FromUI8', 401 => 'OleLoadPictureEx',
+402 => 'OleLoadPictureFileEx', 411 => 'SafeArrayCreateVector', 412 => 'SafeArrayCopyData', 413 => 'VectorFromBstr',
+414 => 'BstrFromVector', 415 => 'OleIconToCursor', 416 => 'OleCreatePropertyFrameIndirect', 417 => 'OleCreatePropertyFrame',
+418 => 'OleLoadPicture', 419 => 'OleCreatePictureIndirect', 420 => 'OleCreateFontIndirect', 421 => 'OleTranslateColor',
+422 => 'OleLoadPictureFile', 423 => 'OleSavePictureFile', 424 => 'OleLoadPicturePath', 425 => 'VarUI4FromI8',
+426 => 'VarUI4FromUI8', 427 => 'VarI8FromUI8', 428 => 'VarUI8FromI8', 429 => 'VarUI8FromUI1',
+430 => 'VarUI8FromI2', 431 => 'VarUI8FromR4', 432 => 'VarUI8FromR8', 433 => 'VarUI8FromCy',
+434 => 'VarUI8FromDate', 435 => 'VarUI8FromStr', 436 => 'VarUI8FromDisp', 437 => 'VarUI8FromBool',
+438 => 'VarUI8FromI1', 439 => 'VarUI8FromUI2', 440 => 'VarUI8FromUI4', 441 => 'VarUI8FromDec',
+442 => 'RegisterTypeLibForUser', 443 => 'UnRegisterTypeLibForUser',
+		},
+	}
 end
 end
 

data/{lib/metasm → metasm}/parse.rb

@@ -159,13 +159,20 @@ class AsmPreprocessor < Preprocessor
 		end
 	end
 
+	class Preprocessor::Token
+		# token already preprocessed for macro def/expansion
+		attr_accessor :alreadyapp
+	end
+
 	# the program (used to create new label names)
 	attr_accessor :program
 	# hash macro name => Macro
 	attr_accessor :macro
+	attr_accessor :may_apreprocess
 
 	def initialize(text='', program=nil)
 		@program = program
+		@may_apreprocess = false
 		@macro = {}
 		super(text)
 	end
@@ -184,13 +191,21 @@ class AsmPreprocessor < Preprocessor
 		t
 	end
 
-	# reads a token, handles macros/comments/integers/etc
-	# argument is for internal use
-	def readtok(rec = false)
+	def feed!(*a)
+		super(*a)
+		if not @may_apreprocess and (@text =~ / (macro|equ) / or not @macro.empty?)
+			@may_apreprocess = true
+		end
+		self
+	end
+
+	# reads a token, handles macros/comments/etc
+	def readtok
 		tok = super()
+		return tok if not tok or tok.alreadyapp
 
 		# handle ; comments
-		if tok and tok.type == :punct and tok.raw == ';'
+		if tok.type == :punct and tok.raw[0] == ?;
 			tok.type = :eol
 			begin
 				tok = tok.dup
@@ -203,30 +218,13 @@ class AsmPreprocessor < Preprocessor
 			end
 		end
 
-		# aggregate space/eol
-		if tok and (tok.type == :space or tok.type == :eol)
-			if ntok = readtok(true) and ntok.type == :space
-				tok = tok.dup
-				tok.raw << ntok.raw
-			elsif ntok and ntok.type == :eol
-				tok = tok.dup
-				tok.raw << ntok.raw
-				tok.type = :eol
-			else
-				unreadtok ntok
-			end
-		end
-
-
 		# handle macros
-		# the rec parameter is used to avoid reading the whole text at once when reading ahead to check 'macro' keyword
-		if not rec and tok and tok.type == :string
+		if @may_apreprocess and tok.type == :string
 			if @macro[tok.raw]
 				@macro[tok.raw].apply(tok, self, @program).reverse_each { |t| unreadtok t }
 				tok = readtok
-
 			else
-				if ntok = readtok(true) and ntok.type == :space and nntok = readtok(true) and nntok.type == :string and (nntok.raw == 'macro' or nntok.raw == 'equ')
+				if ntok = super() and ntok.type == :space and nntok = super() and nntok.type == :string and (nntok.raw == 'macro' or nntok.raw == 'equ')
 					puts "W: asm: redefinition of macro #{tok.raw} at #{tok.backtrace_str}, previous definition at #{@macro[tok.raw].name.backtrace_str}" if @macro[tok.raw]
 					m = Macro.new tok
 					# XXX this allows nested macro definition..
@@ -252,6 +250,7 @@ class AsmPreprocessor < Preprocessor
 			end
 		end
 
+		tok.alreadyapp = true if tok
 		tok
 	end
 end
@@ -314,6 +313,7 @@ class ExeFormat
 						lname = @locallabels_bkw[tok.raw] = @locallabels_fwd.delete(tok.raw) || new_label('local_'+tok.raw)
 					else
 						lname = tok.raw
+						raise tok, "invalid label name: #{lname.inspect} is reserved" if @cpu.check_reserved_name(lname)
 						raise tok, "label redefinition" if new_label(lname) != lname
 					end
 					l = Label.new(lname)
@@ -780,7 +780,7 @@ class Expression
 			pp = Preprocessor.new(str)
 
 			e = parse(pp, &b)
-			
+
 			# update arg
 			len = pp.pos
 			pp.queue.each { |t| len -= t.raw.length }
@@ -821,6 +821,8 @@ class IndExpression < Expression
 					break
 				when ':'	# symbols, eg ':eax'
 					n = lexer.readtok
+					nil while tok = lexer.readtok and tok.type == :space
+					lexer.unreadtok tok
 					return n.raw.to_sym
 				else
 					lexer.unreadtok tok

data/{lib/metasm → metasm}/parse_c.rb

@@ -249,7 +249,7 @@ module C
 		end
 
 		def findmember(name, igncase=false)
-			raise parser, 'undefined structure' if not @members
+			raise 'undefined structure' if not members
 			return @fldlist[name] if fldlist and @fldlist[name]
 
 			name = name.downcase if igncase
@@ -267,7 +267,7 @@ module C
 		end
 
 		def offsetof(parser, name)
-			raise parser, 'undefined structure' if not @members
+			raise parser, 'undefined structure' if not members
 			update_member_cache(parser) if not fldlist
 			return 0 if @fldlist[name]
 
@@ -284,7 +284,7 @@ module C
 		end
 
 		def bitoffsetof(parser, name)
-			raise parser, 'undefined structure' if not @members
+			raise parser, 'undefined structure' if not members
 			update_member_cache(parser) if not fldlist
 			return if @fldlist[name] or @members.include?(name)
 			raise parser, 'undefined union' if not @members
@@ -390,6 +390,22 @@ module C
 			end
 			idx + 1
 		end
+
+		# resolve structptr + offset into 'str.membername'
+		# handles 'var.substruct1.array[12].foo'
+		# updates str
+		# returns the final member type itself
+		# works for Struct/Union/Array
+		def expand_member_offset(c_parser, off, str)
+			# XXX choose in members, check sizeof / prefer structs
+			m = @members.first
+			str << '.' << m.name if m.name
+			if m.type.respond_to?(:expand_member_offset)
+				m.type.expand_member_offset(c_parser, off, str)
+			else
+				m.type
+			end
+		end
 	end
 	class Struct < Union
 		attr_accessor :pack
@@ -397,9 +413,10 @@ module C
 		def align(parser) [@members.to_a.map { |m| m.type.align(parser) }.max || 1, (pack || 8)].min end
 
 		def offsetof(parser, name)
-			raise parser, 'undefined structure' if not @members
+			raise parser, 'undefined structure' if not members
 			update_member_cache(parser) if not fldlist
 			return @fldoffset[name] if @fldoffset[name]
+			return @fldoffset[name.name] if name.respond_to?(:name) and @fldoffset[name.name]
 
 			# this is almost never reached, only for <struct>.offsetof(anonymoussubstructmembername)
 			raise parser, 'unknown structure member' if (name.kind_of?(::String) ?  !findmember(name) : !@members.include?(name))
@@ -433,7 +450,7 @@ module C
 					end
 					mal = [m.type.align(parser), al].min
 					off = (off + mal - 1) / mal * mal
-				       	if m.name == name or m == name
+					if m.name == name or m == name
 						break
 					elsif indirect and m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
 						off += m.type.untypedef.offsetof(parser, name)
@@ -449,18 +466,28 @@ module C
 		# returns the [bitoffset, bitlength] of the field if it is a bitfield
 		# this should be added to the offsetof(field)
 		def bitoffsetof(parser, name)
-			raise parser, 'undefined structure' if not @members
+			raise parser, 'undefined structure' if not members
 			update_member_cache(parser) if not fldlist
 			return @fldbitoffset[name] if fldbitoffset and @fldbitoffset[name]
+			return @fldbitoffset[name.name] if fldbitoffset and name.respond_to?(:name) and @fldbitoffset[name.name]
 			return if @fldlist[name] or @members.include?(name)
 			raise parser, 'undefined union' if not @members
 			raise parser, 'unknown union member' if not findmember(name)
 
 			@members.find { |m|
-				m.type.untypedef.kind_of? Union and m.type.untypedef.findmember(name)
+				m.type.untypedef.kind_of?(Union) and m.type.untypedef.findmember(name)
 			}.type.untypedef.bitoffsetof(parser, name)
 		end
 
+		# returns the @member element that has offsetof(m) == off
+		def findmember_atoffset(parser, off)
+			return if not members
+			update_member_cache(parser) if not fldlist
+			if m = @fldoffset.index(off)
+				@fldlist[m]
+			end
+		end
+
 		def parse_members(parser, scope)
 			super(parser, scope)
 
@@ -515,6 +542,32 @@ module C
 				end
 			}
 		end
+
+		# see Union#expand_member_offset
+		def expand_member_offset(c_parser, off, str)
+			members.to_a.each { |m|
+				mo = offsetof(c_parser, m)
+				if mo == off or mo + c_parser.sizeof(m) > off
+					if bitoffsetof(c_parser, m)
+						# ignore bitfields
+						str << "+#{off}" if off > 0
+						return self
+					end
+
+					str << '.' << m.name if m.name
+					if m.type.respond_to?(:expand_member_offset)
+						return m.type.expand_member_offset(c_parser, off-mo, str)
+					else
+						return m.type
+					end
+				elsif mo > off
+					break
+				end
+			}
+			# XXX that works only for pointer-style str
+			str << "+#{off}" if off > 0
+			nil
+		end
 	end
 	class Enum < Type
 		# name => value
@@ -557,6 +610,11 @@ module C
 			parse_attributes(parser)
 		end
 
+		def compare_deep(o)
+			return true if o.object_id == self.object_id
+			return if o.class != self.class or o.name != self.name or o.attributes != self.attributes
+			members == o.members
+		end
 	end
 	class Pointer < Type
 		attr_accessor :type
@@ -684,6 +742,17 @@ module C
 			end
 			idx + 1
 		end
+
+		# see Union#expand_member_offset
+		def expand_member_offset(c_parser, off, str)
+			tsz = c_parser.sizeof(@type)
+			str << "[#{off/tsz}]"
+			if @type.respond_to?(:expand_member_offset)
+				@type.expand_member_offset(c_parser, off%tsz, str)
+			else
+				@type
+			end
+		end
 	end
 
 	class Variable
@@ -880,7 +949,7 @@ module C
 						when :space; body << ' '
 						when :eol; body << "\n"
 						when :punct; body << tok.raw
-						when :quoted; body << tok.value.inspect	# concat adjacent c strings
+						when :quoted; body << CExpression.string_inspect(tok.value)	# concat adjacent c strings
 						when :string
 							body << \
 							case tok.raw
@@ -923,7 +992,7 @@ module C
 								break
 							else body << tok.raw
 							end
-						when :quoted; body << (body.empty? ? tok.value : tok.value.inspect)	# asm "pop\nret"  VS  asm add al, 'z'
+						when :quoted; body << (body.empty? ? tok.value : CExpression.string_inspect(tok.value))	# asm "pop\nret"  VS  asm add al, 'z'
 						when :string
 							body << \
 							case tok.raw
@@ -997,7 +1066,7 @@ module C
 			raise "invalid CExpr #{[l, o, r, t].inspect}" if (o and not o.kind_of? ::Symbol) or not t.kind_of? Type
 			@lexpr, @op, @rexpr, @type = l, o, r, t
 		end
-		
+
 		# overwrites @lexpr @op @rexpr @type from the arg
 		def replace(o)
 			@lexpr, @op, @rexpr, @type = o.lexpr, o.op, o.rexpr, o.type
@@ -1033,7 +1102,7 @@ module C
 				else
 					x2 = splat[args[2]]
 				end
- 				new(splat[args[0]], op, x2, args[3])
+				new(splat[args[0]], op, x2, args[3])
 			when 3
 				op = args[1]
 				x1 = splat[args[0]]
@@ -1047,7 +1116,7 @@ module C
 				when :funcall
 				       rt = x1.type.untypedef
 				       rt = rt.type.untypedef if rt.pointer?
-			       	       new(x1, op, x2, rt.type)
+				       new(x1, op, x2, rt.type)
 				when :[]; new(x1, op, x2, x1.type.untypedef.type)
 				when :+; new(x1, op, x2, (x2.type.pointer? ? x2.type : x1.type))
 				when :-; new(x1, op, x2, ((x1.type.pointer? and x2.type.pointer?) ? BaseType.new(:int) : x2.type.pointer? ? x2.type : x1.type))
@@ -1111,13 +1180,14 @@ module C
 		attr_accessor :lexer, :toplevel, :typesize, :pragma_pack
 		attr_accessor :endianness
 		attr_accessor :allow_bad_c
+		attr_accessor :program
 		# allowed arguments: ExeFormat, CPU, Preprocessor, Symbol (for the data model)
 		def initialize(*args)
 			model = args.grep(Symbol).first || :ilp32
 			lexer = args.grep(Preprocessor).first || Preprocessor.new
-			exe = args.grep(ExeFormat).first
+			@program = args.grep(ExeFormat).first
 			cpu = args.grep(CPU).first
-			cpu ||= exe.cpu if exe
+			cpu ||= @program.cpu if @program
 			@lexer = lexer
 			@prev_pragma_callback = @lexer.pragma_callback
 			@lexer.pragma_callback = lambda { |tok| parse_pragma_callback(tok) }
@@ -1128,7 +1198,7 @@ module C
 				:char => 1, :float => 4, :double => 8, :longdouble => 12 }
 			send model
 			cpu.tune_cparser(self) if cpu
-			exe.tune_cparser(self) if exe
+			@program.tune_cparser(self) if @program
 		end
 
 		def ilp16
@@ -1513,6 +1583,7 @@ EOH
 			when Struct
 				raise self, "unknown structure size #{type.name}" if not type.members
 				al = type.align(self)
+				al = 1 if (var.kind_of?(Attributes) and var.has_attribute('sizeof_packed')) or type.has_attribute('sizeof_packed')
 				lm = type.members.last
 				lm ? (type.offsetof(self, lm) + sizeof(lm) + al - 1) / al * al : 0
 			when Union
@@ -1703,6 +1774,7 @@ EOH
 				Goto.new name
 			when 'return'
 				expr = CExpression.parse(self, scope)	# nil allowed
+				raise tok || self, "cannot return #{expr} in function returning void" if expr and nest[0].kind_of?(Type) and nest[0].void?
 				p, i = nest[0].pointer?, nest[0].integral? if expr
 				r = expr.reduce(self) if p or i
 				if (not p and not i) or (i and not r.kind_of? ::Integer) or (p and r != 0)
@@ -1770,6 +1842,7 @@ EOH
 		end
 
 		# returns all numeric constants defined with their value, either macros or enums
+		# for enums, also return the enum name
 		def numeric_constants
 			ret = []
 			# macros
@@ -1779,8 +1852,17 @@ EOH
 				end
 			}
 			# enums
+			seen_enum = {}
+			@toplevel.struct.each { |k, v|
+				if v.kind_of?(Enum)
+					v.members.each { |kk, vv|
+						ret << [kk, vv, k]
+						seen_enum[kk] = true
+					}
+				end
+			}
 			@toplevel.symbol.each { |k, v|
-				ret << [k, v] if v.kind_of? ::Numeric
+				ret << [k, v] if v.kind_of?(::Numeric) and not seen_enum[k]
 			}
 			ret
 		end
@@ -1933,7 +2015,10 @@ EOH
 			name = :int
 			tok = nil
 			loop do
-				raise parser if not tok = parser.skipspaces
+				if not tok = parser.skipspaces
+					raise parser if specifier.empty?
+					break
+				end
 				if tok.type != :string
 					parser.unreadtok tok
 					break
@@ -2239,12 +2324,13 @@ EOH
 				else
 					l = CExpression.new(nil, nil, l, BaseType.new(:int)) if l.kind_of? ::Integer
 					r = CExpression.new(nil, nil, r, BaseType.new(:int)) if r.kind_of? ::Integer
-				       	CExpression.new(l, @op, r, @type)
+					CExpression.new(l, @op, r, @type)
 				end
 			when :'.'
 				le = CExpression.reduce(parser, @lexpr)
 				if le.kind_of? Variable and le.initializer.kind_of? ::Array
-					midx = le.type.members.index(le.type.findmember(@rexpr))
+					t = le.type.untypedef
+					midx = t.members.index(t.findmember(@rexpr))
 					CExpression.reduce(parser, le.initializer[midx] || 0)
 				else
 					CExpression.new(le, @op, @rexpr, @type)
@@ -2282,7 +2368,7 @@ EOH
 					end
 				else
 					l = CExpression.reduce(parser, @lexpr)
-				       	if not l.kind_of?(::Numeric) or not r.kind_of?(::Numeric)
+					if not l.kind_of?(::Numeric) or not r.kind_of?(::Numeric)
 						l = CExpression.new(nil, nil, l, BaseType.new(:int)) if l.kind_of? ::Integer
 						r = CExpression.new(nil, nil, r, BaseType.new(:int)) if r.kind_of? ::Integer
 						return CExpression.new(l, @op, r, @type)
@@ -2325,7 +2411,7 @@ EOH
 			o.object_id == self.object_id or
 			(self.class == o.class and op == o.op and lexpr == o.lexpr and rexpr == o.rexpr)
 		end
-	
+
 		def ===(o)
 			(self.class == o.class and op == o.op and lexpr === o.lexpr and rexpr === o.rexpr) or
 			(o.class == Variable and not @op and @rexpr == o)
@@ -2506,6 +2592,7 @@ EOH
 						type = :long if suffix.count('l') == 1
 					end
 					val = CExpression[val, BaseType.new(type, *specifier)]
+					val = parse_value_postfix(parser, scope, val)
 				else raise parser, "internal error #{val.inspect}"
 				end
 
@@ -2513,6 +2600,7 @@ EOH
 				if tok.raw[0] == ?'
 					raise tok, 'invalid character constant' if not [1, 2, 4, 8].include? tok.value.length	# TODO 0fill
 					val = CExpression[Expression.decode_imm(tok.value, tok.value.length, :big), BaseType.new(:int)]
+					val = parse_value_postfix(parser, scope, val)
 				else
 					val = CExpression[tok.value, Pointer.new(BaseType.new(tok.raw[0, 2] == 'L"' ? :short : :char))]
 					val = parse_value_postfix(parser, scope, val)
@@ -2712,96 +2800,109 @@ EOH
 			end
 		end
 
-		def parse(parser, scope, allow_coma = true)
-			opstack = []
-			stack = []
-
-			popstack = lambda {
-				r, l = stack.pop, stack.pop
-				case op = opstack.pop
-				when :'?:'
-					stack << CExpression.new(stack.pop, op, [l, r], l.type)
-				when :','
-					stack << CExpression.new(l, op, r, r.type)
-				when :'='
+		def parse_popstack(parser, stack, opstack)
+			r = stack.pop
+			l = stack.pop
+			case op = opstack.pop
+			when :'?:'
+				stack << CExpression.new(stack.pop, op, [l, r], l.type)
+			when :','
+				stack << CExpression.new(l, op, r, r.type)
+			when :'='
+				unless r.kind_of?(CExpression) and not r.lexpr and r.type.kind_of?(BaseType) and
+				    ((not r.op and r.rexpr.kind_of?(Integer)) or
+				     (r.op == :- and r.rexpr.kind_of?(CExpression) and not r.rexpr.op and not r.rexpr.lexpr and r.rexpr.rexpr.kind_of?(Integer))) and
+				     l.kind_of?(Typed) and (l.type.untypedef.kind_of?(BaseType) or (l.type.untypedef.kind_of?(Pointer) and r.rexpr == 0))
+					# avoid useless warnings on unsigned foo = -1  /  void *foo = 0
 					parser.check_compatible_type(parser, r.type, l.type)
-					stack << CExpression.new(l, op, r, l.type)
-				when :'&&', :'||'
-					stack << CExpression.new(l, op, r, BaseType.new(:int))
+				end
+				if l.kind_of?(Typed) and (lt = l.type.untypedef).kind_of?(BaseType) and r.kind_of?(Typed) and (rt = r.type.untypedef).kind_of?(BaseType) and lt.specifier != :unsigned and rt.specifier == :unsigned and parser.typesize[lt.name] > parser.typesize[rt.name]
+					# (int32)i = (uchar)255 => 255, not -1
+					r = CExpression.new(nil, nil, r, BaseType.new(lt.name, :unsigned))
+				end
+				stack << CExpression.new(l, op, r, l.type)
+			when :'&&', :'||'
+				stack << CExpression.new(l, op, r, BaseType.new(:int))
+			else
+				# XXX struct == struct ?
+				raise parser, "invalid type #{l.type} #{l} for #{op.inspect}" if not l.type.arithmetic? and not parser.allow_bad_c
+				raise parser, "invalid type #{r.type} #{r} for #{op.inspect}" if not r.type.arithmetic? and not parser.allow_bad_c
+
+				if l.type.pointer? and r.type.pointer?
+					type = \
+					case op
+					when :'-'; BaseType.new(:long)	# addr_t or sumthin ?
+					when :'-='; l.type
+					when :'>', :'>=', :'<', :'<=', :'==', :'!='; BaseType.new(:long)
+					else raise parser, "cannot do #{op.inspect} on pointers" unless parser.allow_bad_c ; l.type
+					end
+				elsif l.type.pointer? or r.type.pointer?
+					puts parser.exception("should not #{op.inspect} a pointer").message if $VERBOSE and not [:'+', :'-', :'=', :'+=', :'-=', :==, :'!='].include? op
+					type = l.type.pointer? ? l.type : r.type
+				elsif RIGHTASSOC[op] and op != :'?:'	# += etc
+					type = l.type
 				else
-					# XXX struct == struct ?
-					raise parser, "invalid type #{l.type} #{l} for #{op.inspect}" if not l.type.arithmetic? and not parser.allow_bad_c
-					raise parser, "invalid type #{r.type} #{r} for #{op.inspect}" if not r.type.arithmetic? and not parser.allow_bad_c
-
-					if l.type.pointer? and r.type.pointer?
-						type = \
-						case op
-						when :'-'; BaseType.new(:long)	# addr_t or sumthin ?
-						when :'-='; l.type
-						when :'>', :'>=', :'<', :'<=', :'==', :'!='; BaseType.new(:long)
-						else raise parser, "cannot do #{op.inspect} on pointers" unless parser.allow_bad_c ; l.type
-						end
-					elsif l.type.pointer? or r.type.pointer?
-						puts parser.exception("should not #{op.inspect} a pointer").message if $VERBOSE and not [:'+', :'-', :'=', :'+=', :'-=', :==, :'!='].include? op
-						type = l.type.pointer? ? l.type : r.type
-					else
-						# yay integer promotion
-						lt = l.type.untypedef
-						rt = r.type.untypedef
-						if    (t = lt).name == :longdouble or (t = rt).name == :longdouble or
-						      (t = lt).name == :double or (t = rt).name == :double or
-						      (t = lt).name == :float or (t = rt).name == :float
-						# long double > double > float ...
-							type = t
-						elsif true
-							# custom integer rules based on type sizes
-							lts = parser.typesize[lt.name]
-							rts = parser.typesize[rt.name]
-							its = parser.typesize[:int]
-							if not lts or not rts
-								type = BaseType.new(:int)
-							elsif lts >  rts and lts >= its
-								type = lt
-							elsif rts >  lts and rts >= its
-								type = rt
-							elsif lts == rts and lts >= its
-								type = lt
-								type = rt if rt.specifier == :unsigned
-							else
-								type = BaseType.new(:int)
-							end
-							# end of custom rules
-						elsif ((t = lt).name == :long and t.specifier == :unsigned) or
-						      ((t = rt).name == :long and t.specifier == :unsigned)
-						# ... ulong ...
-							type = t
-						elsif (lt.name == :long and rt.name == :int and rt.specifier == :unsigned) or
-						      (rt.name == :long and lt.name == :int and lt.specifier == :unsigned)
-						# long+uint => ulong
-							type = BaseType.new(:long, :unsigned)
-						elsif (t = lt).name == :long or (t = rt).name == :long or
-						      ((t = lt).name == :int and t.specifier == :unsigned) or
-						      ((t = rt).name == :int and t.specifier == :unsigned)
-						# ... long > uint ...
-							type = t
+					# yay integer promotion
+					lt = l.type.untypedef
+					rt = r.type.untypedef
+					if    (t = lt).name == :longdouble or (t = rt).name == :longdouble or
+					      (t = lt).name == :double or (t = rt).name == :double or
+					      (t = lt).name == :float or (t = rt).name == :float
+					# long double > double > float ...
+						type = t
+					elsif true
+						# custom integer rules based on type sizes
+						lts = parser.typesize[lt.name]
+						rts = parser.typesize[rt.name]
+						its = parser.typesize[:int]
+						if not lts or not rts
+							type = BaseType.new(:int)
+						elsif lts >  rts and lts >= its
+							type = lt
+						elsif rts >  lts and rts >= its
+							type = rt
+						elsif lts == rts and lts >= its
+							type = lt
+							type = rt if rt.specifier == :unsigned
 						else
-						# int
 							type = BaseType.new(:int)
 						end
-					end
-
-					case op
-					when :'>', :'>=', :'<', :'<=', :'==', :'!='
-						# cast both sides
-						l = CExpression[l, type] if l.type != type
-						r = CExpression[r, type] if r.type != type
-						stack << CExpression.new(l, op, r, BaseType.new(:int))
+						# end of custom rules
+					elsif ((t = lt).name == :long and t.specifier == :unsigned) or
+					      ((t = rt).name == :long and t.specifier == :unsigned)
+					# ... ulong ...
+						type = t
+					elsif (lt.name == :long and rt.name == :int and rt.specifier == :unsigned) or
+					      (rt.name == :long and lt.name == :int and lt.specifier == :unsigned)
+					# long+uint => ulong
+						type = BaseType.new(:long, :unsigned)
+					elsif (t = lt).name == :long or (t = rt).name == :long or
+					      ((t = lt).name == :int and t.specifier == :unsigned) or
+					      ((t = rt).name == :int and t.specifier == :unsigned)
+					# ... long > uint ...
+						type = t
 					else
-						# promote result
-						stack << CExpression.new(l, op, r, type)
+					# int
+						type = BaseType.new(:int)
 					end
 				end
-			}
+
+				case op
+				when :'>', :'>=', :'<', :'<=', :'==', :'!='
+					# cast both sides
+					l = CExpression[l, type] if l.type != type
+					r = CExpression[r, type] if r.type != type
+					stack << CExpression.new(l, op, r, BaseType.new(:int))
+				else
+					# promote result
+					stack << CExpression.new(l, op, r, type)
+				end
+			end
+		end
+
+		def parse(parser, scope, allow_coma = true)
+			opstack = []
+			stack = []
 
 			return if not e = parse_value(parser, scope)
 
@@ -2812,7 +2913,7 @@ EOH
 				when :'?'
 					# a, b ? c, d : e, f  ==  a, (b ? (c, d) : e), f
 					until opstack.empty? or OP_PRIO[opstack.last][:'?:']
-						popstack[]
+						parse_popstack(parser, stack, opstack)
 					end
 					stack << parse(parser, scope)
 					raise op || parser, '":" expected' if not op = readop(parser) or op.value != :':'
@@ -2827,7 +2928,7 @@ EOH
 						break
 					end
 					until opstack.empty? or OP_PRIO[op.value][opstack.last]
-						popstack[]
+						parse_popstack(parser, stack, opstack)
 					end
 				end
 
@@ -2837,7 +2938,7 @@ EOH
 			end
 
 			until opstack.empty?
-				popstack[]
+				parse_popstack(parser, stack, opstack)
 			end
 
 			CExpression[stack.first]
@@ -2929,8 +3030,9 @@ EOH
 			end
 
 			a, val = a
-			raise "#{a.inspect} not a struct member" if not a.kind_of? C::Variable and not f = @struct.findmember(a.to_s, true)
-			a = f.name if a.kind_of? String or a.kind_of? Symbol
+			f = a
+			raise "#{a.inspect} not a struct member" if not f.kind_of? C::Variable and not f = @struct.findmember(a.to_s, true)
+			a = f.name || f
 			val = sizeof if val == :size
 			off = @stroff + @struct.offsetof(@cp, a)
 
@@ -2972,7 +3074,6 @@ EOH
 				str.last << "struct #{@struct.name || '_'} x = " if not off
 				@struct.update_member_cache(@cp) if not @struct.fldlist
 				fldoff = @struct.fldoffset
-				fbo = @struct.fldbitoffset || {}
 				mlist = @struct.members.map { |m| m.name || m }
 			else
 				str.last << "union #{@struct.name || '_'} x = " if not off
@@ -3203,8 +3304,7 @@ EOH
 			all = @toplevel.struct.values + @toplevel.symbol.values
 			all -= all.grep(::Integer)	# Enum values
 
-			r, dep = @toplevel.dump_reorder(all, todo_rndr, todo_deps)
-			r.join("\n")
+			@toplevel.dump_reorder(all, todo_rndr, todo_deps)[0].join("\n")
 		end
 
 		# returns a string containing the C definition(s) of toplevel functions, with their dependencies
@@ -3783,7 +3883,7 @@ EOH
 			r.last << 'asm '
 			r.last << 'volatile ' if @volatile
 			r.last << '('
-			r.last << @body.inspect
+			r.last << CExpression.string_inspect(@body)
 			if @output or @input or @clobber
 				if @output and @output != []
 					# TODO
@@ -3801,13 +3901,18 @@ EOH
 				end
 			end
 			if @clobber and @clobber != []
-				r << (': ' << @clobber.map { |c| c.inspect }.join(', '))
+				r << (': ' << @clobber.map { |c| CExpression.string_inspect(c) }.join(', '))
 			end
 			r.last << ');'
 			[r, dep]
 		end
 	end
 	class CExpression
+		def self.string_inspect(s)
+			# keep all ascii printable except \ and "
+			'"' + s.gsub(/[^ !\x23-\x5b\x5d-\x7e]/) { |o| '\\x' + o.unpack('H*').first } + '"'
+		end
+
 		def self.dump(e, scope, r=[''], dep=[], brace = false)
 			if $DEBUG
 				brace = false
@@ -3820,7 +3925,7 @@ EOH
 			r, dep = \
 			case e
 			when ::Numeric; r.last << e.to_s ; [r, dep]
-			when ::String; r.last << e.inspect ; [r, dep]
+			when ::String; r.last << string_inspect(e) ; [r, dep]
 			when CExpression; e.dump_inner(scope, r, dep, brace)
 			when Variable; e.dump(scope, r, dep)
 			when nil; [r, dep]
@@ -3865,7 +3970,7 @@ EOH
 						end
 					when ::String
 						r.last << 'L' if @type.kind_of? Pointer and @type.type.kind_of? BaseType and @type.type.name == :short
-						r.last << @rexpr.inspect
+						r.last << CExpression.string_inspect(@rexpr)
 					when CExpression # cast
 						r, dep = @type.dump_cast(scope, r, dep)
 						r, dep = CExpression.dump(@rexpr, scope, r, dep, true)
@@ -3899,7 +4004,7 @@ EOH
 					l = lexpr.lexpr.type.pointed.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of? CExpression and lexpr.op == :'->'
 					# honor __attribute__((indexenum(enumname)))
 					if l and l.attributes and rexpr.kind_of? CExpression and not rexpr.op and rexpr.rexpr.kind_of? ::Integer and
-					       		n = l.has_attribute_var('indexenum') and enum = scope.struct_ancestors[n] and i = enum.members.index(rexpr.rexpr)
+							n = l.has_attribute_var('indexenum') and enum = scope.struct_ancestors[n] and i = enum.members.index(rexpr.rexpr)
 						r.last << i
 						dep |= [enum]
 					else