Какие платформы имеют что-то другое, чем 8-разрядный символ?

при написании кода и мышлением о кроссплатформе (например, для библиотек общей используемой), Какого рода рассмотрение стоит дать платформам с не 8-битным CHAR?

Это не так много, что это «стоит рассмотреть вопрос о чем-то, как это играет по правилам. Например, в C ++ стандарт говорит, что все байты будут иметь «по крайней мере» 8 бит. Если ваш код предполагает, что байты имеют ровно 8 бит, вы нарушаете стандарт.

Это может казаться глупым сейчас - «, конечно Все байты имеют 8 битов!», Я слышу, как вы говорите. Но многие очень умные люди полагались на предположения, которые не были гарантированы, а потом все сломалось. История восстанавливается таким примерами.

Например, большинство разработчиков в начале 90-х годов предположили, что конкретный задержка синхронизации ЦП № OP принимает фиксированное количество циклов, потребуется фиксированного количества часов времени, поскольку большинство потребительских процессоров были примерно эквивалентны мощности. К сожалению, компьютеры очень быстро вернулись быстрее. Это породило рост ящиков с помощью кнопок «Турбо» - чья цель, по иронии судьбы, должна была замедлить компьютер, чтобы игры, использующие технику времени задержки, могут быть воспроизведены на разумной скорости.

Один комментатор спросил, где в стандарте он говорит, что CHAR должен иметь как минимум 8 битов. Это в разделе 5.2.4.2.1 . Этот раздел определяет CHAR_BIT , количество битов в наименьшем адресуемом объекте и имеет значение по умолчанию 8. Он также говорит:

их значения, определенные введения, должны быть равными или больше по величине (абсолютно Значение) к показанным, с тем же знаком.

Таким образом, любой номер, равный 8 или выше, подходит для замены осуществлением в CHAR_BIT .

Машины с 36-битными архитектурами имеют 9-битные байты. Согласно Wikipedia, машины с 36-битными архитектурами включают в себя:

• Corporation Corporation Corporation PDP-6/10
• IBM 701/704/709/7090/7094
• Univac 1103 / 1103A / 1105/1100/2200,

Несколько из которых я знаю:

• DEC PRP-10: Переменная, но чаще всего 7-битные символы упаковывают 5 на 36-битное слово, или иначе 9-битные символы, 4 за слово
• Картинки управления Mainframes (CDC-6400, 6500, 6600, 7600, Cyber ​​170, Cyber ​​176 и т. Д. ) 6-битные символы, упакованные 10 на 60-битное слово.
• ДУХОВНЫЕ МАЙНЫЕ МАЙНЫЕ МАЙСЫ: 9 бит / байт
• Windows CE: просто не поддерживает тип `CHAR` вообще - вместо этого требуется 16-битный wchar_t

Языки программирования C и C ++, например, определяют байт как «адресуемое блок. данных достаточно больших, чтобы удерживать любого члена основного набора символов среды выполнения »(пункт 3.6 стандарта C). Поскольку тип данных C CAR CHAR должен содержать не менее 8 битов (пункт 5.2.4.2.1), байт в C, по меньшей мере, способен удерживать 256 разных значений. Различные реализации C и C ++ определяют байт как 8, 9, 16, 32 или 36 битов

, указанные из http://en.wikipedia.org/wiki/byte#history

Не уверен другие языки, хотя.

http://en.wikipedia.org/wiki/ibm_7030_stretch#data_formats

Определяет байт на этой машине, чтобы быть переменной длиной

Для тех из вас, кто заинтересован в фактической реализации приложений с несколькими процессами, я написал статью об этом на своем сайте: Multi-process C # app как Google Chrome .

Я включил рабочий код C #. Он был протестирован для работы с .NET 2.0, .NET 3.0 и .NET 3.5.

Именованные каналы: Как процессы говорят с другими

Поскольку ваш вопрос конкретно о Google Chrome, вы должны знать, что Chrome использует именованные каналы для обмена данными между процессами.

В упомянутом выше исходном коде C # имеется 2 файла: PipeServer.cs & PipeClient.cs. Эти 2 файла представляют собой тонкие оболочки Windows API именованных каналов. Это хорошо протестировано, потому что наши продукты используют сотни тысяч людей. Таким образом, стабильность и надежность были требованием.

Как мы используем мультипроцессный дизайн

Теперь, когда у вас есть все части головоломки, позвольте мне рассказать вам, как мы используем мультипроцессный дизайн в нашем приложении.

Наш продукт является полным решением для обновления. Таким образом, есть программа , которая строит участки обновления (не относящийся к обсуждению), автономная updater программа ( wyUpdate - также открытый источник ), и Автоматический контроль за Updater , что наши пользователи ставят свой C# или формы VB.NET.

Мы используем именованные каналы для обмена данными между автономным средством обновления (wyUpdate) и элементом управления Automatic Updater, расположенным в форме программы. wyUpdate сообщает о ходе выполнения автоматического обновления, а средство автоматического обновления может сообщить wyUpdate об отмене выполнения, о начале загрузки, о начале извлечения и т.д.

На самом деле, точный код канала, который мы используем, включен в статью I, упомянутую выше: Multi-process C # app, как Google Chrome .

Почему вы не должны использовать многопроцессную модель

Как сказал Джон Скит выше, у вас должна быть конкретная потребность в многопроцессной модели. В нашем случае мы хотели, чтобы средство обновления было полностью отделено от вашей программы. Таким образом, если бы программа обновления как-то потерпела крах, ваша программа осталась бы невредимой. Мы также не хотели дублировать наш код в 2 местах.

При этом, даже с нашей хорошо протестированной оболочкой именованных труб, взаимодействие между процессами затруднено. Так что осторожно идите.

Я думаю, что это больше связано с Weblogic - я вижу то же самое на Weblogic 9.2 - но не на Tomcat или Jetty. Не ударяет по моей Url Mapping:

"/"(controller: 'home', action: 'index')

Я думаю, что Weblogic является умным и конвертирует/- > index.gsp, который затем возвращается как 404.

Существует несколько уродливый обходной путь - просто добавьте такое отображение:

"/index.gsp"(controller: 'home', action: 'index')   

и это, кажется, делает трюк. У кого-нибудь есть лучший способ исправить это???

В одном случае длина символов Юникода превышает 8 бит. Как уже упоминалось ранее, спецификация C определяет типы данных по их минимальным размерам. Используйте sizeof и значения в limits.h , если требуется опросить типы данных и точно определить их размер для конфигурации и архитектуры.

Поэтому я стараюсь придерживаться таких типов данных, как uint16 _ t , когда мне нужен тип данных определенной длины.

Изменить: Извините, я изначально неправильно понял ваш вопрос.

В спецификации C указано, что объект char является «достаточно большим для хранения любого члена набора символов выполнения». limits.h перечисляет минимальный размер 8 бит, но определение оставляет открытым максимальный размер символа .

Таким образом, символ char является по меньшей мере самым большим символом из набора выполнения вашей архитектуры (обычно округляется до ближайшей 8-битной границы). Если архитектура имеет более длинные коды операций, размер символа может быть больше.

Исторически код операции платформы x86 имел длину в один байт, поэтому char изначально был 8-битным значением. Текущие платформы x86 поддерживают opcodes длиннее одного байта, но char поддерживается на 8 битах в длину, так как именно на это рассчитывают программисты (и большие объемы существующего кода x86).

При рассмотрении поддержки нескольких платформ воспользуйтесь преимуществами типов, определенных в stdint.h . Если используется (например) uint16_t, то можно убедиться, что это значение является неподписанным 16-битным значением на любой архитектуре, независимо от того, соответствует ли это 16-битное значение char , short , int или что-то еще. Большая часть напряженной работы уже проделана людьми, которые написали ваш компилятор/стандартные библиотеки.

Если вам нужно знать точный размер символа , потому что вы выполняете некоторые низкоуровневые аппаратные манипуляции, которые требуют этого, я обычно использую тип данных, который достаточно велик для хранения символа на всех поддерживаемых платформах (обычно достаточно 16 битов) и выполнить значение через конвертировать _ в программу _ machine _ char , когда мне нужно точное представление машины. Таким путям, специфичный для платформы код ограничивается функцией интерфейса, и большую часть времени я могу использовать обычный uint16 _ t .

Многие чипы DSP имеют 16- или 32-битное CHAR . Ti регулярно делает такие чипы , например .

Вы можете запускать PowerShell.exe с -NOEXIT или попробуйте:

"hello world" | out-gridview
Read-Host "press enter to exit"

Обновлено: Out-GridView неблокирует, поэтому, если вы хотите проверить для него, чтобы выйти, вы должны прибегать к некоторому низкоуровневым API-APIS Win32. Следующий код работает в ISE (не проверил его в хосте консоли). Также он имеет ограничение - в основном ищет любое окно, связанное с процессом HOST, кроме главного окна хоста, чтобы уйти. В этот момент он вернется. Оказывается, Out-GridView не является ребенком главного окна, и его подпись не является последовательным (GPS | Out-GridView или GPS | OGV или GPS | <Любые псевдонимы, которые вы составляете> ):

$src = @'
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;

namespace Utils
{
    public delegate bool Win32Callback(IntPtr hwnd, IntPtr lParam);

    public class WindowHelper 
    {
        private const int PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
        private IntPtr _mainHwnd;
        private IntPtr _ogvHwnd;
        private IntPtr _poshProcessHandle;
        private int _poshPid;
        private bool _ogvWindowFound;

        public WindowHelper()
        {
            Process process = Process.GetCurrentProcess();
            _mainHwnd = process.MainWindowHandle;
            _poshProcessHandle = process.Handle;
            _poshPid = process.Id;
        }

        public void WaitForOutGridViewWindowToClose()
        {
            do 
            {
                _ogvWindowFound = false;
                EnumChildWindows(IntPtr.Zero, EnumChildWindowsHandler,
                                 IntPtr.Zero);
                Thread.Sleep(500);
            } while (_ogvWindowFound);
        }

        [DllImport("User32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool EnumChildWindows(
            IntPtr parentHandle, Win32Callback callback, IntPtr lParam);

        [DllImport("Oleacc.dll")]
        public static extern IntPtr GetProcessHandleFromHwnd(IntPtr hwnd);

        [DllImport("Kernel32.dll")]
        public static extern int GetProcessId(IntPtr handle);

        [DllImport("Kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool DuplicateHandle(
            IntPtr hSourceProcessHandle, 
            IntPtr hSourceHandle, 
            IntPtr hTargetProcessHandle,
            out IntPtr lpTargetHandle,
            int dwDesiredAccess,
            bool bInheritHandle,
            int dwOptions);

        [DllImport("Kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("Kernel32.dll")]
        public static extern int GetLastError();

        private bool EnumChildWindowsHandler(IntPtr hwnd, IntPtr lParam)
        {
            if (_ogvHwnd == IntPtr.Zero)
            {
                IntPtr hProcess = GetProcessHandleFromHwnd(hwnd);
                IntPtr hProcessDup;
                if (!DuplicateHandle(hProcess, hProcess, _poshProcessHandle,
                                     out hProcessDup, 
                                     PROCESS_QUERY_LIMITED_INFORMATION,
                                     false, 0))
                {
                    Console.WriteLine("Dup process handle {0:X8} error: {1}",
                                      hProcess.ToInt32(), GetLastError());
                    return true;
                }
                int processId = GetProcessId(hProcessDup);
                if (processId == 0)
                {
                    Console.WriteLine("GetProcessId error:{0}",
                                      GetLastError());
                    return true;
                }
                if (processId == _poshPid)
                {
                    if (hwnd != _mainHwnd)
                    {
                        _ogvHwnd = hwnd;
                        _ogvWindowFound = true;
                        CloseHandle(hProcessDup);
                        return false;
                    }
                }
                CloseHandle(hProcessDup);
            }
            else if (hwnd == _ogvHwnd)
            {
                _ogvWindowFound = true;
                return false;
            }
            return true;
        }
    }
}
'@

Add-Type -TypeDefinition $src

Get-Process | Out-GridView

$helper = new-object Utils.WindowHelper
$helper.WaitForOutGridViewWindowToClose()

"Done!!!!"

ints используются для 16 битов (PDP11 и т. Д.). Перейти к 32-битным архитектурам было трудно. Люди становятся все лучше: вряд ли кто-то предполагает, что указатель будет сильно вписаться (вы не правы?). Или файловые смещения, или метки времени или ...

8 битных символов уже несколько анахронизма. Нам уже нужно 32 бита, чтобы держать все наборы персонажей мира.

Похоже, что вы все еще можете купить IM6100 (I.E. PDP-8 на чипе) из склада. Это 12-битная архитектура.

В семействе DEC PDP-8 было 12-битное слово, хотя вы обычно использовали 8-битный ASCII для вывода (в основном на Teletype). Однако был также 6-битный символьный код, который позволял закодировать 2 символа в одном 12-битном слове.