metasm 1.0.0 → 1.0.5

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

@@ -26,18 +26,10 @@ class CPU
 		while tok = lexer.readtok and parse_prefix(i, tok.raw)
 			lexer.skip_space_eol
 		end
-		return if not tok
 
-		# allow '.' in opcode name
-		tok = tok.dup
-		while ntok = lexer.nexttok and ntok.type == :punct and ntok.raw == '.'
-			tok.raw << lexer.readtok.raw
-			ntok = lexer.readtok
-			raise tok, 'invalid opcode name' if not ntok or ntok.type != :string
-			tok.raw << ntok.raw
-		end
-
-		raise tok, 'invalid opcode' if not opcode_list_byname[tok.raw]
+		lexer.unreadtok(tok)
+		tok = parse_instruction_mnemonic(lexer)
+		return if not tok
 
 		i.opname = tok.raw
 		i.backtrace = tok.backtrace
@@ -63,6 +55,23 @@ class CPU
 		i
 	end
 
+	# return a lexer token with an instruction mnemonic in #raw
+	# allows '.' in opcode name
+	# return nil at eof
+	def parse_instruction_mnemonic(lexer)
+		return if not tok = lexer.readtok
+		tok = tok.dup
+		while ntok = lexer.nexttok and ntok.type == :punct and ntok.raw == '.'
+			tok.raw << lexer.readtok.raw
+			ntok = lexer.readtok
+			raise tok, 'invalid opcode name' if not ntok or ntok.type != :string
+			tok.raw << ntok.raw
+		end
+
+		raise tok, 'invalid opcode' if not opcode_list_byname[tok.raw]
+		tok
+	end
+
 	def parse_instruction_checkproto(i)
 		opcode_list_byname[i.opname].to_a.find { |o|
 			o.args.length == i.args.length and o.args.zip(i.args).all? { |f, a| parse_arg_valid?(o, f, a) }
@@ -159,13 +168,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 +200,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 +227,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 +259,7 @@ class AsmPreprocessor < Preprocessor
 			end
 		end
 
+		tok.alreadyapp = true if tok
 		tok
 	end
 end
@@ -314,6 +322,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)
@@ -421,7 +430,7 @@ class ExeFormat
 			@cursource << Padding.new(fillwith, tok.backtrace) << Offset.new(e, tok.backtrace)
 
 		else
-			@cpu.parse_parser_instruction(self, tok)
+			@cpu.parse_parser_instruction(@lexer, tok)
 		end
 	end
 
@@ -746,6 +755,8 @@ class Expression
 
 		# for boolean operators, true is 1 (or anything != 0), false is 0
 		def parse(lexer)
+			lexer = Preprocessor.new(lexer) if lexer.kind_of?(::String)
+
 			opstack = []
 			stack = []
 
@@ -780,7 +791,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 +832,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

@@ -22,7 +22,17 @@ module C
 			__builtin_offsetof
 	].inject({}) { |h, w| h.update w => true }
 
+	module Misc
+		attr_accessor :misc
+
+		def with_misc(m)
+			@misc = m if m or misc
+			self
+		end
+	end
+
 	class Statement
+		include Misc
 	end
 
 	module Typed	# allows quick testing whether an object is an CExpr or a Variable
@@ -114,6 +124,7 @@ module C
 
 	class Type
 		include Attributes
+		include Misc
 		attr_accessor :qualifier	# const volatile
 
 		def pointer? ;    false end
@@ -249,7 +260,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 +278,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 +295,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 +401,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 +424,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 +461,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 +477,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 +553,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 +621,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,11 +753,23 @@ 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
 		include Attributes
 		include Typed
+		include Misc
 
 		attr_accessor :type
 		attr_accessor :initializer	# CExpr	/ Block (for Functions)
@@ -704,6 +785,8 @@ module C
 	# found in a block's Statements, used to know the initialization order
 	# eg { int i; i = 4; struct foo { int k; } toto = {i}; }
 	class Declaration
+		include Misc
+
 		attr_accessor :var
 		def initialize(var)
 			@var = var
@@ -877,10 +960,10 @@ module C
 						raise ftok, 'unterminated asm block' if not tok = parser.lexer.readtok
 						break if tok.type == :punct and tok.raw == '}'
 						case tok.type
-						when :space; body << ' '
-						when :eol; body << "\n"
+						when :space; body << ' ' unless body.empty?
+						when :eol; body << "\n" unless body.empty?
 						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 +1006,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
@@ -987,17 +1070,20 @@ module C
 	class CExpression < Statement
 		include Typed
 
+		AssignOp = [:'=', :'+=', :'-=', :'*=', :'/=', :'%=', :'^=', :'&=', :'|=', :'>>=', :'<<=', :'++', :'--']
+
 		# may be :,, :., :'->', :funcall (function, [arglist]), :[] (array indexing), nil (cast)
 		attr_accessor :op
 		# nil/CExpr/Variable/Label/::String( = :quoted/struct member name)/::Integer/::Float/Block
 		attr_accessor :lexpr, :rexpr
 		# a Type
 		attr_accessor :type
+
 		def initialize(l, o, r, t)
 			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
@@ -1023,7 +1109,7 @@ module C
 			# sub-arrays in args are to be passed to self.[] recursively (syntaxic sugar)
 			splat = lambda { |e| e.kind_of?(::Array) ? self[*e] : e }
 
-			args.shift while args.first == nil	# CExpr[nil, :&, bla] => CExpr[:&, bla]
+			args.shift while args.length > 0 and args.first == nil	# CExpr[nil, :&, bla] => CExpr[:&, bla]
 
 			case args.length
 			when 4
@@ -1033,7 +1119,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]]
@@ -1045,9 +1131,9 @@ module C
 
 				case op
 				when :funcall
-				       rt = x1.type.untypedef
-				       rt = rt.type.untypedef if rt.pointer?
-			       	       new(x1, op, x2, rt.type)
+					rt = x1.type.untypedef
+					rt = rt.type.untypedef if rt.pointer?
+					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 +1197,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 +1215,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 +1600,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 +1791,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 +1859,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 +1869,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 +2032,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 +2341,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 +2385,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 +2428,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 +2609,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 +2617,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 +2817,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 +2930,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 +2945,7 @@ EOH
 						break
 					end
 					until opstack.empty? or OP_PRIO[op.value][opstack.last]
-						popstack[]
+						parse_popstack(parser, stack, opstack)
 					end
 				end
 
@@ -2837,7 +2955,7 @@ EOH
 			end
 
 			until opstack.empty?
-				popstack[]
+				parse_popstack(parser, stack, opstack)
 			end
 
 			CExpression[stack.first]
@@ -2929,8 +3047,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 +3091,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
@@ -3075,7 +3193,7 @@ EOH
 		end
 
 		# parse a given String as an AllocCStruct
-		# offset is an optionnal offset from the string start
+		# offset is an optional offset from the string start
 		# modification to the structure will modify the underlying string
 		def decode_c_struct(structname, str, offset=0)
 			struct = find_c_struct(structname)
@@ -3203,8 +3321,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
@@ -3221,19 +3338,49 @@ EOH
 		end
 	end
 
+	# used to render a C to a source string, while keeping the information of which each character comes from which C object
+	class CRenderString < ::String
+		attr_accessor :my_c	# default C obj with which raw characters are associated
+		# hash offset => C::Statement, means bytes from this offset to the next entry comes from rendering this C object
+		def c_at_offset
+			@c_at_offset ||= {}
+		end
+
+		# concatenate another CRenderString: merge @c_at_offset
+		def <<(o)
+			if o.kind_of?(self.class)
+				o.c_at_offset.each { |k, v|
+					c_at_offset[length+k] ||= v
+				}
+			elsif my_c
+				c_at_offset[length] ||= my_c
+			end
+			super(o)
+		end
+
+		def initialize(*a)
+			if cs = a.grep(Statement).first
+				a -= [cs]
+				@my_c = cs
+				c_at_offset[0] = cs
+			end
+			super(*a)
+		end
+	end
+
 	class Statement
-		def self.dump(e, scope, r=[''], dep=[])
+		def self.dump(e, scope, r=[CRenderString.new], dep=[])
 			case e
 			when nil; r.last << ';'
 			when Block
 				r.last << ' ' if not r.last.empty?
 				r.last << '{'
-				tr, dep = e.dump(scope, [''], dep)
+				tr, dep = e.dump(scope, [CRenderString.new], dep)
 				tr.pop if tr.last.empty?
 				r.concat tr.map { |s| Case.dump_indent(s) }
-				(r.last[-1] == ?{ ? r.last : r) << '}'
+				(r.last[-1] == ?{ ? r.last : r) << CRenderString.new('}')
 			else
-				tr, dep = e.dump(scope, [''], dep)
+				tr, dep = e.dump(scope, [CRenderString.new], dep)
 				r.concat tr.map { |s| Case.dump_indent(s) }
 			end
 			[r, dep]
@@ -3248,7 +3395,7 @@ EOH
 		def to_s() dump(nil)[0].join("\n") end
 
 		# return array of c source lines and array of dependencies (objects)
-		def dump(scp, r=[''], dep=[])
+		def dump(scp, r=[CRenderString.new], dep=[])
 			mydefs = @symbol.values.grep(TypeDef) + @struct.values + anonymous_enums.to_a
 			todo_rndr = {}
 			todo_deps = {}
@@ -3260,7 +3407,7 @@ EOH
 			[r, dep]
 		end
 
-		def dump_reorder(mydefs, todo_rndr, todo_deps, r=[''], dep=[])
+		def dump_reorder(mydefs, todo_rndr, todo_deps, r=[CRenderString.new], dep=[])
 			val = todo_deps.values.flatten.uniq
 			dep |= val
 			dep -= mydefs | todo_deps.keys
@@ -3275,6 +3422,7 @@ EOH
 			# predeclare structs involved in cyclic dependencies
 			dep_cycle = lambda { |ary|
 				# sexyness inside (c)
+				# XXX 5 years later, i have no idea whats going on here
 				deps = todo_deps[ary.last]
 				if deps.include? ary.first; ary
 				elsif (deps-ary).find { |d| deps = dep_cycle[ary + [d]] }; deps
@@ -3284,7 +3432,7 @@ EOH
 				oldc = nil
 				while c = dep_cycle[[t]]
 					break if oldc == c
-					r << "#{t.kind_of?(Struct) ? 'struct' : 'union'} #{t.name};" if not oldc
+					r << CRenderString.new(t, "#{t.kind_of?(Struct) ? 'struct' : 'union'} #{t.name};") if not oldc
 					oldc = c
 					c.each { |s|
 						# XXX struct z { struct a* }; struct a { void (*foo)(struct z); };
@@ -3303,7 +3451,7 @@ EOH
 				end
 				todo_now.sort_by { |k| k.name || '0' }.each { |k|
 					if k.kind_of? Variable and k.type.kind_of? Function and k.initializer
-						r << ''
+						r << CRenderString.new
 						r.concat todo_rndr.delete(k)
 					else
 						r.pop if r.last == ''
@@ -3313,12 +3461,12 @@ EOH
 					todo_deps.delete k
 				}
 				todo_deps.each_key { |k| todo_deps[k] -= todo_now }
-				r << '' << '' << ''
+				r << CRenderString.new << CRenderString.new << CRenderString.new
 			end
 
 			@statements.each { |s|
-				r << '' if not r.last.empty?
-				if s.kind_of? Block
+				r << CRenderString.new if not r.last.empty?
+				if s.kind_of?(Block)
 					r, dep = Statement.dump(s, self, r, dep)
 				else
 					r, dep = s.dump(self, r, dep)
@@ -3329,10 +3477,10 @@ EOH
 		end
 	end
 	class Declaration
-		def dump(scope, r=[''], dep=[])
-			tr, dep = @var.dump_def(scope, [''], dep)
-			if @var.kind_of? Variable and @var.type.kind_of? Function and @var.initializer
-				r << ''
+		def dump(scope, r=[CRenderString.new], dep=[])
+			tr, dep = @var.dump_def(scope, [CRenderString.new], dep)
+			if @var.kind_of?(Variable) and @var.type.kind_of?(Function) and @var.initializer
+				r << CRenderString.new
 				r.concat tr
 			else
 				r.pop if r.last == ''
@@ -3361,14 +3509,14 @@ EOH
 		end
 	end
 	class Variable
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			if name
 				dep |= [scope.symbol_ancestors[@name]]
 				r.last << @name
 			end
 			[r, dep]
 		end
-		def dump_def(scope, r=[''], dep=[], skiptype=false)
+		def dump_def(scope, r=[CRenderString.new], dep=[], skiptype=false)
 			# int a=1, b=2;
 			r.last << dump_attributes_pre
 			if not skiptype
@@ -3376,7 +3524,7 @@ EOH
 				r, dep = @type.base.dump(scope, r, dep)
 				r.last << ' ' if name
 			end
-			r, dep = @type.dump_declarator([(name ? @name.dup : '') << dump_attributes], scope, r, dep)
+			r, dep = @type.dump_declarator([CRenderString.new(name ? @name.dup : '') << dump_attributes], scope, r, dep)
 
 			if initializer
 				r.last << ' = ' if not @type.kind_of?(Function)
@@ -3390,7 +3538,7 @@ EOH
 		end
 	end
 	class Type
-		def dump_initializer(init, scope, r=[''], dep=[])
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
 			case init
 			when ::Numeric
 				r.last << init.to_s
@@ -3402,9 +3550,9 @@ EOH
 			end
 		end
 
-		def dump_declarator(decl, scope, r=[''], dep=[])
+		def dump_declarator(decl, scope, r=[CRenderString.new], dep=[])
 			r.last << decl.shift
-			r.concat decl
+			r.concat decl.map { |d| CRenderString.new << d }
 			[r, dep]
 		end
 
@@ -3412,11 +3560,11 @@ EOH
 			dump(*a)
 		end
 
-		def dump_cast(scope, r=[''], dep=[])
+		def dump_cast(scope, r=[CRenderString.new], dep=[])
 			r.last << '('
 			r.last << dump_attributes_pre if not kind_of? TypeDef
 			r, dep = base.dump(scope, r, dep)
-			r, dep = dump_declarator([kind_of?(TypeDef) ? '' : dump_attributes], scope, r, dep)
+			r, dep = dump_declarator([CRenderString.new(kind_of?(TypeDef) ? '' : dump_attributes)], scope, r, dep)
 			r.last << ')'
 			[r, dep]
 		end
@@ -3426,28 +3574,29 @@ EOH
 		end
 	end
 	class Pointer
-		def dump_declarator(decl, scope, r=[''], dep=[])
+		def dump_declarator(decl, scope, r=[CRenderString.new], dep=[])
 			d = decl[0]
-			decl[0] = '*'
+			decl[0] = CRenderString.new
+			decl[0] << '*'
 			decl[0] << ' ' << @qualifier.map { |q| q.to_s }.join(' ') << ' ' if qualifier
 			decl[0] << d
-			if @type.kind_of? Function or @type.kind_of? Array
-				decl[0] = '(' << decl[0]
+			if @type.kind_of?(Function) or @type.kind_of?(Array)
+				decl[0] = CRenderString.new << '(' << decl[0]
 				decl.last << ')'
 			end
 			@type.dump_declarator(decl, scope, r, dep)
 		end
 	end
 	class Array
-		def dump_declarator(decl, scope, r=[''], dep=[])
+		def dump_declarator(decl, scope, r=[CRenderString.new], dep=[])
 			decl.last << '()' if decl.last.empty?
 			decl.last << '['
 			decl, dep = CExpression.dump(@length, scope, decl, dep) if length
 			decl.last << ']'
 			@type.dump_declarator(decl, scope, r, dep)
 		end
-		def dump_initializer(init, scope, r=[''], dep=[])
-			return super(init, scope, r, dep) if not init.kind_of? ::Array
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
+			return super(init, scope, r, dep) if not init.kind_of?(::Array)
 			r.last << '{ '
 			showname = false
 			init.each_with_index { |v, i|
@@ -3456,21 +3605,21 @@ EOH
 					next
 				end
 				r.last << ', ' if r.last[-2, 2] != '{ '
-				rt = ['']
+				rt = [CRenderString.new]
 				if showname
 					showname = false
-					rt << "[#{i}] = "
+					rt << CRenderString.new("[#{i}] = ")
 				end
 				rt, dep = @type.dump_initializer(v, scope, rt, dep)
 				r.last << rt.shift
-				r.concat rt.map { |s| "\t" << s }
+				r.concat rt.map { |s| CRenderString.new << "\t" << s }
 			}
 			r.last << ' }'
 			[r, dep]
 		end
 	end
 	class Function
-		def dump_declarator(decl, scope, r=[''], dep=[])
+		def dump_declarator(decl, scope, r=[CRenderString.new], dep=[])
 			decl.last << '()' if decl.last.empty?
 			decl.last << '('
 			if args
@@ -3489,12 +3638,12 @@ EOH
 			@type.dump_declarator(decl, scope, r, dep)
 		end
 
-		def dump_initializer(init, scope, r=[''], dep=[])
-			Statement.dump(init, scope, r << '', dep)
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
+			Statement.dump(init, scope, r << CRenderString.new, dep)
 		end
 	end
 	class BaseType
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 			r.last << @specifier.to_s << ' ' if specifier and @name != :ptr
 			r.last << case @name
@@ -3507,27 +3656,27 @@ EOH
 		end
 	end
 	class TypeDef
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 			r.last << @name
 			dep |= [scope.symbol_ancestors[@name]]
 			[r, dep]
 		end
 
-		def dump_def(scope, r=[''], dep=[])
+		def dump_def(scope, r=[CRenderString.new], dep=[])
 			r.last << 'typedef '
 			r.last << dump_attributes_pre
 			r, dep = @type.base.dump(scope, r, dep)
 			r.last << ' '
-			@type.dump_declarator([(name ? @name.dup : '') << dump_attributes], scope, r, dep)
+			@type.dump_declarator([CRenderString.new(name ? @name.dup : '') << dump_attributes], scope, r, dep)
 		end
 
-		def dump_initializer(init, scope, r=[''], dep=[])
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
 			@type.dump_initializer(init, scope, r, dep)
 		end
 	end
 	class Union
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			if name
 				r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 				r.last << self.class.name.downcase[/(?:.*::)?(.*)/, 1] << ' ' << @name
@@ -3538,26 +3687,26 @@ EOH
 			end
 		end
 
-		def dump_def(scope, r=[''], dep=[])
-			r << ''
+		def dump_def(scope, r=[CRenderString.new], dep=[])
+			r << CRenderString.new
 			r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 			r.last << self.class.name.downcase[/(?:.*::)?(.*)/, 1]
 			r.last << ' ' << @name if name
 			if members
 				r.last << ' {'
 				@members.each_with_index { |m,i|
-					tr, dep = m.dump_def(scope, [''], dep)
+					tr, dep = m.dump_def(scope, [CRenderString.new], dep)
 					tr.last << ':' << @bits[i].to_s if bits and @bits[i]
 					tr.last << ';'
-					r.concat tr.map { |s| "\t" << s }
+					r.concat tr.map { |s| CRenderString.new << "\t" << s }
 				}
-				r << '}'
+				r << CRenderString.new('}')
 			end
 			r.last << dump_attributes
 			[r, dep]
 		end
 
-		def dump_initializer(init, scope, r=[''], dep=[])
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
 			return super(init, scope, r, dep) if not init.kind_of? ::Array
 			r.last << '{ '
 			showname = false
@@ -3567,21 +3716,21 @@ EOH
 					next
 				end
 				r.last << ', ' if r.last[-2, 2] != '{ '
-				rt = ['']
+				rt = [CRenderString.new]
 				if showname
 					showname = false
 					rt << ".#{m.name} = "
 				end
 				rt, dep = m.type.dump_initializer(i, scope, rt, dep)
 				r.last << rt.shift
-				r.concat rt.map { |s| "\t" << s }
+				r.concat rt.map { |s| CRenderString.new << "\t" << s }
 			}
 			r.last << ' }'
 			[r, dep]
 		end
 	end
 	class Struct
-		def dump_def(scope, r=[''], dep=[])
+		def dump_def(scope, r=[CRenderString.new], dep=[])
 			if pack
 				r, dep = super(scope, r, dep)
 				r.last <<
@@ -3595,7 +3744,7 @@ EOH
 		end
 	end
 	class Enum
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			if name
 				r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 				r.last << 'enum ' << @name
@@ -3606,7 +3755,7 @@ EOH
 			end
 		end
 
-		def dump_def(scope, r=[''], dep=[])
+		def dump_def(scope, r=[CRenderString.new], dep=[])
 			r.last << @qualifier.map { |q| q.to_s << ' ' }.join if qualifier
 			r.last << 'enum'
 			r.last << ' ' << @name if name
@@ -3626,7 +3775,7 @@ EOH
 			[r, dep]
 		end
 
-		def dump_initializer(init, scope, r=[''], dep=[])
+		def dump_initializer(init, scope, r=[CRenderString.new], dep=[])
 			if members and (
 					k = @members.index(init) or
 					(init.kind_of? CExpression and not init.op and k = @members.index(init.rexpr))
@@ -3639,14 +3788,14 @@ EOH
 		end
 	end
 	class If
-		def dump(scope, r=[''], dep=[])
-			r.last << 'if ('
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'if (')
 			r, dep = CExpression.dump(@test, scope, r, dep)
 			r.last << ')'
 			r, dep = Statement.dump(@bthen, scope, r, dep)
 			if belse
-				@bthen.kind_of?(Block) ? (r.last << ' else') : (r << 'else')
-				if @belse.kind_of? If
+				@bthen.kind_of?(Block) ? (r.last << CRenderString.new(' else')) : (r << CRenderString.new(self, 'else'))
+				if @belse.kind_of?(If)
 					# skip indent
 					r.last << ' '
 					r, dep = @belse.dump(scope, r, dep)
@@ -3658,9 +3807,9 @@ EOH
 		end
 	end
 	class For
-		def dump(scope, r=[''], dep=[])
-			r.last << 'for ('
-			if @init.kind_of? Block
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'for (')
+			if @init.kind_of?(Block)
 				scope = @init
 				skiptype = false
 				@init.symbol.each_value { |s|
@@ -3684,56 +3833,57 @@ EOH
 		end
 	end
 	class While
-		def dump(scope, r=[''], dep=[])
-			r.last << 'while ('
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'while (')
 			r, dep = CExpression.dump(@test, scope, r, dep)
 			r.last << ')'
 			Statement.dump(@body, scope, r, dep)
 		end
 	end
 	class DoWhile
-		def dump(scope, r=[''], dep=[])
-			r.last << 'do'
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'do')
 			r, dep = Statement.dump(@body, scope, r, dep)
-			@body.kind_of?(Block) ? (r.last << ' while (') : (r << 'while (')
+			r << CRenderString.new if not @body.kind_of?(Block)
+			r.last << CRenderString.new(self, ' while (')
 			r, dep = CExpression.dump(@test, scope, r, dep)
 			r.last << ');'
 			[r, dep]
 		end
 	end
 	class Switch
-		def dump(scope, r=[''], dep=[])
-			r.last << 'switch ('
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'switch (')
 			r, dep = CExpression.dump(@test, scope, r, dep)
 			r.last << ')'
-			r.last << ' {' if @body.kind_of? Block
-			tr, dep = @body.dump(scope, [''], dep)
+			r.last << ' {' if @body.kind_of?(Block)
+			tr, dep = @body.dump(scope, [CRenderString.new], dep)
 			r.concat tr.map { |s| Case.dump_indent(s, true) }
-			r << '}' if @body.kind_of? Block
+			r << CRenderString.new('}') if @body.kind_of? Block
 			[r, dep]
 		end
 	end
 	class Continue
-		def dump(scope, r=[''], dep=[])
-			r.last << 'continue;'
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'continue;')
 			[r, dep]
 		end
 	end
 	class Break
-		def dump(scope, r=[''], dep=[])
-			r.last << 'break;'
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'break;')
 			[r, dep]
 		end
 	end
 	class Goto
-		def dump(scope, r=[''], dep=[])
-			r.last << "goto #@target;"
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, "goto #@target;")
 			[r, dep]
 		end
 	end
 	class Return
-		def dump(scope, r=[''], dep=[])
-			r.last << 'return '
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'return ')
 			r, dep = CExpression.dump(@value, scope, r, dep)
 			r.last.chop! if r.last[-1] == ?\ 	# the space character
 			r.last << ';'
@@ -3741,12 +3891,12 @@ EOH
 		end
 	end
 	class Case
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			case @expr
 			when 'default'
 				r.last << @expr
 			else
-				r.last << 'case '
+				r.last << CRenderString.new(self, 'case ')
 				r, dep = CExpression.dump(@expr, scope, r, dep)
 				if exprup
 					r.last << ' ... '
@@ -3759,35 +3909,35 @@ EOH
 
 		def self.dump_indent(s, short=false)
 			case s
-			when /^(case|default)\W/; (short ? '    ' : "\t") << s
-			when /^\s+(case|default)\W/; "\t" << s
+			when /^(case|default)\W/; CRenderString.new(short ? '    ' : "\t") << s
+			when /^\s+(case|default)\W/; CRenderString.new("\t") << s
 			when /:$/; s
-			else "\t" << s
+			else CRenderString.new("\t") << s
 			end
 		end
 	end
 	class Label
-		def dump(scope, r=[''], dep=[])
-			r.last << @name << ':'
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, @name) << ':'
 			dump_inner(scope, r, dep)
 		end
-		def dump_inner(scope, r=[''], dep=[])
+		def dump_inner(scope, r=[CRenderString.new], dep=[])
 			if not @statement; [r, dep]
-			elsif @statement.kind_of? Block; Statement.dump(@statement, scope, r, dep)
-			else  @statement.dump(scope, r << '', dep)
+			elsif @statement.kind_of?(Block); Statement.dump(@statement, scope, r, dep)
+			else  @statement.dump(scope, r << CRenderString.new, dep)
 			end
 		end
 	end
 	class Asm
-		def dump(scope, r=[''], dep=[])
-			r.last << 'asm '
+		def dump(scope, r=[CRenderString.new], dep=[])
+			r.last << CRenderString.new(self, 'asm ')
 			r.last << 'volatile ' if @volatile
 			r.last << '('
-			r.last << @body.inspect
+			r.last << CRenderString.new(self, CExpression.string_inspect(@body))
 			if @output or @input or @clobber
 				if @output and @output != []
 					# TODO
-					r << ': /* todo */'
+					r << CRenderString.new(': /* todo */')
 				elsif (@input and @input != []) or (@clobber and @clobber != [])
 					r.last << ' :'
 				end
@@ -3795,51 +3945,60 @@ EOH
 			if @input or @clobber
 				if @input and @input != []
 					# TODO
-					r << ': /* todo */'
+					r << CRenderString.new(': /* todo */')
 				elsif @clobber and @clobber != []
 					r.last << ' :'
 				end
 			end
 			if @clobber and @clobber != []
-				r << (': ' << @clobber.map { |c| c.inspect }.join(', '))
+				r << (CRenderString.new(': ') << @clobber.map { |c| CExpression.string_inspect(c) }.join(', '))
 			end
 			r.last << ');'
 			[r, dep]
 		end
 	end
 	class CExpression
-		def self.dump(e, scope, r=[''], dep=[], brace = false)
-			if $DEBUG
-				brace = false
-				case e
-				when CExpression, Variable
-					r, dep = e.type.dump_cast(scope, r, dep)
+		def self.string_inspect(s)
+			# keep all ascii printable except \ and "
+			'"' + s.gsub(/[^ !\x23-\x5b\x5d-\x7e]/) { |o|
+				case hex = o.unpack('H*').first.downcase
+				when '00'; '\\0'
+				when '0a'; '\\n'
+				when '0d'; '\\r'
+				when '1b'; '\\e'
+				when '22'; '\\"'
+				when '5c'; '\\\\'
+				else "\\x#{hex}"
 				end
-				r.last << '('
-			end
+			} + '"'
+		end
+
+		def self.dump(e, scope, r=[CRenderString.new], dep=[], brace = false)
 			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]
 			else raise 'wtf?' + e.inspect
 			end
-			if $DEBUG
-				r.last << ')'
-			end
 			[r, dep]
 		end
 
-		def dump(scope, r=[''], dep=[])
+		def dump(scope, r=[CRenderString.new], dep=[])
 			r, dep = dump_inner(scope, r, dep)
-			r.last << ';'
+			r.last << CRenderString.new(self, ';')
 			[r, dep]
 		end
 
-		def dump_inner(scope, r=[''], dep=[], brace = false)
-			r.last << '(' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of? CExpression)
+		def dump_inner(scope, r=[CRenderString.new], dep=[], brace = false)
+			r.last << CRenderString.new(self)
+			if misc and misc[:custom_display]
+				r.last << misc[:custom_display]
+				return [r, dep]
+			end
+			r.last << '(' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of?(CExpression))
 			if not @lexpr
 				if not @op
 					case @rexpr
@@ -3855,7 +4014,7 @@ EOH
 						else
 							r.last << re.to_s
 						end
-						if @type.kind_of? BaseType
+						if @type.kind_of?(BaseType)
 							r.last << 'U' if @type.specifier == :unsigned
 							case @type.name
 							when :longlong, :__int64; r.last << 'LL'
@@ -3864,8 +4023,8 @@ EOH
 							end
 						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 << 'L' if @type.kind_of?(Pointer) and @type.type.kind_of?(BaseType) and @type.type.name == :short
+						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)
@@ -3877,11 +4036,11 @@ EOH
 						r.last << ' )'
 					when Label
 						r.last << '&&' << @rexpr.name
-					else raise "wtf? #{inspect}"
+					else raise "(wtf? #{inspect})"
 					end
 				else
 					r.last << @op.to_s
-					r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of? C::CExpression and @rexpr.lexpr))
+					r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of?(C::CExpression) and @rexpr.lexpr))
 				end
 			elsif not @rexpr
 				r, dep = CExpression.dump(@lexpr, scope, r, dep)
@@ -3890,16 +4049,16 @@ EOH
 				case @op
 				when :'->', :'.'
 					r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
-					r.last << @op.to_s << @rexpr
+					r.last << CRenderString.new(self, @op.to_s) << @rexpr
 				when :'[]'
 					r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
 					r.last << '['
-					l = lexpr if lexpr.kind_of? Variable
-					l = lexpr.lexpr.type.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of? CExpression and lexpr.op == :'.'
-					l = lexpr.lexpr.type.pointed.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of? CExpression and lexpr.op == :'->'
+					l = lexpr if lexpr.kind_of?(Variable)
+					l = lexpr.lexpr.type.untypedef.findmember(lexpr.rexpr) if lexpr.kind_of?(CExpression) and lexpr.op == :'.'
+					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)
+					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)
 						r.last << i
 						dep |= [enum]
 					else
@@ -3911,22 +4070,22 @@ EOH
 					r.last << '('
 					@rexpr.each { |arg|
 						r.last << ', ' if r.last[-1] != ?(
-						r, dep = CExpression.dump(arg, scope, r, dep)
+						r, dep = CExpression.dump(arg, scope, r, dep, (arg.kind_of?(CExpression) and arg.op == :','))
 					}
 					r.last << ')'
 				when :'?:'
 					r, dep = CExpression.dump(@lexpr, scope, r, dep, true)
-					r.last << ' ? '
+					r.last << CRenderString.new(self, ' ? ')
 					r, dep = CExpression.dump(@rexpr[0], scope, r, dep, true)
-					r.last << ' : '
+					r.last << CRenderString.new(self, ' : ')
 					r, dep = CExpression.dump(@rexpr[1], scope, r, dep, true)
 				else
-					r, dep = CExpression.dump(@lexpr, scope, r, dep, (@lexpr.kind_of? CExpression and @lexpr.lexpr and @lexpr.op != @op))
-					r.last << ' ' << @op.to_s << ' '
-					r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of? CExpression and @rexpr.lexpr and @rexpr.op != @op and @rexpr.op != :funcall))
+					r, dep = CExpression.dump(@lexpr, scope, r, dep, (@lexpr.kind_of?(CExpression) and @lexpr.lexpr and @lexpr.op != @op and @lexpr.op != :funcall))
+					r.last << CRenderString.new(self, ' ' << @op.to_s << ' ')
+					r, dep = CExpression.dump(@rexpr, scope, r, dep, (@rexpr.kind_of?(CExpression) and @rexpr.lexpr and @rexpr.op != @op and @rexpr.op != :funcall and @op != :'='))
 				end
 			end
-			r.last << ')' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of? CExpression)
+			r.last << ')' if brace and @op != :'->' and @op != :'.' and @op != :'[]' and (@op or @rexpr.kind_of?(CExpression))
 			[r, dep]
 		end