static void xdr2fattr( Dictionary<int,Object> attr, int fattr , XdrDecodingStream xdr) { switch(fattr) { case NFSv4Protocol.FATTR4_SIZE : uint64_t size = new uint64_t(); size.xdrDecode(xdr); attr.Add(fattr, size); break; case NFSv4Protocol.FATTR4_MODE : mode4 mode = new mode4(); mode.xdrDecode(xdr); attr.Add(fattr, mode); break; case NFSv4Protocol.FATTR4_TYPE : fattr4_type type = new fattr4_type(); type.xdrDecode(xdr); attr.Add(fattr,type ); break; case NFSv4Protocol.FATTR4_TIME_CREATE : nfstime4 time = new nfstime4(); time.xdrDecode(xdr); attr.Add(fattr,time); break; case NFSv4Protocol.FATTR4_TIME_ACCESS : nfstime4 time2 = new nfstime4(); time2.xdrDecode(xdr); attr.Add(fattr,time2); break; case NFSv4Protocol.FATTR4_TIME_MODIFY : nfstime4 time3 = new nfstime4(); time3.xdrDecode(xdr); attr.Add(fattr,time3); break; /*case NFSv4Protocol.FATTR4_OWNER : // TODO: use princilat utf8str_cs owner = new utf8str_cs (); owner.xdrDecode(xdr); String new_owner = new String(owner.value.value); attr.Add(fattr,new_owner ); break; case NFSv4Protocol.FATTR4_OWNER_GROUP : // TODO: use princilat utf8str_cs owner_group = new utf8str_cs (); owner_group.xdrDecode(xdr); String new_group = new String(owner_group.value.value); attr.Add(fattr,new_group ); break;*/ default: break; } }
static uint64_t ReadUint64(Vector buffer, out int number_of_read_digits) { uint64_t result = 0; int i = 0; while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) { int digit = buffer[i++] - '0'; result = 10 * result + (ulong)digit; } number_of_read_digits = i; return(result); }
public void create(string path, uint64_t size, bool overwrite, ref std::error_code ec) { if (isOpened()) { close(ref ec); if (ec != null) { return; } } //C++ TO C# CONVERTER TODO TASK: Only lambda expressions having all locals passed by reference can be converted to C#: //ORIGINAL LINE: Tools::ScopeExit failExitHandler([this, &ec] Tools.ScopeExit failExitHandler(() => { ec = std::error_code(errno, std::system_category()); std::error_code ignore = new std::error_code(); close(ref ignore); }); m_file = global::open(path, O_RDWR | O_CREAT | (overwrite ? O_TRUNC : O_EXCL), S_IRUSR | S_IWUSR); if (m_file == -1) { return; } int result = global::ftruncate(m_file, (off_t)size); if (result == -1) { return; } //C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#: m_data = reinterpret_cast <uint8_t>(global::mmap(null, (size_t)size, PROT_READ | PROT_WRITE, MAP_SHARED, m_file, 0)); if (m_data == MAP_FAILED) { return; } //C++ TO C# CONVERTER TODO TASK: The following line was determined to be a copy assignment (rather than a reference assignment) - this should be verified and a 'CopyFrom' method should be created: //ORIGINAL LINE: m_size = size; m_size.CopyFrom(size); m_path = path; ec = std::error_code(); failExitHandler.cancel(); }
public byte[] Add(byte[] a, byte[] b, out bool overflow) { uint64_t _a = new uint64_t(a); uint64_t _b = new uint64_t(b); uint64_t result = _a + _b; byte[] r = result.ToBinary(); byte[] values; overflow = false; if (a.Length >= b.Length) { values = new byte[a.Length]; } else { values = new byte[b.Length]; } Array.Copy(r, values, values.Length); if (values.Length < 8) { overflow = (r[values.Length + 1] > 0); } else { try { UInt64 temp = checked (_a + _b); } catch (OverflowException) { overflow = true; flags = flags | ALUFlags.Overflow; } } flags = ALUFlags.None; if (overflow) { flags = flags | ALUFlags.Overflow; } return(values); }
public void Compare(byte[] a, byte[] b) { uint64_t _a = new uint64_t(a); uint64_t _b = new uint64_t(b); flags = ALUFlags.None; if (_a.Value == _b.Value) { flags = flags | ALUFlags.Equal; } if (_a.Value > _b.Value) { flags = flags | ALUFlags.GreaterThan; } if (_a.Value < _b.Value) { flags = flags | ALUFlags.LessThan; } }
public static SortedSet<Tuple<SortedSet<string>, UInt64>> fptree_growth(FPTree fptree) { if (fptree.empty()) { return { }; } if (contains_single_path(fptree)) { // generate all possible combinations of the items in the tree SortedSet<Tuple<SortedSet<string>, uint64_t>> single_path_patterns = new SortedSet<Tuple<SortedSet<string>, uint64_t>>(); // for each node in the tree Debug.Assert(fptree.root.children.Count == 1); var curr_fpnode = fptree.root.children[0]; while (curr_fpnode) { string curr_fpnode_item = curr_fpnode.item; uint64_t curr_fpnode_frequency = curr_fpnode.frequency; // add a pattern formed only by the item of the current node Tuple<SortedSet<string>, uint64_t> new_pattern = new Tuple<SortedSet<string>, uint64_t>({ curr_fpnode_item }, curr_fpnode_frequency);
public void flush(uint8_t data, uint64_t size, ref std::error_code ec) { Debug.Assert(isOpened()); uintptr_t pageSize = (uintptr_t)sysconf(_SC_PAGESIZE); //C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#: uintptr_t dataAddr = reinterpret_cast <uintptr_t>(data); uintptr_t pageOffset = (dataAddr / pageSize) * pageSize; //C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#: int result = global::msync(reinterpret_cast <object>(pageOffset), (size_t)(dataAddr % pageSize + size), MS_SYNC); if (result == 0) { result = global::fsync(m_file); if (result == 0) { ec = std::error_code(); return; } } ec = std::error_code(errno, std::system_category()); }
public CachedPower(ulong significand, short binary_exponent, short decimal_exponent) { this.significand = significand; this.binary_exponent = binary_exponent; this.decimal_exponent = decimal_exponent; }
public void sleep(std::chrono.nanoseconds duration) { Debug.Assert(dispatcher != null); Debug.Assert(context == null); if (dispatcher.interrupted()) { throw InterruptedException(); } if (duration.count() == 0) { dispatcher.yield(); } else { timer = dispatcher.getTimer(); var seconds = std::chrono.duration_cast <std::chrono.seconds>(duration); itimerspec expires = new itimerspec(); expires.it_interval.tv_nsec = expires.it_interval.tv_sec = 0; expires.it_value.tv_sec = seconds.count(); expires.it_value.tv_nsec = std::chrono.duration_cast <std::chrono.nanoseconds>(duration - seconds).count(); timerfd_settime(timer, 0, expires, null); ContextPair contextPair = new ContextPair(); OperationContext timerContext = new OperationContext(); timerContext.interrupted = false; timerContext.context = dispatcher.getCurrentContext(); contextPair.writeContext = null; contextPair.readContext = timerContext; epoll_event timerEvent = new epoll_event(); timerEvent.events = EPOLLIN | EPOLLONESHOT; timerEvent.data.ptr = contextPair; if (epoll_ctl(dispatcher.getEpoll(), EPOLL_CTL_MOD, timer, timerEvent) == -1) { throw new System.Exception("Timer::sleep, epoll_ctl failed, " + lastErrorMessage()); } dispatcher.getCurrentContext().interruptProcedure = () => { Debug.Assert(dispatcher != null); Debug.Assert(context != null); OperationContext timerContext = (OperationContext)context; if (!timerContext.interrupted) { uint64_t value = 0; if (global::read(timer, value, sizeof(uint64_t)) == -1) { //C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#: //#pragma GCC diagnostic push //C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#: //#pragma GCC diagnostic ignored "-Wlogical-op" if (errno == EAGAIN || errno == EWOULDBLOCK) { //C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#: //#pragma GCC diagnostic pop timerContext.interrupted = true; dispatcher.pushContext(timerContext.context); } else { throw new System.Exception("Timer::sleep, interrupt procedure, read failed, " + lastErrorMessage()); } } else { Debug.Assert(value > 0); dispatcher.pushContext(timerContext.context); } epoll_event timerEvent = new epoll_event(); timerEvent.events = EPOLLONESHOT; timerEvent.data.ptr = null; if (epoll_ctl(dispatcher.getEpoll(), EPOLL_CTL_MOD, timer, timerEvent) == -1) { throw new System.Exception("Timer::sleep, interrupt procedure, epoll_ctl failed, " + lastErrorMessage()); } } }; context = timerContext; dispatcher.dispatch(); dispatcher.getCurrentContext().interruptProcedure = null; Debug.Assert(dispatcher != null); Debug.Assert(timerContext.context == dispatcher.getCurrentContext()); Debug.Assert(contextPair.writeContext == null); Debug.Assert(context == &timerContext); context = null; timerContext.context = null; dispatcher.pushTimer(timer); if (timerContext.interrupted) { throw InterruptedException(); } } }
// If the function returns true then the result is the correct double. // Otherwise it is either the correct double or the double that is just below // the correct double. static bool DiyFpStrtod(Vector buffer, int exponent, out double result) { DiyFp input; int remaining_decimals; ReadDiyFp(buffer, out input, out remaining_decimals); // Since we may have dropped some digits the input is not accurate. // If remaining_decimals is different than 0 than the error is at most // .5 ulp (unit in the last place). // We don't want to deal with fractions and therefore keep a common // denominator. const int kDenominatorLog = 3; const int kDenominator = 1 << kDenominatorLog; // Move the remaining decimals into the exponent. exponent += remaining_decimals; uint64_t error = (ulong)(remaining_decimals == 0 ? 0 : kDenominator / 2); int old_e = input.e; input.Normalize(); error <<= old_e - input.e; if (exponent < PowersOfTenCache.kMinDecimalExponent) { result = 0.0; return(true); } DiyFp cached_power; int cached_decimal_exponent; PowersOfTenCache.GetCachedPowerForDecimalExponent(exponent, out cached_power, out cached_decimal_exponent); if (cached_decimal_exponent != exponent) { int adjustment_exponent = exponent - cached_decimal_exponent; DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent); input.Multiply(ref adjustment_power); if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) { // The product of input with the adjustment power fits into a 64 bit // integer. } else { // The adjustment power is exact. There is hence only an error of 0.5. error += kDenominator / 2; } } input.Multiply(ref cached_power); // The error introduced by a multiplication of a*b equals // error_a + error_b + error_a*error_b/2^64 + 0.5 // Substituting a with 'input' and b with 'cached_power' we have // error_b = 0.5 (all cached powers have an error of less than 0.5 ulp), // error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64 int error_b = kDenominator / 2; int error_ab = (error == 0 ? 0 : 1); // We round up to 1. int fixed_error = kDenominator / 2; error += (ulong)(error_b + error_ab + fixed_error); old_e = input.e; input.Normalize(); error <<= old_e - input.e; // See if the double's significand changes if we add/subtract the error. int order_of_magnitude = DiyFp.kSignificandSize + input.e; int effective_significand_size = Double.SignificandSizeForOrderOfMagnitude(order_of_magnitude); int precision_digits_count = DiyFp.kSignificandSize - effective_significand_size; if (precision_digits_count + kDenominatorLog >= DiyFp.kSignificandSize) { // This can only happen for very small denormals. In this case the // half-way multiplied by the denominator exceeds the range of an uint64. // Simply shift everything to the right. int shift_amount = (precision_digits_count + kDenominatorLog) - DiyFp.kSignificandSize + 1; input.f = (input.f >> shift_amount); input.e = (input.e + shift_amount); // We add 1 for the lost precision of error, and kDenominator for // the lost precision of input.f(). error = (error >> shift_amount) + 1 + kDenominator; precision_digits_count -= shift_amount; } // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too. uint64_t one64 = 1; uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1; uint64_t precision_bits = input.f & precision_bits_mask; uint64_t half_way = one64 << (precision_digits_count - 1); precision_bits *= kDenominator; half_way *= kDenominator; DiyFp rounded_input = new DiyFp(input.f >> precision_digits_count, input.e + precision_digits_count); if (precision_bits >= half_way + error) { rounded_input.f = (rounded_input.f + 1); } // If the last_bits are too close to the half-way case than we are too // inaccurate and round down. In this case we return false so that we can // fall back to a more precise algorithm. result = new Double(rounded_input).value(); if (half_way - error < precision_bits && precision_bits < half_way + error) { // Too imprecise. The caller will have to fall back to a slower version. // However the returned number is guaranteed to be either the correct // double, or the next-lower double. return(false); } else { return(true); } }
public static extern int JS_ToIndex(JSContext ctx, out uint64_t plen, JSValueConst val);
public Opcode(uint64_t value, uint16_t address) : this() { this.Address = address; FromBinary(value.ToBinary()); }
public NFSAttributes GetItemAttributes(string ItemFullName, bool ThrowExceptionIfNotFound = true) { if (_ProtocolV4 == null) { throw new NFSConnectionException("NFS Client not connected!"); } ItemFullName = ItemFullName.Replace(".\\.\\", ".\\"); if (useFHCache) { if (cached_attrs.ContainsKey(ItemFullName)) { return((NFSAttributes)cached_attrs[ItemFullName]); } } //we will return it in the old way !! ;) NFSAttributes attributes = null; if (String.IsNullOrEmpty(ItemFullName)) { //should not happen return(attributes); } if (ItemFullName == ".\\.") { return(new NFSAttributes(0, 0, 0, NFSItemTypes.NFDIR, new NFSPermission(7, 7, 7), 4096, _rootFH.value)); } nfs_fh4 currentItem = _rootFH; int initial = 1; String[] PathTree = ItemFullName.Split(@"\".ToCharArray()); if (useFHCache) { string parent = System.IO.Path.GetDirectoryName(ItemFullName); //get cached parent dir to avoid too much directory if (parent != ItemFullName) { if (cached_attrs.ContainsKey(parent)) { currentItem.value = ((NFSAttributes)cached_attrs[parent]).Handle; initial = PathTree.Length - 1; } } } for (int pC = initial; pC < PathTree.Length; pC++) { List <int> attrs = new List <int>(1); attrs.Add(NFSv4Protocol.FATTR4_TIME_CREATE); attrs.Add(NFSv4Protocol.FATTR4_TIME_ACCESS); attrs.Add(NFSv4Protocol.FATTR4_TIME_MODIFY); attrs.Add(NFSv4Protocol.FATTR4_TYPE); attrs.Add(NFSv4Protocol.FATTR4_MODE); attrs.Add(NFSv4Protocol.FATTR4_SIZE); List <nfs_argop4> ops = new List <nfs_argop4>(); ops.Add(SequenceStub.generateRequest(false, _sessionid.value, _sequenceID.value.value, 12, 0)); ops.Add(PutfhStub.generateRequest(currentItem)); ops.Add(LookupStub.generateRequest(PathTree[pC])); //ops.Add(PutfhStub.generateRequest(_cwd)); //ops.Add(LookupStub.generateRequest(PathTree[PathTree.Length-1])); ops.Add(GetfhStub.generateRequest()); ops.Add(GetattrStub.generateRequest(attrs)); COMPOUND4res compound4res = sendCompound(ops, ""); if (compound4res.status == nfsstat4.NFS4_OK) { currentItem = compound4res.resarray[3].opgetfh.resok4.object1; //nfs_fh4 currentItem = compound4res.resarray[3].opgetfh.resok4.object1; //results Dictionary <int, Object> attrrs_results = GetattrStub.decodeType(compound4res.resarray[4].opgetattr.resok4.obj_attributes); //times nfstime4 time_acc = (nfstime4)attrrs_results[NFSv4Protocol.FATTR4_TIME_ACCESS]; int time_acc_int = unchecked ((int)time_acc.seconds.value); nfstime4 time_modify = (nfstime4)attrrs_results[NFSv4Protocol.FATTR4_TIME_MODIFY]; int time_modif = unchecked ((int)time_modify.seconds.value); int time_creat = 0; //linux should now store create time if it is let's check it else use modify date if (attrrs_results.ContainsKey(NFSv4Protocol.FATTR4_TIME_CREATE)) { nfstime4 time_create = (nfstime4)attrrs_results[NFSv4Protocol.FATTR4_TIME_CREATE]; time_creat = unchecked ((int)time_create.seconds.value); } else { time_creat = time_modif; } //3 = type NFSItemTypes nfstype = NFSItemTypes.NFREG; fattr4_type type = (fattr4_type)attrrs_results[NFSv4Protocol.FATTR4_TYPE]; if (type.value == 2) { nfstype = NFSItemTypes.NFDIR; } //4 = mode is int also mode4 mode = (mode4)attrrs_results[NFSv4Protocol.FATTR4_MODE]; byte other = (byte)(mode.value.value % 8); byte grup = (byte)((mode.value.value >> 3) % 8); byte user = (byte)((mode.value.value >> 6) % 8); NFSPermission per = new NFSPermission(user, grup, other); uint64_t size = (uint64_t)attrrs_results[NFSv4Protocol.FATTR4_SIZE]; //here we do attributes compatible with old nfs versions attributes = new NFSAttributes(time_creat, time_acc_int, time_modif, nfstype, per, size.value, currentItem.value); } else if (compound4res.status == nfsstat4.NFS4ERR_NOENT) { return(null); } else { throw new NFSConnectionException(nfsstat4.getErrorString(compound4res.status)); } } // if(attributes.NFSType == NFSItemTypes.NFDIR) if (useFHCache) { cached_attrs.Add(ItemFullName, attributes); } return(attributes); }