language-implementation

I was looking the implementation of memcpy.c, I found a different memcpy code. I couldnt understand why do they do (((ADDRESS) s) | ((ADDRESS) d) | c) & (sizeof(UINT) - 1) #if !defined(__MACHDEP_MEMFUNC) #ifdef _MSC_VER #pragma function(memcpy) #undef __MEMFUNC_ARE_INLINED #endif #if !defined(__MEMFUNC_ARE_INLINED) /* Copy C bytes from S to D. * Only works if non-overlapping, or if D < S. */ EXTERN_C void * __cdecl memcpy(void *d, const void *s, size_t c) { if ((((ADDRESS) s) | ((ADDRESS) d) | c) & (sizeof(UINT) - 1)) { BYTE *pS = (BYTE *) s; BYTE *pD = (BYTE *) d; BYTE *pE = (BYTE *) ((

I'm reading The C++ Programming Language and in it Stroustrup states that the int value of a char can range from 0 to 255 or -127 to 127, depending on implementation. Is this correct? It seems like it should be from -128 to 127. If not, why are their only 255 possible values in the second implementation possibility, not 256. Roddy You're stuck in two's complement thinking - The C++ standard does not define the representation used for negative numbers! If your computer (god forbid) uses ones's complement to represent negative numbers, you have a range of -127 to + 127 in an 8-bit byte. On the

In Ruby 2.0.0-p0, the __dir__ variable was introduced for easy access to the directory of the file currently being executed. Why is __dir__ lowercase when __FILE__ is uppercase? Intrepidd I think that is because __FILE__ is a parse-time constant whereas __dir__ is a function and returns File.dirname(File.realpath(__FILE__)) For more details, see This discussion TL; DR The relative merits of language implementation choices are outside the scope of a reasonable Stack Overflow question. However, this is a good question because it identifies a potentially confusing use case in the language and

I have been trying to understand the internal implementation of java.util.HashMap and java.util.HashSet . Following are the doubts popping in my mind for a while: Whats is the importance of the @Override public int hashcode() in a HashMap/HashSet? Where is this hash code used internally? I have generally seen the key of the HashMap be a String like myMap<String,Object> . Can I map the values against someObject (instead of String) like myMap<someObject, Object> ? What all contracts do I need to obey for this happen successfully? Thanks in advance ! EDIT: Are we saying that the hash code of the

C++ has multiple inheritance. The implementation of multiple inheritance at the assembly level can be quite complicated, but there are good descriptions online on how this is normally done (vtables, pointer fixups, thunks, etc). Java doesn't have multiple implementation inheritance, but it does have multiple interface inheritance, so I don't think a straight forward implementation with a single vtable per class can implement that. How does java implement interfaces internally? I realize that contrary to C++, Java is Jit compiled, so different pieces of code might be optimized differently, and