Автор: admin

Введение в C#: классы

Вадим Бодров

Система классов играет важную роль в современных языках программирования. Как же они реализованы в новом языке C#, созданном корпорацией Microsoft, и зачем нужно изучать С#?

Ответы на эти вопросы зависят от того, как вы собираетесь работать дальше. Если вы хотите создавать приложения для платформы .NET, то вам, скорее всего, не удастся избежать изучения C#. Конечно, можно использовать и Си++, и Visual Basic или любой язык программирования, тем более что независимыми разработчиками создаются трансляторы с APL, Кобола, Eiffel, Haskell, Оберона, Smalltalk, Perl, Python, Паскаля и др. Однако для компилятора, способного генерировать приложения среды .NET CLR (Common Language Runtime), только C# является «родным» языком. Он полностью соответствует идеологии .NET и позволяет наиболее продуктивно работать в среде CLR. В свое время для использования виртуальной машины Java было создано множество так называемых «переходников» (bridges) c различных языков программирования, в частности PERCobol, JPython, Eiffel-to-JavaVM System, Tcl/Java и т.д. Подобные разработки так и не получили должного распространения. Практика показала, что значительно проще изучить новый язык, чем вводить дополнительные расширения в менее подходящую для данных целей систему программирования. И не надо быть провидцем, чтобы утверждать, что бо,льшая часть программистов, создающих приложения для платформы .NET, отдаст предпочтение именно языку C#.

C# является языком объектно-ориентированного программирования, поэтому классы играют в нем основополагающую роль. Более того, все типы данных C#, как встроенные, так и определенные пользователем, порождены от базового класса object. Иными словами, в отличие от Java, где примитивные типы данных отделены от объектных типов, все типы данных в C# являются классами и могут быть разделены на две группы:

ссылочные (reference types);

обычные (value types).

Внешне ссылочные и обычные типы очень похожи, так как аналогично Cи++ в них можно объявлять конструкторы, поля, методы, операторы и т.д. Однако, в отличие от Cи++, обычные типы в C# не позволяют определять классы и не поддерживают наследования. Они описываются с помощью ключевого слова struct и в основном используются для создания небольших объектов. Ссылочные же типы описываются с помощью ключевого слова class и являются указателями, а экземпляры таких типов ссылаются на объект, находящийся в куче (heap). Продемонстрируем сказанное на примере:

using System;

class CValue

{

public int val;

public CValue(int x) {val = x;}

}

class Example_1

{

public static void Main()

{

CValue p1 = new CValue(1);

CValue p2 = p1;

Console.WriteLine(”p1 = {0}, p2 = {1}”,

p1.val, p2.val);

p2.val = 2;

Console.WriteLine(”p1 = {0}, p2 = {1}”,

p1.val, p2.val);

}

}

Откомпилировав и выполнив программу, получим следующий результат:

p1 = 1, p2 = 1

p1 = 2, p2 = 2

Как нетрудно видеть, p2 является всего лишь ссылкой на p1. Тем самым становится очевидно, что при изменении поля val экземпляра класса p2 в действительности изменяется значение соответствующего поля p1. Подобный подход не очень удобен при работе с примитивными типами данных, которые должны содержать само значение, а не ссылку на него (Complex, Point, Rect, FileInfo и т.д.). Для описания таких объектов и предназначены типы значений:

using System;

struct SValue

{

public int val;

public SValue(int x) {val = x;}

}

class Example_2

{

public static void Main()

{

SValue p1 = new SValue(1);

SValue p2 = p1;

Console.WriteLine(”p1 = {0}, p2 = {1}”,

p1.val, p2.val);

p2.val = 2;

Console.WriteLine(”p1 = {0}, p2 = {1}”,

p1.val, p2.val);

}

}

Вот что получится после запуска вышеприведенной программы:

p1 = 1, p2 = 1

p1 = 1, p2 = 2

Из этого следует, что экземпляр класса p2 является самостоятельным объектом, который содержит собственное поле val, не связанное с p1. Использование обычных типов позволяет избежать дополнительного расходования памяти, поскольку не создаются дополнительные ссылки, как в случае с экземплярами классов. Конечно, экономия невелика, если у вас имеется всего несколько небольших объектов типа Complex или Point. Зато для массива, содержащего несколько тысяч таких элементов, картина может в корне измениться. В таблице приведены основные отличия типов class и struct.

Интерфейсы

Классы в языке C# претерпели довольно серьезные изменения по сравнению с языком программирования Cи++, который и был взят за основу. Первое, что бросается в глаза, это невозможность множественного наследования. Такой подход уже знаком тем, кто пишет на языках Object Pascal и Java, а вот программисты Cи++ могут быть несколько озадачены. Хотя при более близком рассмотрении данное ограничение уже не кажется сколь-нибудь серьезным или непродуманным. Во-первых, множественное наследование, реализованное в Cи++, нередко являлось причиной нетривиальных ошибок. (При том что не так уж часто приходится описывать классы с помощью множественного наследования.) Во-вторых, в C#, как и в диалекте Object Pascal фирмы Borland, разрешено наследование от нескольких интерфейсов.

Интерфейсом в C# является тип ссылок, содержащий только абстрактные элементы, не имеющие реализации. Непосредственно реализация этих элементов должна содержаться в классе, производном от данного интерфейса (вы не можете напрямую создавать экземпляры интерфейсов). Интерфейсы C# могут содержать методы, свойства и индексаторы, но в отличие, например, от Java, они не могут содержать константных значений. Рассмотрим простейший пример использования интерфейсов:

using System;

class CShape

{

bool IsShape() {return true;}

}

interface IShape

{

double Square();

}

class CRectangle: CShape, IShape

{

double width;

double height;

public CRectangle(double width, double height)

{

this.width = width;

this.height = height;

}

public double Square()

{

return (width * height);

}

}

class CCircle: CShape, IShape

{

double radius;

public CCircle(double radius)

{

this.radius = radius;

}

public double Square()

{

return (Math.PI * radius * radius);

}

}

class Example_3

{

public static void Main()

{

CRectangle rect = new CRectangle(3, 4);

CCircle circ = new CCircle(5);

Console.WriteLine(rect.Square());

Console.WriteLine(circ.Square());

}

}

Оба объекта, rect и circ, являются производными от базового класса CShape и тем самым они наследуют единственный метод IsShape(). Задав имя интерфейса IShape в объявлениях CRectangle и CCircle, мы указываем на то, что в данных классах содержится реализация всех методов интерфейса IShape. Кроме того, члены интерфейсов не имеют модификаторов доступа. Их область видимости определяется непосредственно реализующим классом.

Свойства

Рассматривая классы языка C#, просто нельзя обойти такое «новшество», как свойства (properties). Надо сказать, что здесь чувствуется влияние языков Object Pascal и Java, в которых свойства всегда являлись неотъемлемой частью классов. Что же представляют собой эти самые свойства? С точки зрения пользователя, свойства выглядят практически так же, как и обычные поля класса. Им можно присваивать некоторые значения и получать их обратно. В то же время свойства имеют бо,льшую функциональность, так как чтение и изменение их значений выполняется с помощью специальных методов класса. Такой подход позволяет изолировать пользовательскую модель класса от ее реализации. Поясним данное определение на конкретном примере:

using System;

using System.Runtime.InteropServices;

class Screen

{

[DllImport(”kernel32.dll”)]

static extern bool SetConsoleTextAttribute(

int hConsoleOutput, ushort wAttributes

);

[DllImport(”kernel32.dll”)]

static extern int GetStdHandle(

uint nStdHandle

);

const uint STD_OUTPUT_HANDLE = 0x0FFFFFFF5;

static Screen()

{

output_handle = GetStdHandle(STD_OUTPUT_HANDLE);

m_attributes  = 7;

}

public static void PrintString(string str)

{

Console.Write(str);

}

public static ushort Attributes

{

get

{

return m_attributes;

}

set

{

m_attributes = value;

SetConsoleTextAttribute(output_handle, value);

}

}

private static ushort m_attributes;

private static int    output_handle;

}

class Example_4

{

public static void Main()

{

for (ushort i = 1; i < 8; i++)

{

Screen.Attributes = i;

Screen.PrintString(”Property Demo

”);

}

}

}

Программа выводит сообщение «Property Demo», используя различные цвета символов (от темно-синего до белого). Давайте попробуем разобраться в том, как она работает. Итак, сначала мы импортируем важные для нас функции API-интерфейса Windows: SetConsoleTextAttribute и GetStdHandle. К сожалению, стандартный класс среды .NET под названием Console не имеет средств управления цветом вывода текстовой информации. Надо полагать, что корпорация Microsoft в будущем все-таки решит эту проблему. Пока же для этих целей придется воспользоваться службой вызова платформы PInvoke (обратите внимание на использование атрибута DllImport). Далее, в конструкторе класса Screen мы получаем стандартный дескриптор потока вывода консольного приложения и помещаем его значение в закрытую переменную output_handle для дальнейшего использования функцией SetConsoleTextAttribute. Кроме этого, мы присваиваем другой переменной m_attributes начальное значение атрибутов экрана (7 соответствует белому цвету символов на черном фоне). Заметим, что в реальных условиях стоило бы получить текущие атрибуты экрана с помощью функции GetConsoleScreenBufferInfo из набора API-интерфейса Windows. В нашем же случае это несколько усложнило бы пример и отвлекло от основной темы.

В классе Screen мы объявили свойство Attributes, для которого определили функцию чтения (getter) и функцию записи (setter). Функция чтения не выполняет каких-либо специфических действий и просто возвращает значение поля m_attributes (в реальной программе она должна бы возвращать значение атрибутов, полученное с помощью все той же GetConsoleScreenBufferInfo). Функция записи несколько сложнее, так как кроме тривиального обновления значения m_attributes она вызывает функцию SetConsoleTextAttribute, устанавливая заданные атрибуты функций вывода текста. Значение устанавливаемых атрибутов передается специальной переменной value. Обратите внимание на то, что поле m_attributes является закрытым, а стало быть, оно не может быть доступно вне класса Screen. Единственным способом чтения и/или изменения этого метода является свойство Attributes.

Свойства позволяют не только возвращать и изменять значение внутренней переменной класса, но и выполнять дополнительные функции. Так, они позволяют произвести проверку значения или выполнить иные действия, как показано в вышеприведенном примере.

В языке C# свойства реализованы на уровне синтаксиса. Более того, рекомендуется вообще не использовать открытых полей классов. На первый взгляд, при таком подходе теряется эффективность из-за того, что операции присваивания будут заменены вызовами функций getter и setter. Отнюдь! Среда .NET сгенерирует для них соответствующий inline-код.

Делегаты

Язык программирования C# хотя и допускает, но все же не поощряет использование указателей. В некоторых ситуациях бывает особенно трудно обойтись без указателей на функции. Для этих целей в C# реализованы так называемые делегаты (delegates), которые иногда еще называют безопасными аналогами указателей на функцию. Ниже приведен простейший пример использования метода-делегата:

using System;

delegate void MyDelegate();

class Example_5

{

static void Func()

{

System.Console.WriteLine(«MyDelegate.Func()»);

}

public static void Main()

{

MyDelegate f = new MyDelegate(Func);

f();

}

}

Помимо того что делегаты обеспечивают типовую защищенность, а следовательно, и повышают безопасность кода, они отличаются от обычных указателей на функции еще и тем, что являются объектами, производными от базового типа System.Delegate. Таким образом, если мы используем делегат для указания на статический метод класса, то он просто связывается с соответствующим методом данного класса. Если же делегат указывает на нестатический метод класса, он связывается уже с методом экземпляра такого класса. Это позволяет избежать нарушения принципов ООП, поскольку методы не могут быть использованы отдельно от класса (объекта), в котором они определены.

Еще одним отличием делегатов от простых указателей на функции является возможность вызова нескольких методов с помощью одного делегата. Рассмотрим это на конкретном примере:

using System;

delegate void MyDelegate(string message);

class Example_6

{

public static void Func1(string message)

{

Console.WriteLine(”{0}: MyDelegate.Func1”, message);

}

public static void Func2(string message)

{

Console.WriteLine(”{0}: MyDelegate.Func2”, message);

}

public static void Main()

{

MyDelegate f1, f2, f3;

f1 = new MyDelegate(Func1);

f2 = new MyDelegate(Func2);

f3 = f1 + f2;

f1(”Calling delegate f1”);

f2(”Calling delegate f2”);

f3(”Calling delegate f3”);

}

}

Откомпилировав и выполнив вышеприведенную программу, получим следующий результат:

Calling delegate f1: MyDelegate.Func1

Calling delegate f2: MyDelegate.Func2

Calling delegate f3: MyDelegate.Func1

Calling delegate f3: MyDelegate.Func2

Из этого следует, что вызов метода-делегата f3, полученного с помощью операции сложения f1 + f2, приводит к последовательному выполнению обоих этих методов. Подобно применению операции сложения с целью объединения делегатов, можно использовать и операцию вычитания, которая, как нетрудно догадаться, выполняет обратное действие.

Способы передачи параметров

Анализируя особенности реализации классов языка C#, хотелось бы уделить внимание и способам передачи параметров метода по ссылке. Иногда возникает потребность в том, чтобы функция возвращала сразу несколько значений. Рассмотрим это на примере программы, вычисляющей квадратный корень:

using System;

class Example_7

{

static int GetRoots(double a, double b, double c,

out double x1, out double x2)

{

double d = b * b — 4 * a * c;

if (d > 0)

{

x1 = -(b + Math.Sqrt(d)) / (2 * a);

x2 = -(b — Math.Sqrt(d)) / (2 * a);

return 2;

} else

if (d == 0)

{

x1 = x2 = -b / (2 * a);

return 1;

} else

{

x1 = x2 = 0;

return 0;

}

}

public static void Main()

{

double x1, x2;

int roots = GetRoots(3, -2, -5, out x1, out x2);

Console.WriteLine(”roots #: {0}”, roots);

if (roots == 2)

Console.WriteLine(”x1 = {0}, x2 = {1}”, x1, x2);

else

if (roots == 1)

Console.WriteLine(”x = {0}”, x1);

}

}

Чтобы функция GetRoots возвращала оба корня уравнения (x1 и x2), мы указали транслятору, что переменные x1 и x2 должны быть переданы по ссылке, применив для этого параметр out. Обратите внимание на то, что нам не обязательно инициализировать переменные x1 и x2 перед вызовом функции GetRoots. Обозначив функцию ключевым словом out, мы добьемся того, что ее аргументы могут использоваться только для возврата какого-то значения, но не для его передачи внутрь функции. Таким образом, подразумевается, что переменная будет инициализирована в теле самой функции. В случае же, если нам по какой-то причине потребуется передать в параметре функции некоторое значение с возможностью его последующего изменения, можно воспользоваться параметром ref. Действие этого параметра очень похоже на действие out, но он позволяет еще и передавать значение параметра телу функции. Второе отличие ключевого слова ref состоит в том, что передаваемый параметр функции должен быть инициализирован предварительно.

Такой метод очень напоминает использование параметра var в списке аргументов функций, принятое в языке программирования Паскаль, и является еще одним отличием от языка Java, где параметры всегда передаются по значению.

Заключение

Язык программирования C#, как и платформа .NET, находится в развитии. В частности, в ближайшее время можно ожидать появления обобщенных шаблонов, которые подобно шаблонам языка Cи++ позволят создавать сильно типизированные классы-коллекции. В любом случае язык программирования C# уже вполне сформировался для того, чтобы его изучить и начать применять в реальных приложениях.

Список литературы

C# Language Specification. Microsoft Corporation, 2000.

Гуннерсон Э. Введение в C#. СПб.: Питер, 2001.

Бесплатная версия .NET Framework SDK Beta 1: www.microsoft.com/downloads.

Обширнейшая информация по платформе .NET: www.gotdotnet.com.

Официальная конференция по языку C#: news://msnews.microsoft.com/ microsoft.public.dotnet.languages.csharp.

Инструментарий С#

Прежде чем начать работу с языком программирования C#, необходимо установить на компьютере набор инструментальных средств под названием .Net Framework SDK, бета-версия которого доступна для бесплатной загрузки непосредственно c Web-страницы корпорации Microsoft [3]. Кроме того, понадобится хороший текстовый редактор, поддерживающий синтаксически настраиваемый ориентированный режим (syntax highlight) и позволяющий выделять ключевые слова в исходных текстах того или иного языка программирования. Я рекомендую программу SharpDevelop (www.icsharpcode.net), распространяемую независимыми программистами на условиях лицензии GNU. В крайнем случае можно использовать любой редактор, способный работать с исходными текстами на языке Cи/Cи++, или даже обычный текстовый редактор Notepad.

C# и Java

Язык программирования C# часто и небезосновательно сравнивают с Java. Оба языка были созданы для аналогичных целей и имеют много общего, в том числе синтаксис, базирующийся на Cи++. В то же время есть и множество различий, относящихся к базовым типам, классам, способам передачи параметров, реализации интерфейсов и т. д. Основным же несходством между C# и Java является то, что Java-приложения работают со средой Java Frameworks and Runtime, а C#-приложения — со средой .NET Framework and Runtime. В полном объеме концепция .NET будет реализована только в новой операционной системе Windows XP (также известна как Whistler), хотя она уже около года активно продвигается корпорацией Microsoft. Похоже, если вы планируете создавать приложения, совместимые с платформой Microsoft, явно стоит поближе познакомиться с Microsoft .NET. Лучшим же языком для создания .NET-приложений, по утверждению самой корпорации Microsoft, является C#.

От двух до…

Исходный текст любого исполняемого приложения, написанного на языке программирования C#, содержит статический метод Main(), — аналог знакомой программистам Си/Си++ функции main(). Именно с этого метода начинается выполнение программы.

Что же произойдет, если исходный текст будет содержать два или более методов Main(), как показано ниже?

using System;

class SayHello

{

public static void Main()

{

Console.WriteLine(”Hello friend!”);

}

}

class SayBye

{

public static void Main()

{

Console.WriteLine(”Bye, bye…”);

}

}

Разумеется, компиляция этого примера вызовет сообщение об ошибке, так как классы SayHello и SayBye абсолютно «равноправны» с точки зрения транслятора. Процесс компиляции будет прерван. Однако существует специальный ключ компилятора /main, с помощью которого можно указать класс, содержащий нужный нам метод Main(). Вышеприведенный пример, откомпилированный с ключом /main:SayHello, напечатает сообщение:

Hello friend!

Если же откомпилировать тот же самый пример, указав ключ /main:SayBye, то текст будет иным:

Bye, bye…

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://bestcode.org/

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

Евгений Каратаев

Мне давно было интересно, можно ли сделать в Cache’ такой запрос, чтобы его можно было бы прокручивать назад, например что-то вроде команды, парной к Fetch, например Prior. Собственные средства Cache’ почему-то не предоставляют такой возможности. Для этого я изучил характер взаимодействия sql-движка с Cache Object Script. В результате исследований выяснилось, что это возможно, хотя и не столь гладко, как бы того хотелось. Надеюсь, читатель с пониманием отнесется к возникшей некрасивости.

Возьмем и сделаем рутину со следующим текстом:

run()

  &sql(declare cur CURSOR for select ID, Name, Home

   from Sample.Person order by ID asc)

  &sql(open cur)

  &sql(fetch cur)

  &sql(close cur)

  q

Скомпилируем и сохраним текст полученной int-рутины. После чего изменим рутину следующим образом:

run()

  &sql(declare cur CURSOR for select ID, Name, Home

   from Sample.Person order by ID desc)

  &sql(open cur)

  &sql(fetch cur)

  &sql(close cur)

  q

И также сохраним текст полученной int-рутины. В запросе можно использовать любую имеющуюся у Вас таблицу, просто в данном случае я использовал таблицу из штатного дистрибутива.

Сличим полученные тексты int-рутин. Ничего особенно романтичного в работе автоматического генератора не наблюдается, за исключением того, что сгенерированные тексты полностью совпадают за исключением замены операции $o() на $zp(), которые друг другу прямо противоположны по направлению. Таким образом, для реализации двунаправленной прокрутки используем оба варианта и попробуем совместить их данные, оставив и использовав коды (рутины) доступа.

Для работы нам потребуются некие дежурные данные. Создаем новый класс, например User.NameList, наследник %Persistent и %Populate. Добавляем ему новое свойство Name:%String. Сохраняем, компилируем. В терминале создаем 10 объектов для теста:

d ##class(User.NameList).Populate()

Запускаем SQL Manager и для проверки что действительно создана таблица sql и содержит тестовые данные, выполняем запрос

select ID, Name from NameList.

Если все было в порядке, то будет показана табличка с двумя колонками и десятком строк. Имена англоязычные, вымышленные. Для проверки работы прокрутки в обе стороны создадим рутину (например FetchBack) с кодом

Test()

n ascHandle,descHandle,ascSelect,descSelect,

n ok,i,AtEnd,Row,ID,Name,State,ascClose,descClose

; первоначальное выражение — «select ID, Name from NameList»

; чтобы ходить по нему, преобразуем в два

s ascSelect=»select ID, Name from NameList order by ID ASC»

s descSelect=»select ID, Name from NameList order by ID DESC»

S ok=##class(%DynamicQuery).SQLPrepare(.descHandle,descSelect)

S ok=##class(%DynamicQuery).SQLExecute(.descHandle)

s descClose=descHandle

S ok=##class(%DynamicQuery).SQLPrepare(.ascHandle,ascSelect)

S ok=##class(%DynamicQuery).SQLExecute(.ascHandle)

s State=$li(ascHandle,1)

s ascClose=ascHandle

; идем на 4 шага вперед

s $li(ascHandle,1)=State

w «4 steps forward»,!

f i=1:1:4 d

. d ##class(%DynamicQuery).SQLFetch(.ascHandle,.Row,.AtEnd)

. q:(AtEnd=1)!(Row=»»)

. s ID=$li(Row,1)

. s Name=$li(Row,2)

. w «ID=»_ID_», Name=»_Name,!

s State=$li(ascHandle)

; возвращаемся на 2 шага назад

s $li(descHandle,1)=State

w «2 steps backward»,!

f i=1:1:2 d

. d ##class(%DynamicQuery).SQLFetch(.descHandle,.Row,.AtEnd)

. q:(AtEnd=1)!(Row=»»)

. s ID=$li(Row,1)

. s Name=$li(Row,2)

. w «ID=»_ID_», Name=»_Name,!

s State=$li(descHandle)

; снова на 4 шага вперед

s $li(ascHandle,1)=State

w «4 steps forward»,!

f i=1:1:4 d

. d ##class(%DynamicQuery).SQLFetch(.ascHandle,.Row,.AtEnd)

. q:(AtEnd=1)!(Row=»»)

. s ID=$li(Row,1)

. s Name=$li(Row,2)

. w «ID=»_ID_», Name=»_Name,!

s State=$li(ascHandle)

d ##class(%DynamicQuery).SQLClose(.ascClose)

d ##class(%DynamicQuery).SQLClose(.descClose)

q

Компилитуем, выполняем. В моем случае это выглядит как

USER>d Test^FetchBack()

4 steps forward

ID=1, Name=Presley,Samantha H.

ID=2, Name=Quine,Keith G.

ID=3, Name=Jones,Elvira A.

ID=4, Name=Townsend,Howard D.

2 steps backward

ID=3, Name=Jones,Elvira A.

ID=2, Name=Quine,Keith G.

4 steps forward

ID=3, Name=Jones,Elvira A.

ID=4, Name=Townsend,Howard D.

ID=5, Name=Uberoth,Juanita D.

ID=6, Name=Van De Griek,Michael K.

Видим, что два использованных запроса гладко сшились по используемому состоянию. Это обусловлено тем, что оба запроса совершенно идентичны за исключением направления сортировки. Исследование кодов возврата функций позволяет сделать суждение о более правильном отношении к закрытию запросов.

Таким образом, составить новый класс или набор классов, аналогичные по интерфейсу штатным, не составляет особых проблем. За исключением того, что имея один запрос мы должны будем сделать из него два. Для этого введем некоторую некрасивость — в теле запроса потребуем указания обеих сортировок и разделителей, ограничивающих собственно запрос и сортировки. Выберем в качестве разделителя символы $$$ и будем полагать, что запрос строится по схеме:

select …

from …

where …

$$$ order by … asc

$$$ order by … desc

И что при этом программист возьмет на себя интеллектуальную работу по повторению сортировки в обоих концах. Поля, попадающие в сортировку, должны действительно определять строку выборки. Если поля в выборке допускают неуникальные строки, то следует ввести поле, введение которого сделает строку уникальной. Это требуется для корректного сшивания сортировок. Впрочем, это достаточно поверхностное теоретическое суждение и после его проверки оно может оказаться неверным в каких-то версиях.

Все, что нам понадобится, это удерживать в одном запросе два описателя вместо одного. При создании запроса сконструируем два объекта и при выполнении операций будем обращаться к соответствующим нашим внутренним объектам и передавать их данные штатному sql-движку.

Внимание привлекает поведение функций доступа, например, класс %DynamicSQLQuery, функция Fetch:

n %qref,rtn Set %qref=$lg(qHandle,1),rtn=$lg(qHandle,2)

Quit:%qref=»»!(rtn=»») $$$ERROR($$$GeneralError,»Query not Prepared»)

QUIT $$Fetch^@rtn

Как видно по тексту, сама функция принимает и передает qHandle по ссылке, но к сгенерированной рутине обращается, передавая значения через локальные переменные. Код сгенерированной рутины закрыт, но судя по тому, что состояние qHandle должно быть передано наружу, ее модифицировать может только вызываемая рутина $$Fetch^@rtn. Других проблемных моментов я не нашел, поэтому к делу.

Экспортируем классы %DynamicQuery, %DynamicSQLQuery и $ResultSet в cdl. Дописываем к их именам символ 2 и правим коды так, чтобы у %DynamicSQLQuery2 была внутренняя поддержка обратной прокрутки, более развернутого хендла, чтобы у класса %DynamicQuery использовался запрос типа %DynamicSQLQuery2 и чтобы класс %ResultSet2 имел еще одну функцию, обращающуюся к FetchBack.

Получившиеся у меня для Cache’ 4.1.9 классы можно загрузить по ссылке в конце страницы.

Проверочный код примерно следующего вида:

run()

  n result,i

  Set result=##class(%ResultSet2).%New(«%DynamicQuery2:SQL»)

  Do result.Prepare(«select ID, Name from NameList

   $$$ order by ID ASC $$$ order by ID DESC»)

  Do result.Execute()

  f i=1:1:4 d

  . d result.Next()

  . Write result.Get(«ID»),result.Get(«Name»),!

  f i=1:1:2 d

  . d result.Prior()

  . Write result.Get(«ID»),result.Get(«Name»),!

  f i=1:1:4 d

  . d result.Next()

  . Write result.Get(«ID»),result.Get(«Name»),!

  Do result.%Close()

  q

В результате его работы в терминале выдаются примерно следующие данные:

USER>d run^fetch()

1Presley,Samantha H.

2Quine,Keith G.

3Jones,Elvira A.

4Townsend,Howard D.

3Jones,Elvira A.

2Quine,Keith G.

3Jones,Elvira A.

4Townsend,Howard D.

5Uberoth,Juanita D.

6Van De Griek,Michael K.

Поскольку данные сгенерированы случайным образом, в Вашем случае они могут выглядеть иначе.

К неприятностям метода можно отнести следующие обстоятельства —

Использование нестандартного набора классов

Но что мешает изменить штатные классы, если это очень нужно?

Использование нештатной sql конструкции

Но штатной нет, а какая разница, какие символы будут там написаны? Все равно ведь что-то писать надо будет.

В версии Cache 5 появился дополнительный класс %ScrollableResultSet, который примерно то же самое и делает, и кроме того объект этого класса может быть сохранен в базе данных. Это позволяет просто организовать подкачку страниц например для веб интерфейса — выдачу строк порциями с сохранением контекста запроса между обращениями к базе например.

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://karataev.nm.ru/

Закон Мура

Основные характеристики компьютеров улучшаются в два раза каждые два года.

В 1960-е годы, в самом начале информационной революции, Гордон Мур, впоследствии один из основателей корпорации Intel, обратил внимание на интересную закономерность в развитии компьютеров. Он заметил, что объем компьютерной памяти удваивается примерно каждые два года. Эта закономерность стала своего рода эмпирическим правилом в компьютерной промышленности, и вскоре оказалось, что не только память, но и каждый показатель производительности компьютера — размер микросхем, скорость процессора и т. д. — подчиняется этому правилу.

Последующее развитие компьютеров шло в соответствии с «законом» Мура. Поразительно, но в последние десятилетия мы стали свидетелями нескольких настоящих революций в области технологий. Мы прошли путь от компьютеров на ламповых транзисторах к компьютерам на интегральных схемах и далее — к компьютерам на микропроцессорах, и каждый раз закон Мура находил подтверждение. В 1960-е годы ни один человек в Силиконовой долине не мог даже предположить, что современные технологии производства позволят размещать миллионы элементов в кремниевом кристалле (чипе) размером с почтовую марку. Но когда в соответствии с законом Мура должна была возникнуть такая степень интеграции, она возникла. Правда, закон Мура, похоже, стал действовать быстрее — за последние несколько лет период удвоения производительности сократился с двух лет до полутора.

Однако рано или поздно законы природы положат конец господству закона Мура. Взять, к примеру, размеры элементов микросхемы. Закон предсказывает, что к 2060 году они должны будут стать размером с одиночный атом — что невозможно с точки зрения квантовой механики.

***

Гордон Эрл МУР

Gordon Earle Moore, р. 1929

Американский компьютерный инженер и бизнесмен. Родился в Сан-Франциско, получил докторскую степень в области химической физики в Калифорнийском технологическом институте. Некоторое время работал под руководством Вильяма Шокли (William Shockley, 1910–89), одного из изобретателей транзистора, и занимался изучением полупроводников. Но в характере Шокли начала проявляться эксцентричность, поведение его стало непредсказуемым, и Мур и несколько его коллег уволились. С одним из них, Робертом Нойсом (Robert Noyce, 1927–90), в 1968 году Мур основал корпорацию Intel (где до сих пор занимает должность почетного председателя совета директоров) и приступил к разработке и производству сложных интегральных схем — «чипов», — лежащих в основе современных персональных компьютеров. «Закон» Мура впервые был изложен в 1965 году в журнале «Электроника» в комментарии ученого к статье о том, как технология интегральных схем должна привести к снижению стоимости компьютеров.

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://elementy.ru/

В.М. Курейчик

Генетические алгоритмы (ГА) есть поисковые алгоритмы, основанные на механизмах натуральной селекции и натуральной генетики. Они реализуют «выживание сильнейших» среди рассмотренных структур, формируя и изменяя поисковый алгоритм на основе моделирования эволюции [1-7].

Основой для возникновения генетических алгоритмов считается модель биологической эволюции и методы случайного поиска [ 6, 7 ]. Один из известных специалистов в мире в области случайного поиска и стохастической оптимизации Растригин пишет [ 6 ]. Случайный поиск (СП) возник как реализация простейшей модели эволюции, когда случайные мутации моделировались случайнымишагами оптимального решения, а отбор “уходом” неудачных вариантов. Например, для прикладных оптимизационных задач

K(X)   extr,

здесь K- функционая, X- искомое решение, extr – экстремум (принимает

в зависимости от условий задачи минимальное или максимальное значение).

Тогда, например, для максимизации

K(X)       min      X*,

где X* — наилучшее решение.

Это выражение реализуется с учетом ограничений и граничных условий. Эволюционный поиск согласно [6] – это последовательное преобразование одного конечного множества промежуточных решений в другое. Само преобразование можно назвать алгоритмом поиска или алгоритмом эволюции.

Растригин выделяет три особенности алгоритма эволюции:

– каждая новая популяция состоит только из “жизнеспособных” хромосом;

– каждая новая популяция “лучше” (в смысле целевой функции) предыдущей;

– в процессе эволюции последующая популяция зависит только от предыдущей [ 7 ].

Согласно [7] природа, реализуя эволюцию, как бы решает оптимизационную задачу на основе случайного поиска. Выделяется три основных бионических эвристики случайного поиска:

– клеточный СП,

– моделирование целесообразного поведения особей,

– моделирование передачи наследуемой биологической информации.

Законы эволюции отбирают все ценное и пригодное для эволюции и отметают в сторону, как мусор, как непригодное, все отсталое. Они не знают ни пощады ни состродания и производят оценку каждого лишь по степени пригодности или непригодности ею для дальнейшего развития.

Простой генетический алгоритм был впервые описан Гольдбергом на основе работ Холланда [1,2]. Механизм простого ГА (ПГА) несложен. Он копирует последовательности и переставляет их части. Предварительно ГА случайно генерирует популяцию последовательностей – стрингов (хромосом). Затем ГА применяет множество простых операций к начальной популяции и генерирует новые популяции. ПГА состоит из 3 операторов:  репродукция, кроссинговер, мутация. Р е п р о д у к ц и я  — процесс, в котором хромосомы копируются согласно их целевой функции (ЦФ). Копирование хромосом с «лучшим» значением ЦФ имеет большую вероятность для их попадания в следующую генерацию. Оператор репродукции (ОР), является искусственной версией натуральной селекции, “выживания сильнейших” по Дарвину. После выполнения ОР оператор кроссинговера (ОК) может выполниться в 3 шага. На первом шаге члены нового репродуцированного множества хромосом выбираются сначала. Далее каждая пара хромосом (стрингов) пересекается по следующему правилу: целая позиция k вдоль стринга выбирается случайно между l и длиной хромосомы меньше единицы т.е. в интервале (1,L-1). Длина L хромосомы это число значащих цифр в его двоичном коде. Число k, выбранное случайно между первым и последним членами, называется точкой ОК или разделяющим знаком.

Механизм ОР и ОК. Он включает случайную генерацию чисел, копирование хромосом и частичный обмен информацией между хромосомами.

Генерация ГА начинается с репродукции. Мы выбираем хромосомы для следующей генерации, вращая колесо рулетки, такое количество раз, которое соответствует мощности начальной популяции. Величину отношения  называют вероятностью выбора копий (хромосом) при ОР и обозначают

                                      (1)

здесь fi(x)- значение ЦФ i-той хромосомы в популяции, sum f(x)- суммарное значение ЦФ всех хромосом в популяции. Величину (1) также называют нормализованной величиной.Ожидаемое число копий i-ой хромосомы после ОР определяют

                                       (2)

где n- число анализируемых хромосом.

Число копий хромосомы, переходящее в следующее положение, иногда определяют на основе выражения

 .                                          (3)

Далее, согласно схеме классического ПГА, выполняется оператор мутации. Считают, что мутация — вторичный механизм в ГА.

Понятие «схема» (схемата), согласно Холланду, есть шаблон, описывающий подмножество стрингов, имеющих подобные значения в некоторых позициях стринга [8]. Для этого вводится новый алфавит {0,1,*}, где * — означает: не имеет значения 1 или 0. Для вычисления числа схем или их границы в популяции требуются точные значения о каждом стринге в популяции.

Для количественной оценки схем введены 2 характеристики [1,2]: порядок схемы — О(H);  определенная длина схемы — L(H). Порядок схемы — число закрепленных позиций (в двоичном алфавите — число единиц и нулей), представленных в шаблоне.

Предположим, что заданы шаг (временной) t, m примеров частичных схем H, содержащихся в популяции A(t). Все это записывают как m=m(H,t) — возможное различное число различных схем H в различное время t.

В течение репродукции стринги копируются согласно их ЦФ или более точно: стринг A(i) получает выбор с вероятностью, определяемой выражением (1).

После сбора непересекающихся популяций размера n с перемещением из популяции A(t) мы ожидаем иметь m(H,t+1) представителей схемы H в популяции за время t+1. Это вычисляется уравнением

m(H,t+1)=m(H,t) * n * f(H)/sum[ f(j) ],     (4)

где f(H) – есть средняя ЦФ стрингов, представленных схемой H за время t.

Если обозначить среднюю ЦФ всей популяции как f*=sum[f(j)]/n,  тогда

m(H,t+1)=m(H,t)*f(H)/f* .                           (5)

Правило репродукции Холланда: схема с ЦФ выше средней “живет”, копируется и с ниже средней ЦФ “умирает” [1].

Предположим, что схема H остается с выше средней ЦФ с величиной c?f*, где c-константа. Тогда выражение (5) можно модифицировать так

m(H,t+1)=m(H,t)*(f*+c*f*)/f*=(1+c)*m(H,t)  (6)

Некоторые исследователи считают, что репродукция может привести к экспоненциальному уменьшению или увеличению схем, особенно если выполнять генерации параллельно [3-5].

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

Очевидно, что нижняя граница вероятности выживания схемы после применения ОК может вычислена для любой схемы. Так как схема выживает, когда точка ОК попадает вне «определенной длины», то вероятность выживания для простого ОК  запишется

P(s)=1-O(H)/(L-1).                                 (7)

Если ОК выполняется посредством случайного выбора, например, с вероятностью P(ОК), то вероятность выживания схемы определится

P(s)?1-P(ОК)*L(H)/(L-1).                           (8)

Допуская независимость репродукции (ОР) и ОК, получим [1]:

 m(H,t+1) ? m(H,t) * f(H)/f* *[1-P(ОК) * 

                L(H)/(l-L)].                                   (9)

Из выражения (9) следует, что схемы с выше средней ЦФ и короткой L(H) имеют возможность экспоненциального роста в новой популяции.

Рассмотрим влияние мутации на возможности выживания. ОМ есть случайная альтернативная перестановка элементов в стринге с вероятностью Р(ОМ). Для того, чтобы схема H выжила, все специфические позиции должны выжить. Следовательно, единственная хромосома выживает с вероятностью (1-P(ОМ)) и частная схема выживает, когда каждая из l(H) закрепленных позиций схемы выживает.

1-L(H)*Р(ОМ).                                    (10)

Тогда мы ожидаем, что частная схема H получает ожидаемое число копий в следующей генерации после ОР,ОК ОМ

m(H,t+1)>m(H,t)*f(H)/f**[1-Р(ОК)*l(H)/(l-1)-

               l(H)*P(ОМ)].                  (11)

Это выражение называется «схема теорем» или фундаментальная теорема ГА [1].

Ответа на вопрос, почему необходимо давать выживание схемам с лучшей ЦФ, нет или он расплывчатый, или каждый раз зависит от конкретной задачи.

Основная  теорема  ГА, приведенная  Холландом, показывает ассимптотическое  число схем «выживающих” при реализации ПГА на каждой итерации. Очевидно,что это число, конечно приблизительное и меняется в зависимости от вероятности применения ГА. Особенно сильное влияние на число «выживающих» и «умирающих» схем  при реализации ПГА оказывает значение целевой функции отдельной хромосомы и всей популяции.

Во многих проблемах имеются специальные знания, позволяющие построить аппроксимационную модель. При использовании ГА это может уменьшить объем и время вычислений и упростить моделирование функций, сократить число ошибок моделирования.

ГА — это мощная стратегия выхода из локальных оптимумов. Она заключается в параллельной обработке множества альтернативных решений с концентрацией поиска на наиболее перспективных из них. Причем периодически в каждой итерации можно проводить стохастические изменения в менее перспективных решениях. Предложенные схемы эффективно используются для решения задач искусственного интеллекта и комбинаторно-логических задач на графах. ГА позволяют одновременно анализировать некоторое подмножество решений, формируя квазиоптимальные решения. Временная сложность алгоритмов зависит от параметров генетического поиска и числа генераций.

Список литературы

Holland John H., Adaptation in Natural and Artificial Systems: An Introductory Analysis with Application to Biology, Control, and Artificial Intelligence. University of Michigan , 1975.

Goldberd David E. Genetic Algorithms in Search, Optimization and Machine Learning. Addison-Wesley Publishing Company, Inc. 1989, 412p.

Handbook of Genetic Algorithms, Edited by Lawrence Davis, Van Nostrand Reinhold, New York, 1991, 385p.

Курейчик В.М., Лях А.В. Задачи моделирования эволюции в САПР. Труды международной конференции (CAD-93), РФ — США, Москва, 1993.

Chambers L.D., Practical Handbook of Genetic Algorithms. CRS Press, Boca        Ration FL, 1995, v. 1, 560 p., v. 2, 448 p.

Растригин Л.А. статистические методы поиска. М: Наука, 1968.

Эволюционные вычисления и генетические алгоритмы. Составители Гудман Э.Д., Коваленко А.П. Обозрение прикладной и промышленной математики, том 3, вып. 5, Москва, ТВП, 1996, 760с.

Flash. Кривые Безье

Сегодня мы поговорим о кривых, или, как их еще иначе называют, о путях. Эта тема была выбрана не случайно. Мы не раз уже обращали ваше внимание на то, что Flash — это программа, в большей степени работающая с векторными элементами, а пути являются основой практически любого вектора. Следует также отметить, что раньше мы рассматривали программы, предназначенные для обработки растровых изображений, такие как Adobe PhotoShop, Corel Photo-Paint, поэтому о векторах говорили лишь обзорно, но пришло время это исправить.

Вспомним отличия между растровой и векторной графиками. Растр — это массив элементарных точек, пикселей, из которых составляется изображение. Векторная графика основана на математических формулах, описывающих неровности контуров и способ заливки.

В PhotoShop, например, есть целая группа инструментов для работы с путями, основой которой является Pen. Подобные инструменты вы можете встретить в любом редакторе векторной графики и в большинстве хороших растровых программ.

Причина этому проста — во всех продуктах пути создаются и редактируются по одному принципу, так как в их основе лежит одно понятие — кривые Безье.

Создателем их еще в 68 году стал французский ученый, математик и инженер Пьер Безье. Тогда это все делалось для необходимости тяжелой промышленности. Пьеру была поставлена задача: научиться минимальными машинными ресурсами максимально просто и обобщенно описывать любые сложные плоскостные формы. Это нужно было для машин по обработке листового металла, которые вырезали из него необходимые детали.

Безье справился не просто хорошо, а гениально. Его система кривых, основанная на тригонометрических формулах, оказалась настолько простой и удачной, что легла в основу не только графических, но и многих других программ.

В компьютерной графике кривые Безье занимают чуть ли не главное место. Это не только основа векторной графики, но и способ описания шрифтов, универсальный способ передачи выделения. Научившись работать с ними в одной программе, вы не будете иметь никаких затруднений при работе с множеством других — повторимся, принцип везде одинаков.

Прежде, чем что-то изучать, нужно понять, какую функцию выполняет этот инструмент, средство.

Самая главная функция контуров, которая была и остается основной причиной их использования, — рисование различных геометрических фигур разной степени точности.

Согласитесь, создать правильные с точки зрения геометрии, ровные фигуры при помощи инструментов рисования не просто сложно, а фантастически сложно. Для этого нужно было бы обладать хорошими художественными способностями, серьезными навыками работы и профессиональными манипуляторами. Эти условия противоречат основной концепции практически любого графического редактора — в программе хорошие работы может делать человек, который руками рисовать совершенно не умеет.

А при помощи кривых создание сложных фигур сводится к очень простым и интуитивно понятным манипуляциям.

Кроме того, фигуры, нарисованные при помощи контуров, можно трансформировать и масштабировать без потери качества (в этом одно из главных достоинств векторной графики вообще).

Именно благодаря существованию контуров в растровой графике возможно качественное создание логотипов и тому подобных работ (хотя чаще все же используются специальные программы, предназначенные для работы с векторами).

Второе основное значение путей — выделение. Если обратиться вновь ко всеми уважаемой и любимой программе PhotoShop, то в ранних версия, например в 3, большая часть работы с выделением никак не могла обойтись без этого столь замечательного инструмента. С развитием программы появились и другие способы маскирования, однако пути не утратили своей актуальности и в данный момент, и иногда все же удобнее выделять при помощи инструментов группы Pen (Перо). Кроме того, контуры сохраняются во многих типах файлов, в отличие от чистого выделения и Альфа каналов. И при хранении размер файла от добавления в него контура почти не увеличивается, что нельзя сказать про другие способы выделения. Именно поэтому довольно часто в коммерческих библиотеках изображений, которые можно купить на CD носителях, изображения поставляются с обтравочными контурами.

Пути применяются и при создании множества эффектов, и для треппинга, и во множестве других случаев, перечислить которые просто не представляется возможным.

Рассмотрим несколько подробнее путь, из чего он состоит и как с ним работать.

Структура контура

Самое тяжелое в работе с контурами — научиться ими пользоваться сознательно. А это, наверное, наиболее тяжелый момент в изучении программы, если раньше вы не сталкивались с данным инструментом. Конечно, есть определенные правила, которые мы изложим чуть ниже, но все же успех в основном зависит не от этого.  

В контурах, как нигде, нужно интуитивно чувствовать, к чему приведет то или иное изменение. А достигается это только одним способом — в ходе собственной практики.

Посмотрите на рисунок. На нем показана структура контура.

Как видно, контур состоит из четырех основных элементов.

1. Непосредственно кривая Безье. То, ради чего все и делается. Именно она называется контуром и является объектом нашей деятельности. Все остальные элементы служат только для того, чтобы придать кривой нужную форму. То есть, этот элемент можно назвать основополагающим, все остальные — вспомогательными.

2. Якорная точка (Anchor Point). Кривая Безье с двух сторон ограничена именно этими линиями, они во многом определят ее форму. В случае, если в контуре больше двух якорных точек, то, следовательно, он состоит из множества кривых Безье. Якорные точки можно передвигать относительно друг друга, настраивая вид пути.

3. Направляющая линия (Control Handle). Эта линия выходит из якорной точки. Она является касательной к кривой Безье. Для тех, кто не очень помнит математику, объясним — это значит, что эта линия касается прямой только в одной точке и что любые изменения, которые вы будете производить с направляющей линией, будут самым прямым образом отражаться и на кривой. Направляющих может быть одна или две.

4. Маркер. Именно так называется этот фрагмент, которым заканчивается направляющая линия. Служит маркер для одной цели — изменения длины и положения направляющих. С положением все ясно — уже было сказано, что это касательная к кривой Безье, поэтому, меняя положение, мы меняем ее форму. Такое же важное значение имеет и длина направляющих. Она определяет амплитуду кривой, или, если проще, — степень «выгнутости».

Таким образом, первый вывод относительно контуров — залог качественной работы с ними скрывается в умении пользоваться, прежде всего, направляющими.

Виды якорных точек

Во Flash существует два типа якорных точек. Разработчики назвали их Smooth (Гладкие) и Corner (Острые). Эта тонкость очень повышает удобство работы с контурами, но новичкам осваивать гораздо сложнее, чем если бы был один тип.

Сначала поговорим про более простые, гладкие якорные точки. Гладкий угол всегда имеет две направляющие с разных сторон. Они взаимосвязаны — при повороте одной на определенный градус точно так же поворачивается вторая. Лучше всего воспринимайте их как одну линию — это наиболее прямая аналогия.

При повороте направляющих линий кривая тоже как бы оборачивается. Внешний вид при этом зависит еще и от длины направляющих линий. Данный режим в основном используется для создания плавных, обтекаемых фигур.

Другой тип якорных точек — острые якорные точки. Они отличаются от гладких тем, что у них может быть три варианта наличия вспомогательных линий (в противовес гладким, у которых только один тип — две направляющие линии):

1. Вообще без вспомогательных линий. Да, такое возможно и предназначается для рисования, к примеру, треугольников и им подобных фигур. Работать с таким типом острых якорных точек проще всего.

2. Одна вспомогательная линия. Так как вспомогательные линии в этом режиме, в отличие от режима гладких якорных точек, не связаны, то объект можно трансформировать и при помощи одной линии.

3. Острая якорная точка с двумя направляющими. Наиболее сложный режим. Позволяет создавать действительно сложные формы, не обладающие симметрией.

Внимание

Одним из основных заблуждений начинающих пользователей является то, что они склонны считать пути частью изображения. Это совсем не так. Путь — это вспомогательный элемент, он не несет в себе графической информации в растровом смысле этого слова. Но когда путь создан, его можно или залить пикселями (в растре), или прорисовать линией, или превратить в выделение.

Еще раз повторимся, что, в принципе, при помощи контуров можно передать абсолютно любую форму — все зависит от навыков и таланта. У авторов был знакомый, который умел контурами имитировать подчерк (!) человека. Конечно, это уникальный случай, но про возможности инструментов говорит много.

Рассмотрим основные инструменты работы с путями, которые встречаются практически в каждом графическом редакторе.

Инструменты группы Pen и методы создания контуров при помощи них

Pen Tool (Перо)

Главный инструмент для работы с контурами. Нельзя сказать, что при помощи его выполняется больше работы, чем при помощи других. Дело не в этом. Просто Pen Tool обычно создает основу, путь, почти все другие — только редактируют его.

Есть два основных способа работы с Pen — создание прямоугольных, острых контуров и более сложных, плавных.

Начнем с более простого, с прямоугольных форм. Создайте новый документ. Запустите указанный инструмент. Кликните левой клавишей мыши. Появится первая якорная точка. Отведите курсор немного в сторону и снова кликните. Появится вторая якорная точка и тотчас соединится с первой кривой Безье.

Пользуясь точно такой же технологией и дальше, можно создать достаточно сложный контур.

Если же вы возвращаете курсор к точке начала создания контура, то он приобретает своеобразный вид, что значит, что при клике в эту точку контур будет закончен и превратится в так называемый замкнутый тип контура. Такой контур обладает рядом свойств, в частности, возможностью превращения в выделение.

Несколько сложнее обстоит дело с созданием плавных, обтекаемых форм.

Начинать нужно точно так же, как и при создании прямых узлов. Кликните, поставьте первую оперную точку. Отнесите курсор мыши на достаточное расстояние и снова кликните левой клавишей мыши для того, чтобы поставить вторую якорную точку. Но кнопку мыши после этого не отпускайте и начинайте передвигать курсор, при этом удерживая кнопку мыши.

Сразу появятся направляющие линии, и кривая начнет плавно изгибаться. Один маркер будет располагаться ровно под вашим курсором, то есть с этого момента вы редактируете вид кривой уже при помощи направляющих.

Далее можно преобразовывать полученную кривую, редактируя направляющие.

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

Freeform Pen Tool (Свободное перо)

По своему действию Freeform Pen очень похож на лассо, только создает не выделение, а контур.

Предназначен этот инструмент для создания абсолютно свободных по форме путей. Правда, действительно хорошо с Freeform Lasso работать только при наличии дигитайзера, мышью почти ничего толкового не сделать.

Пользоваться Свободным пером очень просто: зажимаете левую клавишу мыши и двигаете саму мышь. Вся траектория курсора до отпускания клавиши станет контуром.

Magnetic Pen

Этот инструмент встречается не во всех программах, но упомянуть все же стоит. Пользоваться им чрезвычайно просто. Вы кликаете левой клавишей мыши и ставите первую якорную точку. Дальше ведете вдоль объекта, вокруг которого необходимо создать путь, — и компьютер сам определяет, как располагать кривые.

Программа сама расставляет якорные точки в зависимости от перепадов яркости, то есть, сложности контура и своих собственных, определенных пользователем, параметров. Но и вы при создании пути этим способом можете определять места для якорных точек. Это необходимо в случае, когда перепад яркости в этом месте недостаточен для правильного определения программой нужного пути. Add Anchor

Point Tool (Добавить якорную точку)

Этот инструмент не умеет сам создавать пути, однако имеющиеся преобразовывает очень хорошо.

Рассмотрим это на примере. Создайте путь в виде прямоугольника.

Затем возьмите изучаемый инструмент. Кликните по одной стороне прямоугольника. Появится новая якорная точка. Вытяните ее в сторону. В результате одна сторона прямоугольника оказалась как бы раздута.

Точно таким же способом пофантазируйте с контуром и в других местах. Не забывайте о том, что можно настраивать длину направляющих линий и, как следствие, степень влияния перемещения якорной точки на кривую Безье.

Delete Anchor Point Tool (Удалить якорную точку)

Этот инструмент не столь впечатляющ, как предыдущие, и рассматривать его стоит лишь как очень редко полезное дополнение к Add Anchor Point.

При помощи него можно удалять опорные точки из контуров. Это бывает полезно, если, например, какая-либо из них мешает правильной трансформации пути.

Convert Point Tool (Изменить якорную точку)

Относительно сложный в работе инструмент. Служит для редактирования пути через изменение свойств якорных точек и положения направляющих. Сформулируем основные принципы работы этого инструмента.

1. Клик по существующей якорной точке позволяет вытянуть из нее новые направляющие линии гладкого типа.

2. Если линии уже вытянуты, то манипуляции с маркером любой из них превращает якорную точку в острую.

3. Клик по якорной точке с выдвинутыми направляющими убирает их. При этом данный фрагмент пути приобретает «прямой» вид.

Основываясь на этих трех правилах, потренируйтесь немного — и вы научитесь вполне сносно обращаться с этим инструментом.

Здесь рассмотрены не все, но основные инструменты группы Pen (Перо), так как программ достаточно много и в каждой есть свои особенности, связанные с применением данных инструментов, свои дополнительные настройки, клавиатурные эквиваленты, поэтому мы посчитали, что наиболее важным является понять общий принцип работы с данными элементами.

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://www.i2n.ru

Курсовая работа

по

На тему: «Организация хранения и поиска информации в сети Internet»

Введение

Интернет как средство информации в России пока не может конкурировать с традиционными СМИ, но имеет в этом отношении большие перспективы и сможет в дальнейшем выступать наравне с другими информационными ресурсами.

В настоящее время свыше 500 млн. человек более или менее регулярно пользуются

Интернетом, а через два года их число, по мнению экспертов, превысит 1 млрд., иными словами, более 16% населения Земли. Разумеется, такая колоссальная аудитория не могла остаться невостребованной – Интернет давно превратился в огромную информационную площадку.

Во всем мире, а теперь и у нас в стране, наличие работающего Web-сайта становится признаком стабильной, профессиональной работы фирмы. Интернет давно уже стал не только средством общения, но и полем для серьезной коммерческой деятельности. Практически каждая зарубежная фирма имеет в Сети свое представительство, виртуальный офис. Суммарный оборот компаний, ведущих торговлю в Интернет, достигает миллиардов долларов. В России также все большее число компаний использует Интернет для продвижения своих товаров и услуг. В этом легко убедиться, просмотрев рекламные издания. Рядом с привычными номерами телефонов и факсов все чаще и чаще встречаются адреса электронной почты и Web-сайтов. Скоро отсутствие адреса в Интернет будет затруднять работу так же, как отсутствие факса. Тот, кто займет себе место сейчас, существенно выиграет в будущем. Это оперативность и актуальность. Традиционные средства массовой информации при всей их наглядности и привычности уже не способны обеспечить надлежащий уровень оперативности, требуемый современному человеку. Поэтому все больше и больше людей обращаются в Интернет, чтобы получить самую свежую информацию: об услугах и ценах, погоде, курсах валют, просто новости. На Web-сайте можно менять информацию несколько раз в день. В печатных изданиях надо заказывать рекламу минимум за неделю, а то и больше. А в Интернет все оперативно: новые товары или услуги, новая скидка или новый поставщик – завтра об этом узнают клиенты. Нет необходимости ждать, пока выйдет очередной выпуск печатной рекламы. Информация на сайте будет всегда актуальной, самой свежей. Именно это ценят, именно это привлекает в Интернет миллионы пользователей.

1. Хранение данных в сети Internet

1.1 Гипертекстовые документы, виды файлов

Под гипертекстовым документом понимают документ, содержащий так называемые ссылки на другой документ. Реализовано все это через протокол передачи гипертекста HTTP (HyperText Transfer Protocol).

Информация в документах Web может быть найдена по ключевым словам. Это означает, что каждый обозреватель Web содержит определенные ссылки, через которые образуются так называемые гиперсвязи, позволяющие миллионам пользователей Internet вести поиск информации по всему миру.

Гипертекстовые документы создаются на базе языка HTML (HyperText Markup Language). Этот язык весьма прост, управляющие коды его, которые, собственно, и компилируются обозревателем для отображения на экране, состоят из текста ASCII. Ссылки, списки, заголовки, картинки и формы называются элементами языка HTML, которые позволяют щелчком мыши перейти к просмотру другого документа.

Существует два способа создания гипертекстовых документов. Можно воспользоваться одним из WYSIWYG HTML-редакторов (например, Netscape Composer, основы работы с котором рассмотрены в разделе «Обработка текста на ЭВМ», Microsoft FrontPage, HotDog, или др.), для работы с которыми не требуется специальных знаний о внутренней структуре создаваемого документа. Этот способ позволяет создавать документы для WWW без знания языка HTML. HTML-редакторы автоматизируют создание гипертекстовых документов, избавляют от рутинной работы. Однако их возможности ограничены, они сильно увеличивают размер получаемого файла и не всегда полученный с их помощью результат соответствует ожиданиям разработчика. Но, безусловно, этот способ незаменим для новичков в деле подготовки гипертекстовых документов.

Альтернативой служит создание и разметка документа при помощи обычного редактора plain-текста (таких, как emacs или NotePad). При этом способе в текст вручную вставляются команды языка HTML. Создавая документы таким способом, вы точно знаете, что делаете.

Как уже отмечалось, HTML-документ содержит символьную информацию. Одна ее часть – собственно текст, т.е. данные, составляющие содержимое документа. Другая – теги (markup tags), называемые также флагами разметки, – специальные конструкции языка HTML, используемые для разметки документа и управляющие его отображением. Именно теги языка HTML определяют, в каком виде будет представлен текст, какие его компоненты будут исполнять роль гипертекстовых ссылок, какие графические или мультимедийные объекты должны быть включены в документ. Графическая и звуковая информация, включаемая в HTML-документ, хранится в отдельных файлах. Программы просмотра HTML-документов (браузеры) интерпретируют флаги разметки и располагают текст и графику на экране соответствующим образом. Для файлов, содержащие HTML-документы, приняты расширения.htm или.html.

Прописные и строчные буквы при записи тегов не различаются. В большинстве случаев теги используются парами. Пара состоит из открывающего (start tag) и закрывающего (end tag) тегов. Синтаксис открывающего тега:

<имя_тега [атрибуты]>

Прямые скобки, используемые в описании синтаксиса, означают, что данный элемент может отсутствовать. Имя закрывающего тега отличается от имени открывающего лишь тем, что перед ним ставится наклонная черта:

</имя_тега>

Атрибуты тега записываются в следующем формате:

имя [= «значение»]

Кавычки при задании значения аргумента не обязательны и могут быть опущены. Для некоторых атрибутов значение может не указываться. У закрывающего тега атрибутов не бывает.

Действие любого парного тега начинается с того места, где встретился открывающий тег и заканчивается при встрече соответствующего закрывающего тега. Часто пару, состоящую из открывающего и закрывающего тегов, называют контейнером, а часть текста, окаймленную открывающим и закрывающим тегом, – элементом.

Последовательность символов, составляющая текст, может состоять из пробелов, табуляций, символов перехода на новую строку, символов возврата каретки, букв, знаков препинания, цифр, и специальных символов (например, +, #, $, @), за исключением следующих четырех символов, имеющих в HTML специальный смысл: < (меньше), > (больше), & (амперсенд) и » (двойная кавычка). Если необходимо включить в текст какой-либо из этих символов, то следует закодировать его особой последовательностью символов.

К специальным символам можно отнести и неразрывный пробел. Использование этого символа – один из способов увеличить расстояние между некоторыми словами в тексте. Обычные пробелы использовать для этих целей нельзя, так как группа подряд идущих пробелов интерпретируется браузером как один.

1.2 Графические файлы, их виды и особенности

В настоящее время использование полноцветной качественной графики реалистичных цветов на компьютерах класса ПК выглядит совершенно обыденным. Хотя не так давно это было привилегией издательских систем, которые обычно строились на платформах Macintosh или графических станций Silicon Graphics. Пользователи ПК довольствовались же в крайнем случае графикой с цветом, глубиной максимум 8 бит/пиксел (256 цветов) при довольно слабой разрешающей способности 320Х200 или же 16 цветами при разрешении 640Х480.

Сейчас, с развитием архитектур видеоадаптеров и удешевлением видеопамяти на различных микросхемах, среднестатистическому пользователю вполне доступны системы на платформе ПК, успешно работающие с реалистичными (TrueColor) изображениями глубиной 24 бита / пиксел (более 16 млн. цветов).

В связи с техническим прогрессом возникла потребность в перенесении на платформу ПК и адаптации различных форматов кодирования и хранения графической информации с других платформ (например Macintosh, где подобные разработки развиваются в течение уже второго десятка лет), или же разработка собственных, ориентированных на ПК графических форматов, полностью учитывающих все особенности архитектуры их видеоадаптеров.

Более того, в последние 5 лет в связи с молниеносным распространением Internet и, в частности, технологий World Wide Web, стала вставать проблема другого рода – разработка форматов изображений достаточно компактных для передачи в сети с минимальными задержками и аппаратно независимых, так как к сети подключены компьютеры самых различных архитектур.

В связи с этим, хотелось бы кратко рассмотреть несколько распространенных графических форматов и кратко охарактеризовать их возможности. Все эти сведения сведены в нижеследующую таблицу:

Кроме этого следует отметить, что наиболее компактными являются форматы JPEG, GIF, PNG, которые, к тому же, платформенно-независимы. Формат BMP является стандартным форматом Windows, однако большого распространения не получает из-за непомерных размеров файлов, особенно при сохранении графики с глубиной цвета 24 бит/пиксел. Касаемо формата TIFF следует заметить, что он, как и JPEG, GIF, является частично платформенно-независимым, однако слишком объемен для использования в сети и, что еще хуже, слишком сложен для интерпретации. Кроме того любые программные изделия, в том числе и просмотровщики графических файлов, содержащие код для кодирования / декодирования данных по алгоритму LZW должны распространяться по соответствующему лицензионному соглашению компании Unisys Corp., владельца алгоритма, что дополнительно удорожает эти продукты.

Дальнейшее рассмотрение мне хотелось бы обратить к межплатформенным форматам, принятым в Internet в качестве стандарта де-факто: JPEG, GIF, PNG.

Сразу хочу заметить, что формату PNG (Portable Network Graphic) не будет уделено много внимания, хотя, возможно, он его и заслуживает. Это является следствием того, что формат этот появился не так давно и несмотря на все свои достоинства еще не получил всеобщего признания.

Итак, фактически перед человеком или компанией, которая намерена размещать на своих дисках большое количество изображений и, возможно, предоставлять их для использования в Internet, встает дилемма: что выбрать GIF или JPEG.

Формат GIF, разработанный компанией CompuServe, и изначально предлагавшийся именно как формат для обмена изображениями в сети является форматом с достаточно высокой степенью сжатия изображения. Кроме того, GIF обладает дополнительными возможностями, которые делают его использование в сети привлекательным. Первая – это возможность изменения порядка вывода на экран строк изображения, с заполнением промежутков между ними временной информацией. Визуально это выглядит так, что по мере загрузки из сети (что происходит нередко с катастрофически низкой скоростью) изображение на экране появляется как бы «в низком качестве», а затем, по мере подгрузки дополнительной информации, восстанавливает пропущенные строки изображения. Таким образом, пользователь еще до окончания процесса загрузки может получить представление о содержимом изображения и прервать загрузку ненужного файла большого размера. Вторая возможность заключается в хранении в одном файле боле чем одного изображения, что делает возможной элементарную покадровую анимацию. Еще одной отличительной особенностью GIF является то, что один из цветов можно объявить «прозрачным», и тогда при выводе изображения те его части, которые выкрашены этим цветом не будут выводиться на экран и под ними будет виден фон, на который изображение накладывается. Самым же большим недостатком GIF является то, что он может хранить изображение, состоящее максимум из 256 цветов, что в последнее время становиться все менее и менее приемлемым. Вместе с этим, пользователей GIF преследует такая же неприятность, что и в случае с форматом TIFF: GIF также использует LZW-сжатие, а следовательно, каждое изображение может распространяться только при наличии соответствующего лицензионного соглашения.

Формат JPEG является TrueColor-форматом, то есть может хранить изображения с глубиной цвета 24 бит/пиксел. Такой глубины цвета достаточно для практически точного воспроизведения изображений любой сложности. Более глубокое представление цвета (например 32 бит/пиксел) реально оказывается практически неотличимым от данного при просмотре на современных мониторах и при распечатке на большинстве доступных принтеров. Такая глубина цвета может оказаться полезной разве только в издательской деятельности. JPEG в общем обладает более высокой степенью сжатия изображений, нежели GIF (подробнее этот аспект описан в главе «Практики использования JPEG»), но не обладает возможностью хранить несколько изображений в одном файле. Недавно была разработана модификация формата JPEG, получившая название Progressive JPEG, что приблизительно можно перевести на русский язык как «постепенный JPEG», который предназначен для тех же задач, что и чересстрочное отображение GIF-изображений. Это сделало формат JPEG еще более привлекательным в качестве сетевого стандарта. Однако, и в JPEG присутствуют свои недостатки. В отличие от GIF, который может эффективно сжимать изображения практически любого содержания, JPEG ориентирован прежде всего на реалистичные изображения, то есть изображения фотографической направленности, и качество сжатия значительно ухудшается при обработке изображений с четко очерченными линиями и границами цветов.

Таким образом, нельзя до сих пор сделать окончательного выбора в пользу одного или другого формата. Однако, мне формат JPEG представляется более интересным с точки зрения оригинального алгоритма сжатия и больших возможностей для развития в перспективе. Также формат JPEG следует считать однозначно более гибким: он позволяет выбирать между хорошим качеством изображения или хорошей степенью сжатия и находить приемлемый компромисс для каждого конкретного случая. Поэтому все дальнейшее исследование посвящено именно этому формату.

1.3 Поисковые системы и правила поиска информации

Удобство Интернета в том, что в нем можно найти практически любую информацию, даже когда мы не знаем точно, где она находиться. Если адрес страницы с интересующим нас материалом неизвестен и страницы с подходящими ссылками тоже нет, приходиться разыскивать материалы по всему Интернету. Для этого применяют поисковые системы Интернета – специальные web-узлы, позволяющие найти нужный документ.

Существует два основных метода поиска в Интернете. В первом случае вы ищите web-страницы, относящиеся к определенной теме. Поиск производится путем выбора тематической категории и постепенным ее сужением. Подобные поисковые системы называют поисковыми каталогами. Они удобны, когда вам нужно вые познакомиться с новой для себя темой или добраться до широко известных «классических» ресурсов по данной теме. Второй способ поиска используется, когда тема носит узкий, специфический характер или нужны редкие, малоизвестные ресурсы. В этом случае вы должны представлять себе, какие ключевые слова должны встретиться в документе по интересующей вас теме. Эти слова надо выбрать таким образом, чтобы они, скорее всего, имелись в нужных документах, не имеющих отношения к выбранной теме. Системы, позволяющие выполнять подобный поиск, называют поисковыми указателями. Поисковые каталоги отличаются от поисковых указателей не только методом поиска, но и способом формирования. Любая поисковая система Интернета состоит из двух частей. Специализированная web-страница, доступная всем желающим и позволяющая выполнять поиск, опирается на большую, постоянно пополняемую и обновляемую базу данных, которая содержит сведения о ресурсах Интернета.

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

Поисковые указатели, напротив, ориентированы на широту охвата. С определением слов, имеющихся на web-странице, вполне справляется автоматика, данных поискового указателя может охватывать многие миллионы web-страниц. При этом выполнять поиск в указателе труднее, чем в каталоге, потому что одни те же ключевые слова могут встречаться на web-страницах, посвященным разным темам.

Информационно-поисковые системы размещаются в Интернете на общедоступных серверах. Основой поисковых систем являются так называемые поисковые машины, или автоматические индексы. Специальные программы-роботы (известные также как пауки) в автоматическом режиме периодически обследуют Интернет на основе определенных алгоритмов, проводя индексацию найденных документов. Созданные индексные базы данных используются поисковыми машинами для предоставления пользователю доступа к размещенной на узлах Сети информации. Пользователь в рамках соответствующего интерфейса формулирует запрос, который обрабатывается системой, после чего в окно браузера выдаются результаты обработки запроса. Механизмы обработки запросов постоянно совершенствуются, и современные поисковые системы не просто перебирают огромное число документов. – Поиск ведется на основе оригинальных и весьма сложных алгоритмов, а его результаты анализируются и сортируются таким образом, чтобы представленная пользователю информация в наибольшей степени соответствовала его ожиданиям.
В настоящее время в развитии поисковых систем наблюдается тенденция объединения автоматических индексных поисковых машин и составляемых вручную каталогов Интернет-ресурсов. Ресурсы этих систем удачно дополняют друг друга, в объединение их возможностей вполне логично.

Тем не менее исследования возможностей поисковых машин, даже самых мощных из них, таких как AltaVista или HotBot, показывают, что реальная полнота охвата ресурсов Всемирной паутины отдельной такой системой не превышает 30%. Поэтому не стоит ограничиваться использованием какой-либо одной из них. Если вам не удалось отыскать интересующую вас информацию с помощью одной системы, попробуйте воспользоваться другой.

Каждая поисковая Система имеет свои особенности и, и качество полученного результата зависит от предмета поиска и точности формулировки запроса. Поэтому, приступая к поиску информации, прежде всего, нужно четко представлять себе, что именно и где вы хотите найти. Например, зарубежные системы поражают числом проиндексированных документов. Для поиска в области профессиональных знаний, особенно информации на иностранном языке, такие системы, как AltaVista, HotBot или Northern, подходят наилучшим образом.

Однако для поиска информации на русском языке, особенно в российской части Интернета, лучше приспособлены русские поисковые машины. Во-первых, они специально ориентированные именно на русскоязычные ресурсы Сети и, как правило, отличаются большей полнотой охвата и глубиной исследования эти ресурсов. Во-вторых, российские системы работают с учетом морфологии русского языка, то есть в поиск включаются все формы искомых слов. Российские системы лучше учитывают и такую исторически сложившуюся особенность российских Интернет-ресурсов, как сосуществование нескольких кодировок кириллицы.

2. Обзор и характеристика поисковых систем сети Internet

2.1 Rambler

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

Выполним поиск с помощью системы Рамблер. Как вы увидите, эта система обладает удобной системой поиска и выдачи найденной информации.

Вы можете выполнить поиск как во Всемирной паутине, так и в группах новостей, а также в каталоге этой системы и в товарах. Кроме простого запроса имеется возможность работы с детальными запросами. Но мы выполним простой запрос, как и для других русских поисковых машин.

Введите в поле ввода запроса слова поиск Интернет. Мы хотим найти документы, одновременно содержащие слово «поиск» и слово «Интернет».

Нажмите кнопку Найти!. Мы получили список найденных страниц.

Список найденных страниц удобно организован. Вначале расположены ссылки на страницы, наиболее соответствующие критериям поиска. Наиболее полно удовлетворяют запросу документы, в которых искомые слова часто повторяются и стоят недалеко друг от друга. Кроме того, в кратком фрагменте текста найденного документа выделены обнаруженные ключевые слова.

В системе Рамблер можно посмотреть слова, которые наиболее часто используются в запросах пользователей. Кроме того, Рамблер ведёт список наиболее популярных Российских узлов Интернета. Так как вся информация в системе представлена на русском языке мы надеемся, что вы сможете самостоятельно в дальнейшем познакомиться с возможностями данной поисковой машины.

2.2 Yandex

Поисковая система Яndех располагается по адресу www.уаndех.ru. Она была официально введена в эксплуатацию 23 сентября 1997 года.

Что же такое Яndех? Вот как отвечают на этот вопрос создатели системы. Яndех – это полнотекстовая информационно-поисковая система (ИПС), учитывающая морфологию русского и английского языков. Система Яndех предназначена для поиска информации в электронных текстах различной структуры и разных способов представления (форматов). Яndех (произносится «яндекс») расшифровывается как «языковый индекс» или, в английском написании, Yandex – Yet Another INDEX. Также можно рассматривать Яndех как частичный перевод слова Index с английского на русский язык («I» означает «Я»).

В основе поисковой системы Yandex. Ru лежит системное ядро, общее для всех продуктов с префиксом Яndex (Яndex. Site, Яndex. Lib, Яndex. Dict, Яndex.СD). Первые продукты серии Яndex (Яndex. Site, Яndex. Dict) были представлены широкой публике 18 октября 1996 года на выставке Netcom’96. Поисковая машина для «русского Интернета». явилась естественным продолжением линии Яndex. Как уже говорилось, в хорошем вопросе содержится половина ответа. Искать и находить нужное в ворохе текстов в Интернете – умение не только поисковой системы, мо и пользователя, задающего запрос. Яndex не требует от пользователя знания специальных команд для поиска. достаточно набрать вопрос («где найти дешевые компьютеры» или «нужны телефоны Москвы и Московской области»), и вы получите результат – список страниц, где встречаются эти слова. Независимо от того, в какой форме вы употребили слово в запросе, поиск учитывает все его формы по правилам русского языка. Например, если задан запрос идти, то в результате поиска будут найдены ссылки на документы, содержащие слова «идти», «идет», «шел», «шла» и т.д.

Яndex работает не только с языковыми запросами, но и позволяет выполнять поиск только на определенных серверах ИЛИ же исключить из поиска заведомо ненужные серверы. Появилась возможность поиска изображений по подписям к ним и по именам файлов. Также стали доступными для поиска такие объекты, как сценарии, апплеты и стили (поиск осуществляется по названию). Удобная работа с новыми возможностями предлагается на странице расширенного поиска, где сложный язык запросов сведен к заполнению полей в форме. Кроме стандартной сортировки результатов – по релевантности (то есть по степени соответствия запросу), можно отсортировать документы по дате обновления. Интересной особенностью системы является возможность поиска в Яндексе в любом месте Интернета. Для этого нужно загрузить с сайта http://bar.уаndех.ru программу пол названием Яндекс. Бар и установить ее. После этого в окне браузера появится новая панель. Она предназначена для ввода запроса на поиск (без необходимости открывать страницу Яндекса) и выполнения ряда других функций.

По внешнему виду Яндекс представляет собой типичный портал, на главной странице которого можно найти ссылки на материалы практически любой тематики. Но это не единственное его лицо, для «серьезных» пользователей, которые не хотят тратить время на загрузку ненужной в данный момент информации, существует другой Яндекс. Его страница впечатляет скромностью дизайна и скоростью загрузки. Адрес этой эссенции поисковой машины – www.ya.ru.

2.3 Yahoo

Базы данных: в ведении находится служба поиска Internet-ресурсов, новостей, карт, рекламных информаций, спортивная информация, бизнес, номера телефонов, персональные WWW-страницы, и email-адреса (отдельная база данных).

Содержание: Основная директория содержит: адреса (URLs) лля Internet-ресурсов и краткое описание для этих связей.

Поиск: Все Yahoo страницы предлагают не только простое поисковое окно, но и опции для этого поиска, а так же поиск Usenet или Email-адреса. Поиск может ограничиваться указанием определённого промежутка времени. Boolean операторы (и, или) и последовательный поиск также поддержаны. Отметим: если поиск в Yahoo! не привёл к положительному результату, то процесс поиска автоматически переходит на Alta Vista, которая продолжает поиск, и в случае положительных результатов автоматически возвращает найденную информацию в Yahoo!.

Если Yahoo! не может установить связь достаточно быстро с Alta Vista, то в этом случае Yahoo! будет обеспечивать страницу связи с набором инструментов поиска. После того как одна из этих связей выбирается, ключевые слова передаются к поисковой машине на ваше усмотрение.

Средством, облегчающим поиск, является наличие «tip search» (TS) – поиск с помощью «намека»: Yahoo! Является подчиненным справочником, что означает, что система не имеет так много страниц, как поисковые машины, однако задание наиболее общих ключевых слов позволит найти необходимую тему на странице высокого уровня (первая страница, которая возникает перед пользователем при посещении сайта) для организации или компании.

Результаты: Связи отображаются в соответствии с очерёдностью задаваемых слов последовательностью поиска наряду с их описательным текстом и подчиненной иерархией.

Адрес: http://www.yahoo.com/

2.4 Altavista

AltaVista (www. AltaVista.com) – одна из старейших поисковых систем в Интернете. Первый web-индекс был представлен компанией в 1995 году. Ядро поисковой системы обязано своим рождением странной особенности исследовательской лаборатории компании Digital Equipment Corp. Сотрудники этой лаборатории зачем-то хранили всю свою электронную переписку за последние 10 лет. Чтобы эта куча информации не просто занимала дисковое пространство, а приносила хоть какую-то пользу, была создана программа для индексирования документов и поиска нужных слов в ворохе пожелтевшей от времени электронной корреспонденции. Система получилась настолько удачной, что впоследствии с успехом перекочевала на просторы Всемирной паутины.

Индекс AltaVista содержит документы на более чем 25 языках. Локализованные версии сайта AltaVista располагаются в доменах 20 стран. В область поиска можно включить документы на всех поддерживаемых языках или только в документах на определенном языке, а на специальной странице можно узнать несколько языков для поиска на всех выбранных языках одновременно.

Выводы и предложения

настоящее время в сети Internet используются практически все известные линии связи от низкоскоростных телефонных линий до высокоскоростных цифровых спутниковых каналов. Операционные системы, используемые в сети Internet, также отличаются разнообразием. Большинство компьютеров сети Internet работают под ОС Unix или VMS. Широко представлены также специальные маршрутизаторы сети типа NetBlazer или Cisco, чья ОС напоминает ОС Unix.

Фактически Internet состоит из множества локальных и глобальных сетей, принадлежащих различным компаниям и предприятиям, связанных между собой различными линиями связи. Internet можно представить себе в виде мозаики сложенной из небольших сетей разной величины, которые активно взаимодействуют одна с другой, пересылая файлы, сообщения и т.п.

Примером топологии сети Internet может служить сеть Х-Атом, состоящая из нескольких подсетей, и в то же время являющаяся фрагментом всемирной сети Internet.

На сегодняшний день в мире существует более 130 миллионов компьютеров и более 80% из них объединены в различные информационно-вычислительные сети от малых локальных сетей в офисах до глобальных сетей типа Internet. Всемирная тенденция к объединению компьютеров в сети обусловлена рядом важных причин, таких как ускорение передачи информационных сообщений, возможность быстрого обмена информацией между пользователями, получение и передача сообщений (факсов, E – Mail писем и прочего) не отходя от рабочего места, возможность мгновенного получения любой информации из любой точки земного шара, а так же обмен информацией между компьютерами разных фирм производителей работающих под разным программным обеспечением.

Такие огромные потенциальные возможности которые несет в себе вычислительная сеть и тот новый потенциальный подъем который при этом испытывает информационный комплекс, а так же значительное ускорение производственного процесса не дают нам право не принимать это к разработке и не применять их на практике.

Поэтому необходимо разработать принципиальное решение вопроса по организации ИВС (информационно-вычислительной сети) на базе уже существующего компьютерного парка и программного комплекса отвечающего современным научно-техническим требованиям с учетом возрастающих потребностей и возможностью дальнейшего постепенного развития сети в связи с появлением новых технических и программных решений.

Internet продолжает развиваться с неослабевающей интенсивностью, по сути дела стирая ограничение на распространение и получение информации в мире. Однако в этом информационном океане бывает не очень легко найти необходимый документ. Следует также иметь в виду, что в сети наряду с давно действующими серверами возникают новые.

Помимо серверов «общего» назначения имеются специализированные сайты в той или иной области, как например для физики высоких энергий – http://xxx.lanl.gov.

При импортировании файлов статей следует так же иметь в виду, что часто они хранятся в PostScript формате (с расширением, PS’’, EPS’’) предназначенном для распечатывания на лазерном принтере, поэтому в этом случае, после их получения для просмотра и печати на матричном или струйном принтере следует использовать специальную программу, например GhostView.

Не вызывает сомнения, что использование Internet в научной работе позволяет получать самую, горячую’’ информацию и поддерживать контакт с коллегами в мире.

Есть предположение, что Интернет вытеснит и заменит книги. Сейчас этому препятствует ряд факторов. Во-первых, отсутствие комфорта при чтении книг с монитора компьютера. И хотя портативные устройства для чтения электронных текстов уже существует, разрешение их экранов явно недостаточно. Во-вторых, не до конца разработаны авторские права на электронные публикации.

Интернет в перспективе значительно потеснит традиционные средства массовой информации благодаря гибкости, оперативности и интерактивности.

Сегодня множество людей неожиданно для себя открывают для себя существование глобальных сетей, объединяющих компьютеры во всем мире в единое информационное пространство, которое называется Internet. Что это такое, определить непросто. С технической точки зрения Internet – это объединение транснациональных компьютерных сетей, работающих по различным протоколам, связывающих всевозможные типы компьютеров, физически передающих данные по всем доступным типам линий – от витой пары и телефонных проводов до оптоволокна и спутниковых каналов. Большая часть компьютеров в Internet связано по протоколу TCP/IP. Можно сказать, что Internet – это сеть сетей, опутывающая весь земной шар.

Список рекомендуемой литературы

1. Информатика / Курносов А.П., кулев С.В., Улезько А.В. и др.; Под ред. А.П. Курносова.-М: КолосС, 2005. – 72 с. (Учебники и учеб. пособия для студентов высш. учеб. заведений)

2. Практикум по информатике: Учеб. пособие / Под ред. Курносова А.П. – Воронеж: ВГАУ, 2004. -239 с.

3. Информатика. Учебник. – 3-е изд., перераб./ Под ред. Н.В. Макаровой. – М.:Финансы и статистика, 2002. – 256 с.

4. Информатика. Базовый курс / Симонович С.В. и др.-Спб.: Питер, 2006. – 639 с.: ил.

5. Крупник А.Б. Поиск в Интернете: самоучитель. – 2-е изд. – СПБ.: Питер, 2004. – 572 с.

6. Орлов А.А. Нужные программы для Интернета – СПб.: Питер, 2006. – 127 с.

7. Солоницын Ю.А., Холмогоров В. Интернет. Энциклопедия. – 3-е из. – СПб.: Питер, 2003. – 592 с.

8. Резников Ф.А. Быстро и легко осваиваем работу в сети Интернет. – М.: Лучшие книги, 2002. – 284 с.

9. Компьютерные сети и средства защиты информации: Учеб. пособие / Камалян А.К., Кулев С.А., Назаренко К.Н. и др. – Воронеж: ВГАУ, 2003. – 119 с.

10. Олифер В.Г., Олифер Н.А. Компьютерные сети. Принципы, технологии, протоколы. – СПб.: Питер, 2002. – 672 с.: ил.

11. Интернет: Энциклопедия / Под ред. Л. Мелиховой. – 2-е изд.-СПб.; М.; Харьков; Минск; Питер, 2000. – 527 с.

12. Муштоватый И.Ф. Самоучитель по работе в Интернете/ Под общ. ред. М.И. Монастырского. – 2-е изд., доп. и перераб.-Ростов н/Д: Феникс, 2002.-312 с.

13. Попов В. Практикум по Интернет – технологиям: Учебный курс / В. Попов.-СПб.; М.; Харьков; Минск: Питер, 2002. – 476 с.:ил.

14. Компьютерные сети и средства защиты информации: Учебное пособие / Камалян А.К., Кулев С.А., Назаренко К.Н. и др.-Воронеж: ВГАУ, 2003.-119 с.

15. Заика А.А. Компьютерные Сети – М: Олма-Пресс, 2005. -448 с.

16. Компьютерные сети: Учебный курс – 2-е изд. (+CD-ROM). – MicrosoftPress, Русская редакция, 1998.

17. Основы современных компьютерных технологий. Под ред. Хомоненко А.Д. – Корона-принт, СПб 1998.

18. Персональные компьютеры в сетях TCP/IP. Крейг Хант; перев. С англ. – BHV-Киев, 1997.

19. Федеральный закон Российской Федерации «Об информации, информатизации и защите информации» от 20.02.1995 №24-ФЗ.

20. Комер Д. Принципы функционирования Интернета: Пер. с англ./ Д. Комер. – СПБ.; М.; Харьков; Минск: Питер, 2002.-379 с.

2.2.2. Информационный критерий оценки фонетической неопределенности.
При распознавании устной речи необходимо стремиться к тому, чтобы все фонемы классифицировались правильно, поэтому нас интересует распознавание полной последовательности фонетических единиц, составляющих высказывание.
При этом основным источником неопределенности при распознавании речи является сам акустический сигнал. Еще большую неопределенность представляет параметрическое описание речевой волны. Рассмотрим неопределенности акустического сигнала и приведем меру оценки фонетической неопределенности. Используя эти мерь, можно оценить лексическую и фразеологическую неопределенности. Слитная речь расчленяется на последовательность сегментов по признакам способа образования звуков. К этим признакам добавляются признаки места образования, которые изменяются непрерывно как внутри сегментов, так и через их границы [91,97]. С некоторыми дискретными единицами-звуками речи — фонемами или квазифонемами сегменты связаны таким образом, что смысловые единицы речи (слова) представляются цепочкой фонем.

Большинство систем автоматического распознавания речи [79] преобразует речевой сигнал в такую фонемную цепочку, которая затем сравнивается с ожидаемыми в слове звуками. Процесс преобразования речевого сигнала в последовательность фонем включает нахождение признаков, сегментацию и маркировку сегментов.

Опишем модель фонетической неопределенности, позволяющую оценивать результаты неправильного распознавания фонем. Далее будем использовать матрицу ошибок распознавания фонем и фонетическую структуру слов словаря при оценке лексической неопределенности.

Лексическая неопределенность будет иметь место тогда, когда слова неверно классифицируются из-за близости их фонетической структуры, т.е. последовательности параметров, определяющих эту структуру, на конкурирующих словах. Например, в словах «слезать» и «срезать» первичные параметры звуков, входящих в эти слова, сходны. Когда оба эти слова входят в один и тот же словарь, их точная классификация затруднена, поэтому их можно считать лексически неопределенными. В реальных системах, если позволяет задача, следует подбирать слова, чтобы такой ситуации не возникло. Приведем критерии сложности словаря для того, чтобы можно было оценить степень различимости словарей [63].

Рассмотрим распознавание речи как процесс передачи речевой информации через канал с шумом и оценим информацию, теряющуюся в канале.
Потерянная информация является мерой неопределенности или сложности распознавания фонем. В идеальном канале число входных идеальных, полученных после сегментации высказывания экспертами-фонетистами, и выходных фонетических единиц должно быть одинаковым, а последовательность фонем на выходе должна соответствовать входной последовательности. Если же это условие не соблюдается, в канале теряется информация, и в зависимости от величины потерь можно говорить о большей или меньшей неопределенности классификации фонем. При практической оценке фонетической неопределенности в данной работе использовались система признаков [73] и алгоритм сегментации речи на семь типов сегментов:
V — гласный, Т — переходный, М — сонорный, L — низкочастотный, Н — высокочастотный, R — шумный, П — пауза. Затем алгоритм маркировки ставил в соответствие каждому сегменту некоторый фонетический символ, используя априорно полученные гистограммы параметров. От надежности маркировки сегментов во многом зависит точность работы CPP.

Так как СРР рассматривается здесь как канал передачи информации, предположим, что имеются R возможных входных символов алфавита А и s возможных выходов алфавита В . Таким образом, СРР описывается канальной матрицей.

Канал передачи информации, используемой для описания системы распознавания речи, представленной цепочкой фонем, преобразует не зашумленную последовательность звуков в выходную последовательность
«машинных » фонем, содержащую ошибки пропуска, вставки слияния и замены звуков.

Пусть элемента входного фонетического алфавита {Ai} появляются на входе с некоторой априорной вероятностью p(A1 ),р(A2 ),.,p(Ar), а элементы алфавита {Bj} на выходе — с вероятностью P(B1,), p(B2),…, р(Bs). Как отмечено ранее, работу канала передачи входного алфавита {Ai} характеризует канальная матрица, поэтому

P{Bj}=Sri=1P(Ai)*P(Bj/Ai)
|Символ |А |О |И |
|А |0,89 |0,1 |0,01 |
|O |0,15 |0,75 |0,1 |
|И |0,01 |0,1 |0,89 |

2.2 Пример матрицы условных вероятностей распознавания изолированных звуков(2.2)

Информация I(Ai,Bj), получаемая от канала, когда на его вход поступила фонема Ai , а на выходе распознавалась как Bj, , определяется [91]

I(Ai,Bj)=LOG(P(Ai/Bj)/P(Ai)) (2.3)

Средняя информация, получаемая на выходе канала с потерями при передаче
(распознавании) входного алфавита фонем A(Ai), который распознается как алфавит B=(Bj) , будет

I(A, B)=SA, BP(Ai,Bj)*I(Ai,Bj)= SA, BP(Ai,Bj)*LOG2 (P(Ai/Bj)/P(Ai)=

=-SA, BP(Ai,Bj)*LOG2 P(Ai)+ SA, BP(Ai,Bj)*LOG2 (P(Ai/Bj);

I(A, B)=H(A)+SA, BP(Ai,Bj)*LOG2 (P(Ai/Bj); (2.4 )

Отметим, что Н(A)- энтропия, характеризующая степень неопределенности входного алфавита А=(Ai) . Из (2.4) получаем, что

H(A)- I(A, B)=-SA, BP(Ai,Bj)*LOG2 P(Ai/Bj)=

=-SA, BP(Ai,Bj)*P(Bj)LOG2 P(Ai/Bj)=-S BP(Bj)SAP(Ai/Bj)LOG2
P(Ai/Bj)=H(A/B)

Н(А/B)- апостериорная энтропия входного алфавита фонем, которая характеризует меру информации, теряемой в системе распознавания при передаче входного алфавита (Ai) . Апостериорная энтропия и является мерой, оценивающей сложность входного словаря для автоматического распознавания при фиксированном параметрическом описании.

При наличии значений энтропии входного алфавита фонем можно вычислить размер (объем), равный 2H(A), а значения 2 H|(A/B) характеризуют среднее количество возможных альтернативных (конкурентных) элементов алфавита (Ai) на входе СРР после того, как на выходе получили множество (Bj) , т.е. меру сложности распознавания входного алфавита фонем. Назовем эту меру эквивалентным размером алфавита фонем. Значение 2 H|(A/B) можно назвать энтропийным критерием оценки фонетической неопределенности, который является обобщенной характеристикой сложности распознавания алфавита фонем
(Ai) данной системы распознавания. Если СРР работает без ошибок, условная энтропия Н(А/В)=О и эквивалентный размер алфавита фонем 2 H|(A/B) =1.
Естественно, что если Н(А/В)=0, то 2 H|(A/B) =1, а в случае, когда СРР не распознает Н(А/В)=Н(А), то эквивалентный размер алфавита фонем равен 2 H|(A) .

Эквивалентный размер алфавита фонем дает возможность количественно оценить среднее число возможных конкурентных фонем (имеющие близкие параметрические описания), и для его определения необходимо знать апостериорные вероятности P(Ai/Bj) входного алфавита.

Для решения конкретных проблем автоматического распознавания ограниченных наборов слов все многообразие фонем можно свести к двум- трем рабочим фонетическим единицам (например, к классам длительных шумных, звонких и смычных звуков), которые при использовании простой системы признаков и несложных алгоритмов распознавания дают нулевую апостериорную энтропию. Однако при решении задачи распознавания относительно сложных словарей и/иди требование надежной фонетической верификаций произнесенного слова такого количества рабочих фонем сказывается явно недостаточно. Работать же с полным набором фонем «ложно из- за ошибок их автоматического распознавания. Поэтому и приходится идти на компромиссные решения — искать какой-то оптимум при фонетическом описании рабочих словоформ. Эти проблемы будут частично рассмотрены в п. 2.2.3.

Условные вероятности распознавания фонем P(Ai/Bj), определяющие эквивалентный размер фонетического алфавита, можно определить несколькими методами.

83

Статистический метод позволяет получать вероятности распознавания фонем, используя реальную СРР. Это осуществляется путем сравнения результата распознавания системы с точной ручной сегментацией и маркировкой речевого сигнала (иди его параметрического представления), поступающего на вход системы распознавания. В результате получается классическая матрица правильной и ошибочной классификации входного алфавита фонем.

Акустико-параметрический метод, когда матрица ошибок классификации фонем получается путем прямого сравнения их параметрического описания. При этом эталон фонемы выбирается из множества реализации данной фонемы.
Расстояние между фонемами используется для оценки условных вероятностей ошибочной классификации фонем. Точность этого метода зависит от выбранного эталона и объема исследовательского материала.

Кроме этих методов, оценку вероятности ошибочной классификации фонем можно произвести на основе моделирования речеобразующего тракта человека
[7].

2.2.3. Оценка сложности распознавания слов по их фонетической структуре.
Рассмотрим неадаптивную систему распознавания слов как канал передачи информации. Слова входного словаря V=(V1,V2,..,Vr,..,VR) можно представить последовательностью фонетических символов Vr=(Ai1,Ai2,..,Ain) , а слова выходного словаря канала W=(W1,W2,..,Ws,..,WS) –цепочками квазифонетических эталонов Ws=(Bj1,Bj2,…,Bjr) ,где Ai(A , Bj(B – соответственно входной и выходной алфавит фонем канала ; r= 1,R ; s= 1,S ; n = n (r ) ; l= l(s).
Тогда оценку сложности распознавания слов, производимого сравнением входной реализации с цепочками квааифонетических эталонов, можно осуществить на основании анализа матрицы ошибок, подученной при представлении эталонов слов Ws(W поверхностными формами Wsk ( Ws , K=1,
Ks каждого выходного слова. Фактически сложность распознавания входного словаря V определяется наличием сходных эталонных поверхностных форм Wsk выходного словаря W и частотой встречаемости этих поверхностных форм P(Wsk). Основная проблема при построении матрицы ошибок для каждого словаря заключается в формировании эталонов поверхностных форм
Wsk ( Ws , для реализация каждого слова и получения квазифонетического графа f(Ws), учитывающего все поверхностные формы в вероятностями их появления. Все множество квазифонетических поверхностных форм слова Ws, записать в виде эталонного графа трудно, так как при аппаратурно- программном методе распознавания появляются не только поверхностные формы слова, обусловленные особенностями произношения, но и формы, включающие случайные сегменты, маркированные квазифонетическими метками, появление которых связано с не идеальностью автоматической фонетической сегментации и маркировки нашим аппаратурно-программным методом, вызванной, например, изменением интенсивности речевого сигнала.

В дальнейшем будем рассматривать влияние двух обстоятельств на формирование эталонных поверхностных форм слов рабочего словаря, учитывая, что поверхностные формы, связанные о особенностями произношения и матрицей ошибок квазифонемной классификации, можно построить вручную (или автоматически, используя таблицу акустико- фонологических правил, хранящуюся в памяти, и прилагаемых к базовой квазифонетической цепочке), а поверхностные формы Wsk . , обусловленные особенностями аппаратуры выделения информативных признаков, можно получить, анализируя статистику реализации квазифонетических цепочек слов рабочего словаря, полученных с помощью ЭВМ. Получение этой статистики не всегда обязательно, особенно если рассматриваются слова, контрастные по своим акустическим свойствам. Предварительную оценку сложности распознавания слов можно сделать аналогично оценке сложности фонетического алфавита — по фонетической структуре слов, вычисляя апостериорную словесную неопределенность и не исследуя статистики реализации.

Все эталоны слов Wsk рабочих словарей должны быть представлены последовательностью маркированных фонетическими метками отрезков, где квазифонемы должны делиться на опорные, обязательные для данного слова
(определяющие базовую форму и, как Правило, присутствующие во всех поверхностях), и «вспомогательные», трудно классифицируемые. Трудно классифицируемые сегменты должны быть расчленены (хотя бы грубо) на несколько квазифонетических элементов, если длина этих сегментов выше пороговой (это делает на первом этапе человек на основании знаний фонетической структуры возможных форм каждого слова). Опорными сегментами слова следует считать маркированные отрезки которые при их маркировке квазифонетическими метками допускают суммарную ошибку ниже эвристически определенного порога.

При автоматическом распознавании выбор эталонов (из словаря эталонов) должен быть в первую очередь обусловлен наличием в поступившей на вход реализации опорных, обязательных маркированных сегментов о. с учетом того, что за счет не идеальности сегментации общее число сегментов входной реализации может не совпадать с возможным числом сегментов эталонного графа, за счет не опорных сегментов, образующихся или выпадающих случайно.

Ошибки классификации дают появление «путающихся» поверхностных форм
(представленных последовательностью казифонемы для различных слов словаря.
Будем считать, что матрица ошибок при распознавании слов априори формируется таким образом, что (при сходстве поверхностных форм различных слов словаря) более часто встречающиеся поверхностные формы слов одного класса считаются относящимися к словам только этого класса, а редко встречающиеся сходные поверхностные формы для других слов словаря дают ошибки распознавания. Впрочем, используя синонимию или семантико- синтаксические ограничения при распознавании пословно произносимых фраз.
Всегда следует добиваться того, чтобы подобные случаи не происходили
(трудности представляют слова, входящие в одну семантико-синтаксическую группу, которые нельзя заменить синонимами, например, названия цифр).

Следует отметить, что принятые решения о принадлежности поступившей на вход реализации к тому или иному классу следует делать но эталонам с одинаковым числом опорных сегментов и с учетом верификации слова, всякий раз используя эвристически выбранные пороги достоверности, в общем случае разные для различных слов. Так, для принятия окончательного решения о принадлежности входной реализации Vx к классу Ws необходимо выбрать два наиболее вероятных кандидата Ws1 И Ws2 , которым соответствуют вероятности P(Vx/Ws1) и P(Vx/Ws2) ,и проверить, удовлетворяются ли условия:

P(Vx/Ws1)( ? s 1;

P(Vx/Ws1)-P(Vx/Ws1))( ? s1s2 где ?s1 — пороговое значение вероятности того, что входная реализация соответствует слову Ws1 , ? s1s2 — пороговые значения разности условных вероятностей принадлежности входной реализации Vx классам Ws1 и Ws2 , при которых принимается решение о классификации Vx.

Пороговые значения ?s1, ? s1s2 выбираются экспериментально по заданной системе используемых фонетических признаков, а также требуемых точности распознавания и вероятности отказов от распознавания. В случае, если подбором порогов заданные требования к системе распознавания не удается выполнить, следует провести более детальный анализ не опорных сегментов, иди попытаться улучшить систему признаков. В ряде случаев для удовлетворения заданных в системе требований следует использовать синонимию. Рассмотрим далее более конкретно, как оценить лексическую неопределенность словаря V языка речевого общения неадаптивной системы автоматического распознавания. Аналогично тому, как оценивалась неопределенность алфавита фонем, можно определить сложность распознавания входного словаря V , состоящего из R слов, и вычислить эквивалентный размер входного словаря. При этом необходимо получить вероятности P(Vr/Ws) близости областей признакового описания слов Vr( V , Ws( W , r= 1R , s= 1S
, которые представляются в виде последовательности фонетических единиц
(фонетической транскрипции слов). Далее оценим вероятности P(Vr/Ws).

Как уже отмечалось, на основе лингвистических знаний, эталоны слов Ws( W представляются в вида фонетических ( вернее, квазифонетических) цепочек, совокупность которых описывается графом с конечным числом состояния, а каждая фонема — признаками способа и места образования. Слову Ws соответствует одна или несколько траекторий (цепочек поверхностных форм) на графе (количество траекторий зависит от метода произношения и характеристики диктора). Направленный граф f (Ws) представляет все фонемы эталона слова Ws( W , который имеет Wsk, поверхностных форм, K =
1,2,3..,Ks; каждая поверхностная форма Wsk(Ws содержит L=L(s,k) опорных квазифонемы ,

Необходимо отметить, что количество опорных сегментов в поверхностных формах слов выходного словаря различно, т.е. предел изменения индекса L зависит как от номера слова, так и от его поверхностной формы L=L(s,k).

Для того, чтобы осуществить оценку неверной классификации слов словаря на стадии лексического распознавания по фонетической структуре этих слов, выполним операцию разбиения всех поверхностных форм эталонов слов на М фонетических групп с одинаковым количеством опорных сегментов L=L(s) . При этом слова, поверхностные формы которых принадлежат разным группам, не будут путаться между собой, поскольку их легко классифицировать по числу
«опорных» фонем, составляющих слова.

Вообще говоря, можно представить себе фонетические группы эталонных поверхностных форм, отличающиеся не только числом опорных фонем, но и их характером, а также порядком следования. Если учесть все три фактора, позволяющие разбить эталоны на существенно большее число фонетических групп, то дальнейшие рассуждения можно отнести к каждой из этих групп.
Для простоты, однако, будем считать, что мы имеем М фонетических групп, в каждой из которых одинаковое число опорных сегментов. В практических задачах при разбиении на группы следует учитывать все эти факторы, однако необходимо строго ограничивать число различных опорных сегментов, выбирая лишь те, которые не путаются между собой и характеризуются групповыми признаками места образования — ударные гласные, смычные, фрикативные [81,80] .

Итак, допустим, что существуетM фонетических групп слов
W1,W2,W3,…,Wn,…,Wm , в каждой из которых одинаковое число опорных квазифонемы. Общее число эталонов W= Un=1m Wm , а количество фонем, составляющих: слова (длина фонетической цепочки) каждой группы, обозначим через Lm; m=1, M.

Представляя таким образом слова словаря на входе СРР и используя матрицы ошибочной классификации фонем, составляющих слова

P(a/b)=[Pij], (2.5) можно оценить вероятности Pm(Vr/Ws) спутывания поверхностных форм слов внутри каждой группы слов следующим образом:

Pm (Vr/Ws)=П[pic]; (2.7)
Где T=1,2,..,Tm длина фонетической цепочки группы слов Wm , Art ( Vr ,

Bst ( Ws..В общем случае одно и то же слово Ws может иметь Ks, поверхностных форм, имеющих разное число фонетических элементов и попадающих в разные группы слов Wm . Поэтому общую условную вероятность
«спутывания» слов словаря определим

P(Vr/Ws)=[pic] (2.8)

Для определения потери информации в СРР, которая рассматривается как канал передачи информации, в случае распознавания слов используем выражение

I(V/W)=-[pic][pic], (2.9)

То тогда 2I=(V/W) определяет эквивалентный размер словаря — число альтернативных слов на входе системы распознавания, а 2I=(V) — фактический объем входного словаря, где

I(V)=-[pic] , (2.10)

Эти выражения, аналогичные формулам (2.4), (2.5), оценивающим фонетическую неопределенность, являются критерием оценки лексической неопределенности. Они определяют сложность распознавания словаря и позволяют судить о качестве СРР. При автоматической маркировке, наряду с ошибками неверной классификации фонем, существуют, как уже отмечалось, ошибки неверной сегментации, приводящие к слиянию отрезков, соответствующих смежным фонемам, в один сегмент или расчленению отрезка, соответствующего одной фонеме, на несколько смежных фонем разных классов.
При выборе альтернативных слов словаря надо следить за тем, чтобы неприятности такого рода не вызывали подобия последовательностей фонетических единиц, соответствующих разным словам. Для этого необходимо использовать матрицы, отражающие возможные варианты сегментации слов словаря и частоты встречаемости тех или иных вариантов сегментации, соответствующих различит поверхностным формам слов. Так как информация о словах, содержащихся в фонемах, избыточна, то часто при оценке различимости слов словаря вполне достаточно использовать опорные фонемы, допускающие минимум ошибок расчленения и слияния. Поэтому в формуле (2.7) для приближенной оценки спутывания слов необходимо в первую очередь использовать вероятности ошибочного распознавания таких опорных фонем, которые в данном слове не дают ошибок слияния и расчленения.

Мой личный сервер DNS

Наконец-то Internet приобретает человеческие черты. Сегодня любой желающий по- лучает от сети не только услуги электронной почты , но и полный доступ практически ко всем ресурсам Сети. К сожалению, в большинстве случаев используется так называемое «типовое PPP-подключение», реализуемое без приложения мысленных усилий с использо- ванием Windows95 и броузера WWW Explorer или Netscape.

Почему к сожалению? Дело в том, что использование «простейших» средств, как правило, приводит к получению простейших же результатов. Я уже писал о том, что исполь- зование более перспективной операционной системы Linux [1] позволяет повысить реальную пропускную способность арендуемого коммутируемого канала (телефонной линии) почти вдвое! Но и это не предел. В упомянутой мною публикации выигрыш достигался исключи- тельно за счет эффективной работы ядра операционной системы Linux, которая изначально ориентировалась на работу в сетях TCP/IP. Но этим возможности организации эффективной работы в сети никоим образом не исчерпываются! Возьмем хотя бы службу DNS…

Основное назначение службы доменных имен (DNS – Domain Name System) состоит в упрощении навигации в Internet для человека, которому символьную последовательность запомнить гораздо легче, чем десяток цифр. Компьютеру же наоборот – оперировать с чис- лами гораздо легче, да и быстрее. Для разрешения этого противоречия было создано целое семейство различных серверов DNS – программ, единственной функцией которых является преобразование имен типа www.geocities.com в 123.22.22.11 и наоборот.

Задача, казалось бы, тривиальная: таблица из двух полей и большого количества строк – нашел значение в одном поле, взял из второго, и все в порядке… Но на практике и разработчики, и пользователи столкнулись с несколькими препятствиями. Во-первых, не- прерывно растущая сеть постоянно увеличивает количество использованных IP-адресов, что приводит к разбуханию нашей таблицы соответствий до, прямо-таки скажем, просто непри- личных размеров. Во-вторых, информация в этой таблице подвержена непредсказуемым изменениям: узлы появляются и исчезают, меняют свои адреса и имена и так далее. И, нако- нец, самый неприятный момент – Internet не является однородной системой, управляемой чьей-либо «железной рукой» и раздача адресов IP (и присвоение им доменных имен) проис- ходит если и не совсем хаотично, то, во всяком случае, децентрализовано.

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

Конечные пользователи, как правило, подключаются к DNS-серверам своих провай- деров, которые работают в режиме авторитетного сервера для своих пользователей и осуще- ствляют кэширование всех остальных запросов. С точки зрения пользователя Windows эта проблема по-другому и не решается, но как только вы переходите в UNIX и начинаете гово- рить с Internet на общем языке, у вас появляются весьма интересные возможности.

Одной из них является создание собственного локального кэширующего DNS-сервера.

В самом деле, при каждом обращении к удаленному узлу вам приходится запрашивать у провайдера IP-адрес. Клиентов, подобных вам, у провайдера несколько десятков , и на обслуживание вашего запроса уходит драгоценное время, которое, как вы можете заметить, если будете внимательно разглядывать строку состояния в Netscape Navigator или Explorer может составлять 30-40 секунд на каждом обращении к DNS . А при установке собственного сервера вы сможете: ? обеспечить максимальный уровень привилегий в обслуживании запросов DNS – вы ведь единственный и любимый пользователь; ? создать базу данных DNS узлов, к которым постоянно обращаетесь, и узнать из полученной информации немало интересного (подробнее об этом написано в [2]); ? ускорить процедуру установления соединения с серверами Internet.

Поскольку авторитетом для вашего IP-адреса (безразлично, статического или дина- мического) является ваш провайдер, вам достаточно установить простой кэширующий сер- вер. К счастью, программа сервера DNS – bind, едина для всех типов серверов (включая но- мер версии – 4.9.3), а конкретный режим работы определяется только параметрами настрой- ки. Сам же сервер входит в обязательном порядке во все дистрибутивы Linux, и нередко встречается в исходных текстах. Есть только одна неувязочка, о которой стоит предупредить заранее. Пакет c DNS-сервером и в RedHat и в Slackware называется bind (какой-нибудь вер- сии), но исполняемая программа сервера имеет совершенно другое название – named! По- этому, проверяя, не установлен ли сервер DNS в вашей системе, вам придется воспользо- ваться следующими командами: ps -ax » grep named Скорее всего, named в системе не установлен, но лучше все же проверить. Связано это с режимом последующего запуска сервера: первоначальный запуск осуществляется с помощью команды named, а перезапуск, при работающем сервере – командой named.restart. В любом случае, если в вашей изолированной системе уже запущен сервер DNS, его необхо- димо отключить, или, говоря на языке UNIX – «убить» соответствующий процесс .

Теперь необходимо проверить настройку сетевого интерфейса TCP/IP. Для того чтобы локальные серверы вашей системы могли обслуживать запросы локальных же клиентских программ, в TCP/IP предусмотрен специальный адрес IP, называемый localhost, который имеет значение 127.0.0.1.

Расхожее мнение гласит, что этот адрес в любом компьютере является синонимом адреса текущего компьютера и может использоваться наряду с обычным адресом при обра- щении к локальным ресурсам. Действительность же оказывается более суровой. Адрес localhost не может использоваться внешними пользователями для обращения к вашим ре- сурсам, поскольку при таком обращении любой компьютер начинает опрашивать только свои собственные ресурсы. В остальном адрес localhost подчиняется всем правилам, уста- новленным для адресов IP. А это означает, что вы должны не забыть прописать его в файле /etc/hosts, а также подключить маршрут доступа к этому файлу. Как ни странно, но довольно часто именно отсутствие этих двух простых настроек делает невозможным работу с серве- рами и клиентами TCP/IP. Но давайте по порядку.

Во-первых, база данных хостов сети /etc/hosts. Не отвлекаясь на исторические под- робности, отметим, что localhost прописан в ней обычно первой же строкой. За подробно- стями по содержанию этого файла отсылаю вас к статье [1] и к руководствам пользователя.

Справедливости ради должен отметить, что эта проблема в любом дистрибутиве Linux, как правило, решена. Вторая проблема напрямую связана с маршрутизацией в сети. Прежде все- го, вам необходимо определиться, какие маршруты для вашей машины уже определены. Для этого воспользуйтесь командой route: #route Kernel routing table Destination Gateway Genmask  Flags MSS Window Use Iface loopback  *  255.0.0.0  U 3584  0  1  lo Вот что должна сообщать ваша система при правильной конфигурации сетевого ин- терфейса (при этом мы полагаем, что Ethernet-интерфейса в вашей системе нет – в противном случае процесс конфигурирования станет даже проще, ведь у вас появится собственный «аппаратный» IP-адрес, к которому вы сможете обращаться без оглядки на особенности lo- calhost). Обратите внимание, что мы не видим указания на наш любимый адрес localhost. Дело в том, что в данном случае команде route предшествовало включение в таблицу маршру- тизации целой подсети 127.0.0.0 , что, конечно же, решает наши проблемы, но по большому счету, является излишним.

В случае если таблица маршрутизации, формируемая программой route, оказывается пуста, вам необходимо добавить в инициализационный файл настройку маршрута доступа к локальному узлу. Сделать это можно двумя способами: добавив целую подсеть: 127.0.0.0 или один только localhost. Я предпочитаю использовать более предсказуемый по своим по- следствиям второй путь: route add 127.0.0.1 Вообще говоря, для многозадачных и многопользовательских систем, к которым Linux можно отнести с куда большим основанием, чем нашумевшую Windows95 применимо одно важное правило: нужно вводить только те установки среды и конфигурации, которые необходимы для решения конкретных, текущих задач. Ну да ладно, после того, как мы включили в маршрут доступа (и в инициализационный файл) наш localhost, можно присту- пать к настройке собственно сервера DNS. Перегружать компьютер не нужно! Во-первых, мы еще не закончили, а во-вторых, все изменения вступают в силу немедленно после вы- полнения соответствующих утилит , и вы должны лишь позаботиться о том, чтобы необхо- димые настройки устанавливались при последующих запусках системы.

Итак, приступим к конфигурированию named. При загрузке сервер DNS осуществляет считывание собственного инициализационного файла, который обычно имеет имя /etc/named.boot. Вы, безусловно, можете изменить и каталог, и имя инициализационного файла, но для этого вам придется самостоятельно перекомпилировать named из исходных текстов, самостоятельно заменив указанное имя файла на альтернативное. Сложного в этом процессе ничего нет, но мы отвлекаться на это не будем.

Поскольку мы предполагаем реализовать только простейший, кэширующий сервер DNS, то и особых проблем с настройкой сервера пока не предвидится. Вот типовое содер- жание файла named.boot: ; ; Загрузочный файл кэширующего сервера DNS ; directory  /var/named cache  .

root.cache В этом файле вы указываете компьютеру на два обстоятельства: ? Все остальные конфигурационные файлы сервера DNS размещаются в каталоге /var/named. Это традиционный каталог для их размещения, но если вам больше нравится, вы можете создать для этих целей подкаталог, например, в /etc.

? Сервер осуществляет только кэширование, при этом кэшированию подлежат все доменные имена (поскольку в поле домена указана точка – корень для любого доменного имени), а в файле /var/named/root.cache будет помещен набор корневых серверов сети, откуда named будет извлекать всю необходимую информацию.

Теперь самое время взглянуть на содержимое root.cache. В приведенном ниже при- мере помещено содержимое рабочего конфигурационного файла с моего компьютера. Не стоит мудрствовать, просто создайте такой же и пользуйтесь. Единственное замечание: все строки заполняются с первого символа – никаких пробелов «для красоты»! И не забудьте о точках в конце имен серверов…

; ; Список серверов DNS, являющихся конечными авторитетами ; для корня доменной системы имен (последние инстанции) ; .

  IN  NS NS.INTERNIC.NET.

.

  IN  NS AOS.ARL.ARMY.MIL.

.

  IN  NS NS1.ISI.EDU.

.

  IN  NS C.PSI.NET.

.

  IN  NS TERP.UMD.EDU.

.

  IN  NS NS.NASA.GOV.

.

  IN  NS NIC.NORDU.NET.

.

  IN  NS NS.ISC.ORG.

; ; — Соответствие имен DNS-серверов ; —    и их IP-адресов  ; NS.INTERNIC.NET.

 999999 IN A 198.41.0.4 AOS.ARL.ARMY.MIL.

999999 IN A 128.63.4.82 AOS.ARL.ARMY.MIL.

999999 IN A 192.5.25.82 NS1.ISI.EDU.

  999999 IN A 128.9.0.107 C.PSI.NET.

  999999 IN A 192.33.4.12 TERP.UMD.EDU.

 999999 IN A 128.8.10.90 NS.NASA.GOV.

  999999 IN A 128.102.16.10 NS.NASA.GOV.

  999999 IN A 192.52.195.10 NIC.NORDU.NET.

 999999 IN A 192.36.148.17 NS.ISC.ORG.

  999999 IN A 192.5.5.241 В основном эти данные остаются неизменными – можно сказать, что на перечислен- ных выше серверах держится вся доменная система имен. Тем не менее, периодически в сети происходят изменения, и ниже мы рассмотрим, как можно получить более свежую ин- формацию.

Сейчас же мы предположим, что хоть один из введенных нами в конфигурационный файл серверов окажется «на ходу» и завершим процесс конфигурирования. Нам потребуется скорректировать значение файла /etc/resolv.conf. Как вы, вероятно, помните, в этом файле помещается ссылка на сервер DNS, обслуживающий ваши запросы. Ранее (см. [1]), мы по- местили в этот файл информацию следующего содержания: domain rinet.ru nameserver 194.87.171.65 Теперь давайте внесем некоторые корректировки. Во-первых, вместо domain мы по- ставим более современную конструкцию search, а во-вторых, укажем системе на необходи- мость использовать наш собственный сервер DNS. Вот что мы получим в результате : search .rinet.ru .ru nameserver 127.0.0.1 Что означает директива search ? Она указывает серверу DNS, какие домены необхо- димо «обыскивать» при попытках соединения с любыми, принадлежащими им хостами. Но это в теории, а на практике он используется для задания сокращенных доменных имен. В самом деле, предположим, вы постоянно работаете в домене ru, и обращаетесь к поисковой системе www.rambler.ru. При приведенной выше настройке сервера DNS вы можете просто использовать запросы типа www.rambler. Может быть, выигрыш не слишком значителен? А теперь представим, что вам необходимо постоянно обращаться к пользователям узлов с двумя и тремя точками, например: aivanov@informatik.dortmund.de. Объявив всю правую часть адреса в ключе search, вы можете отправлять почту по адресу aivanov, как будто бы ваш собеседник находится не в Германии, а в вашей локальной сети .

Теперь можно приступать к проверке нашего сервера. Подключитесь к провайдеру, и после установления соединения запустите сервер DNS, введя команду named. После запуска named самостоятельно перейдет в фоновый режим и вернет управление в командную строку оболочки. Проверить, все ли в порядке, можно проанализировав файл /var/log/messages, в конце которого вы должны обнаружить что-нибудь вроде: Sep 1 13:05:47 vvv named[197]: starting. named 4.9.3-BETA26 Sun Nov 26 20:58:49 CST 1995 ^Iroot@fuzzy:/tmp/bind-4.9.3-BETA26/named Sep 1 13:05:48 vvv named[197]: cache zone «» loaded (serial 0) Sep 1 13:05:48 vvv named[198]: Ready to answer queries.

В случае появления каких-либо сообщений об ошибках (и естественно, отсутствии сообщения о готовности обрабатывать запросы) проанализируйте файлы named.boot и root.cache. Скорее всего, вы допустили опечатку. Поправьте «слова» в этих файлах, «убейте» процесс named и перезапустите его еще раз.

Поскольку вы в данный момент подключены к сети, то целесообразно сразу же про- верить работоспособность нашего сервера. Попробуйте воспользоваться уже рассматривав- шимися ранее [1] командами ping и traceroute. А попробовав, сравните с результатами, по- лученными для простейшего PPP-подключения с использованием DNS-сервера вашего про- вайдера.

В чем дело? Вы утверждаете, что стало только хуже, и что автор просто шарлатан, пытающийся заморочить голову всякой ерундой? Но ведь мы еще не закончили! Мы пока что просто проверили работоспособность вашего named! А вот теперь давайте займемся оп- тимизацией.

Давайте задумаемся, каким образом происходит запрос IP-адреса? Ваш DNS-сервер по цепочке пытается добраться до авторитетного сервера той или иной зоны, и при этом ис- пользует ограниченные ресурсы вашего коммутируемого канала. А сервер провайдера при тех же запросах может использовать совершенно другое (по пропускной способности) по- стоянное подключение к Internet. Конечно, после того, как сервер загрузит в свой кэш полу- ченные адреса, никакого паразитного трафика не будет, но ведь кэш еще надо загрузить! А почему бы не заставить DNS-сервера провайдера выполнять за нас всю грязную работу по первичному сбору информации? Named предоставляет и такую возможность! Нам потребуется лишь внести в файл named.boot некоторые изменения, которые приведены ниже: ; ; Загрузочный файл кэширующего сервера DNS ; directory  /var/named cache  .

root.cache ; Внимание — адреса условные, замените их на DNS-сервер ; вашего провайдера forwarders 195.23.1.65 195.23.1.89 slave В результате ваш DNS-сервер будет адресовать все свои запросы только указанным в строке forwarders серверам (учебные адреса приведены по той простой причине, что исполь- зовать чужой сервер без разрешения администратора – плохой тон!).

Теперь осталось лишь перезагрузить сервер DNS, например, с помощью named.restart и можно проводить сравнительные испытания. На моем компьютере среднее время доступа к узлу сети сократилось приблизительно на 10-15%, что если и не является радикальным средством для спасения семейного бюджета, то, во всяком случае, сокращает время бесполезного ожидания у экрана.

Стоит отметить, что реальный выигрыш определяется не только пропускной способ- ностью канала, но и настройками DNS-сервера вашего провайдера, а также его текущей за- грузкой запросами от других пользователей. Вполне может оказаться, что использование режима slave только ухудшит ситуацию. Но в этом случае вы можете быть уверены в том, что ваш DNS-сервер работает лучше, чем у провайдера, и вы смело можете обращаться за запро- сами напрямую по всей Сети…

Теперь имеет смысл поговорить более подробно об авторитетных серверах. Само- стоятельно наш DNS-сервер обновлять информацию о корневых серверах сети не станет.

Значит, мы должны ему помочь. Делается это с помощью команды nslookup, которая пред- назначена для интерактивного тестирования DNS-сервера.

Для запуска этой программы вы должны прежде всего выполнить два условия: ? подключиться к сети Internet, ? запустить сервер named.

После этого мы запускаем nslookup с формированием протокола работы программы: nslookup » tee root.log В ответ nslookup сообщит нам, что работает с сервером DNS localhost (он же 127.0.0.1), и готова к обработке наших запросов. Если вы забыли подключиться к Internet, программа просто зависнет, а в /var/log/messages или /var/log/syslog вы найдете сообщение о том, что nslookup пытается достучаться до перечисленных вами в root.cache авторитетных серверов, но сеть, увы, недоступна (network is unreachable).

Теперь проверим, насколько корректно nslookup понимает введенные нами сведения об авторитетных серверах сети. Для этого нам потребуется ввести всего две команды: > set type=ns > .

В результате nslookup проанализирует нашу запись в root.cache и вернет нам сооб- щение следующего содержания: Server: localhost.rinet.ru Address: 127.0.0.1 Non-authoritative answer: (root)nameserver = G.ROOT-SERVERS.NET (root)nameserver = J.ROOT-SERVERS.NET (root)nameserver = K.ROOT-SERVERS.NET (root)nameserver = L.ROOT-SERVERS.NET (root)nameserver = M.ROOT-SERVERS.NET (root)nameserver = A.ROOT-SERVERS.NET (root)nameserver = H.ROOT-SERVERS.NET (root)nameserver = B.ROOT-SERVERS.NET (root)nameserver = C.ROOT-SERVERS.NET (root)nameserver = D.ROOT-SERVERS.NET (root)nameserver = E.ROOT-SERVERS.NET (root)nameserver = I.ROOT-SERVERS.NET (root)nameserver = F.ROOT-SERVERS.NET Authoritative answers can be found from: G.ROOT-SERVERS.NETinternet address = 192.112.36.4 J.ROOT-SERVERS.NETinternet address = 198.41.0.10 K.ROOT-SERVERS.NETinternet address = 193.0.14.129 L.ROOT-SERVERS.NETinternet address = 198.32.64.12 M.ROOT-SERVERS.NETinternet address = 202.12.27.33 A.ROOT-SERVERS.NETinternet address = 198.41.0.4 H.ROOT-SERVERS.NETinternet address = 128.63.2.53 B.ROOT-SERVERS.NETinternet address = 128.9.0.107 C.ROOT-SERVERS.NETinternet address = 192.33.4.12 D.ROOT-SERVERS.NETinternet address = 128.8.10.90 E.ROOT-SERVERS.NETinternet address = 192.203.230.10 I.ROOT-SERVERS.NETinternet address = 192.36.148.17 F.ROOT-SERVERS.NETinternet address = 192.5.5.241 Вот те раз! Куда же делись все столь тщательно выписанные нами имена корневых серверов! Что за формализм вместо живого дыхания Сети? А это, уважаемые читатели, и есть одна из тех ситуаций, при которых может потребоваться перегрузка списка корневых серверов – относительно недавно всем этим серверам были присвоены новые доменные имена, чтобы пользователям было легче их запомнить и при необходимости найти. Адреса IP остались прежними (а иначе наш DNS-сервер и не заработал бы), но при проверке выяс- нилось, что им соответствуют уже совершенно иные имена! Обратите внимание, что наши собственноручно введенные данные рассматриваются как неавторитетные, которые требуют подтверждения от одного из корневых серверов. Не будем разочаровывать ожиданий nslookup и обратимся к одному из них : > Server: F.ROOT-SERVERS.NET Default Server: F.ROOT-SERVERS.NET Address: 192.5.5.241 > .

Server: F.ROOT-SERVERS.NET Address: 192.5.5.241 (root)nameserver = H.ROOT-SERVERS.NET (root)nameserver = B.ROOT-SERVERS.NET (root)nameserver = C.ROOT-SERVERS.NET (root)nameserver = D.ROOT-SERVERS.NET (root)nameserver = E.ROOT-SERVERS.NET (root)nameserver = I.ROOT-SERVERS.NET (root)nameserver = F.ROOT-SERVERS.NET (root)nameserver = G.ROOT-SERVERS.NET (root)nameserver = J.ROOT-SERVERS.NET (root)nameserver = K.ROOT-SERVERS.NET (root)nameserver = L.ROOT-SERVERS.NET (root)nameserver = M.ROOT-SERVERS.NET (root)nameserver = A.ROOT-SERVERS.NET H.ROOT-SERVERS.NETinternet address = 128.63.2.53 B.ROOT-SERVERS.NETinternet address = 128.9.0.107 C.ROOT-SERVERS.NETinternet address = 192.33.4.12 D.ROOT-SERVERS.NETinternet address = 128.8.10.90 E.ROOT-SERVERS.NETinternet address = 192.203.230.10 I.ROOT-SERVERS.NETinternet address = 192.36.148.17 F.ROOT-SERVERS.NETinternet address = 192.5.5.241 G.ROOT-SERVERS.NETinternet address = 192.112.36.4 J.ROOT-SERVERS.NETinternet address = 198.41.0.10 K.ROOT-SERVERS.NETinternet address = 193.0.14.129 L.ROOT-SERVERS.NETinternet address = 198.32.64.12 M.ROOT-SERVERS.NETinternet address = 202.12.27.33 A.ROOT-SERVERS.NETinternet address = 198.41.0.4 После этого можно завершить работу с nslookup, введя команду: > exit В результате в созданном нами протокольном файле root.log будет создана копия приведенного выше сеанса работы с nslookup. Теперь нам остается только преобразовать его в формат, приемлемый для использования root.cache. Задача совсем не сложна. Нам необхо- димо преобразовать строки из файла регистрации типа: (root) nameserver = D.ROOT-SERVERS.NET в строки вида: .

IN  NS D.ROOT-SERVERS.NET.

а также строки: D.ROOT-SERVERS.NET internet address = 128.8.10.90 в: D.ROOT-SERVERS.NET.

999999 IN A 128.8.10.90 Решить эту проблему можно различными путями, например, воспользовавшись ска- зочной мощью какого-либо текстового редактора, например, jed или ted. Но с точки зрения UNIX-культуры гораздо разумнее использовать одно из средств, предназначенных для ре- шения подобных задач. В данном случае наиболее удобным представляется использование программки на языке awk. Если вы не слишком уверенно чувствуете себя в awk- программировании, я хочу порекомендовать вам небольшую книжку на русском языке — [6], которую вы можете выгрузить из моей домашней странички. Ниже приведен сценарий на языке оболочки, в которую интегрирована awk-программа.

#!/bin/sh echo echo Переформатирование данных от nslookup в формат echo   /var/named/root.cache echo awk ` BEGIN { print «;—————————————»    print «; root.cache : Список корневых серверов »   print «;—————————————» }  /root/  { print «.

IN NS » $4″.» }  /internet/ { print $1″.» » 999999 IN A » $5 }  END { print «; Сгенерирован программой rfm » } ` $1 > $2 В результате вы должны получить следующее: ;————————————— ; root.cache : Список корневых серверов ;————————————— .

IN NS H.ROOT-SERVERS.NET.

.

IN NS B.ROOT-SERVERS.NET.

.

IN NS C.ROOT-SERVERS.NET.

.

IN NS D.ROOT-SERVERS.NET.

.

IN NS E.ROOT-SERVERS.NET.

.

IN NS I.ROOT-SERVERS.NET.

.

IN NS F.ROOT-SERVERS.NET.

.

IN NS G.ROOT-SERVERS.NET.

.

IN NS J.ROOT-SERVERS.NET.

.

IN NS K.ROOT-SERVERS.NET.

.

IN NS L.ROOT-SERVERS.NET.

.

IN NS M.ROOT-SERVERS.NET.

.

IN NS A.ROOT-SERVERS.NET.

H.ROOT-SERVERS.NET.

999999 IN A 128.63.2.53 B.ROOT-SERVERS.NET.

999999 IN A 128.9.0.107 C.ROOT-SERVERS.NET.

999999 IN A 192.33.4.12 D.ROOT-SERVERS.NET.

999999 IN A 128.8.10.90 E.ROOT-SERVERS.NET.

999999 IN A 192.203.230.10 I.ROOT-SERVERS.NET.

999999 IN A 192.36.148.17 F.ROOT-SERVERS.NET.

999999 IN A 192.5.5.241 G.ROOT-SERVERS.NET.

999999 IN A 192.112.36.4 J.ROOT-SERVERS.NET.

999999 IN A 198.41.0.10 K.ROOT-SERVERS.NET.

999999 IN A 193.0.14.129 L.ROOT-SERVERS.NET.

999999 IN A 198.32.64.12 M.ROOT-SERVERS.NET.

999999 IN A 202.12.27.33 A.ROOT-SERVERS.NET.

999999 IN A 198.41.0.4 ; Сгенерирован программой rfm Программа проста и понятна. Стоит обратить внимание лишь на следующее. Во- первых, вы должны позаботиться о том, чтобы входной файл программы не содержал неав- торитетной информации от вашего домашнего сервера. Rfm преобразовывает формат записей, но не может проверить, нужны ли они вам или нет. Решить эту проблему очень просто – отрежьте редактором соответствующий блок из файла протокола и «скормите» его rfm.

Во-вторых, имейте в виду, что синтаксис вызова приведенной выше программы rfm следующий: rfm И в третьих, после того, как вы получите новую версию root.cache, ее нужно поместить в каталог /var/named, а сам сервер DNS – перезапустить.

Итак, чего же нам удалось добиться? Мы сумели установить собственный кэширую- щий DNS-сервер, который позволяет сохранить работоспособность нашего узла Internet даже в случае отказа DNS-сервера провайдера. Следующий шаг очевиден – извлечение полезной информации о доменных именах из Сети, и ее последующий анализ. Но об этом – в сле- дующий раз.

Список литературы

 [1] В. Водолазкий, PPP-подключение в Linux, Планета Internet, №5, 1997, полный текст статьи – http://www.geocities.com/SiliconValley/Pines/7895

[2] П. Храмцов, Лабиринт Internet, М., Электроинформ, 1996, 256 стр.

[3] Справочное руководство системного администратора UNIX, Киев. Bhv, 1997, 600 стр.

[4] Ричард Петерсен, Linux: руководство по операционной системе., Киев, Bhv, 1997, 685 стр.

[5] Nicolai Langfeldt, Caching named mini howto, Version 1, 1995, janl@ifi.uio.no.

[6] В.Водолазкий. GAWK: Справочное руководство. 120 стр., Полный текст в формате Postscript – http://www.geocities.com/SiliconValley/Pines/7895 Большинство читателей, вероятно не подозревает о том, что еще в 1992-1994 годах только избранные граждане имели возможность использовать программку uupc (версия uucp для MS-DOS). О протоколах PPP и SLIP, равно как и об FTP знали совсем немногие. A тер- мин WWW относился к научной фантастике.

Наиболее аккуратное и грамотное описание процесса настройки авторитетного сер- вера вы найдете в [2], а более понятное изложение процесса – в [3].

Естественно, имеются в виду текущие соединения, а не общее количество абонентов.

Если вы пользуетесь стеком TCP/IP Trumpet Winsock, вы можете включить режим контроля прохождения запросов и ответов DNS. Весьма поучительное зрелище…

За подробностями по использованию команды kill отправляю читателя к литературе [3], [4] С помощью route add -net 127.0.0.0 В нашем случае, это программа route.

Не забудьте сделать резервные копии ваших текущих инициализационных и конфи- гурационных файлов! Является заменой более популярного, но постепенно устаревающего ключа domain.

Для знающих читателей сообщаю, что мне известно о механизме синонимов, по- зволяющих упростить ввод адресов в сообщениях электронной почты. Но сейчас мы говорим о механизмах сокращения адреса, используемых сервером DNS.

Последние несколько строк можно просмотреть с помощью tail /var/log/messages.

Вспомните, что в named.boot записано об ответственности root.cache за корневой домен сети.

Поскольку все эти серверы расположены довольно далеко от России выбор кон- кретного сервера для съема информации носит произвольный характер и на время получения данных влияния, по большому счету, не оказывает.

Для подготовки данной работы были использованы материалы с сайта http://lib.rin.ru/cgi-bin/index.pl

Отладка программ пользователя в Tubro Pascal

Думаю, вы не раз сталкивались с тем, что программа отказывалась работать так, как надо. Часто эти ошибки приводят к тому, что решение задачи заходило в тупик. Тут и приходят на помощь обширные средства отладки программ Turbo Pascal. Обычно эти средства используются редко, а зря. Умелая отладка программы позволяет избежать многих подводных камней и создавать идеальные программы.

Введение.

Turbo Pascal предлагает сверхусовершенствованную среду, с автоматическим управлением проектом, модульной организацией программ, высокой скоростью компиляции, с легко используемыми оверлеями. Но даже используя все эти предоставленные средства, программы пользователя могут содержать ошибки, которые приводят к неправильной работе программы.

В помощь пользователю Turbo Pascal предоставляет средства, необходимые для отладки его программы, способствующие устранению всех ошибок в программе, ее тщательному тестированию и выполнению. Turbo Pascal позволяет легко определять местоположение ошибок во время компиляции и во время выполнения программы, а также позволяет включать или выключать автоматический контроль ошибок во время выполнения программы.

Особенно важно то, что Turbo Pascal имеет мощный и гибкий отладчик исходного уровня, который позволяет пользователю выполнять программу построчно, просматривать выражения и модифицировать переменные по мере необходимости. Отладчик встроен в интегрированную среду разработки (IDE) Turbo Pascal; пользователь может редактировать, компилировать и отлаживать программу даже не выходя из Turbo Pascal. Для больших или сложных программ, которые требуют использования всего диапазона средств отладки от машинного языка до вычисления выражений Паскаля, Turbo Pascal полностью поддерживает автономный отладчик фирмы Borland, Turbo Debugger.

Типы ошибок.

Существует три основных типа программных ошибок: ошибки времени компиляции, ошибки времени выполнения и логические ошибки.

Ошибки компиляции.

Ошибки компиляции или синтаксические ошибки встречаются, когда забывают объявить переменную, передают ошибочное количество параметров процедуры, при назначении действительного значения целочисленной переменной. Это означает, что записываются операторы, которые не согласуются с правилами Паскаля.

Turbo Pascal не закончит процесс компиляции программы пользователя (генерацию машинного кода), пока все синтаксические ошибки не будут удалены. Если Turbo Pascal обнаружит синтаксическую ошибку во время компиляции программы, он останавливает компиляцию, входит в исходный текст, указывает местоположение ошибки позиционированием курсора и выводит сообщение об ошибке в окно Edit. Как только пользователь исправит ошибку, он сможет начать процесс компиляции снова.

Если используется версия командной строки (TPC.EXE), Turbo Pascal будет выводить ошибочный оператор, номер строки и сообщение об ошибке. Затем пользователь может войти в любой используемый им редактор, найти заданную строку, исправить ошибку и перекомпилировать программу. Для дополнительной информации о сообщениях об ошибках см. Приложение А в Руководстве программиста.

Ошибки времени выполнения.

Другой тип ошибок — ошибки времени выполнения программы или семантические ошибки. Они встречаются, когда пользователь компилирует синтаксически корректную программу, которая пытается сделать что-нибудь запрещенное во время ее выполнения, например, открывает несуществующий файл для ввода или производит деление на 0. В этом случае Turbo Pascal выводит на экран следующее сообщение об ошибке: Runtime error ## at seg:ofs (Ошибка выполнения # в сегменте: смещение) и останавливает выполнение программы пользователя.

При использовании интегрированной среды Turbo Pascal определяет местоположение ошибки выполнения автоматически, осуществляя переход в окно редактирования для соответствующего исходный файл.

Если пользователь выполняет программу в среде MS-DOS, он будет возвращаться в MS-DOS. Пользователь может загрузить модуль TURBO.EXE и использовать опции Search/Find error для локализации позиции ошибки в исходной программе (убедитесь, что опция Destination установлена в Disk). Для обнаружения ошибки пользователь может также использовать и опцию /F для компилятора командной строки (TPC.EXE).

(Более полное объяснение опций командной строки TPC.EXE приведено в главе 9 «Компилятор командной строки».)

Логические ошибки.

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

Интегрированный отладчик Turbo Pascal.

Некоторые ошибки времени выполнения (логические ошибки) незаметны и трудны для прослеживания. Другие ошибки могут скрываться за неуловимым взаимодействием разделов большой программы. В этих случаях необходимо интерактивное выполнение программы, во время которого производится наблюдение за значениями определенных переменных или выражений. Вам хотелось бы, чтобы Ваша программа останавливалась при достижении определенного места так, чтобы просмотреть, как она проработала этот кусок. Вам хотелось бы остановиться и изменить значения некоторых переменных во время выполнения программы, изменить определенный режим или проследить за реакцией программы. И вам хотелось бы сделать это в режиме, когда возможно быстрое редактирование, перекомпилирование и повторное выполнение программы.

Интегрированный отладчик Turbo Pascal имеет все описанные выше возможности и даже более того. Он представляет собой встроенную часть интегрированной усовершенствованной среды Turbo Pascal (IDE): для использования предлагаются две основные функции меню (Run, Debug), а также некоторые клавиши для команд отладчика. Для дополнительной информации об IDE горячих клавишах см. главу 7 «Справочник по IDE» или справочную информацию о Turbo Pascal.

Что может делать отладчик.

Интегрированный отладчик работает очень просто. Ему не требуются специальные инструкции в Вашем коде, он не увеличивает размер Вашего .EXE файла и не требует перекомпиляции для создания отдельного .EXE файла после окончания отладки.

Если Ваша программа разделена на ряд модулей, исходный код каждого из них автоматически загружается в редактор при трассировке.

Если Вы используете оверлеи, отладчик автоматически обрабатывает их внутри IDE, которая выполняет переключения между компилятором, редактором и отладчиком.

Обзор возможностей отладчика:

Трассировка. F7

Run/Trace Into Вы можете выполнить одну строку вашей программы, затем прерваться и посмотреть на результаты. При вызове процедуры или функции внутри вашей программы, Вы можете задать режим выполнения вызова как одного шага или режим трассировки этой процедуры или функции строка за строкой.

Вы можете так же трассировать вывод Вашей программы строка за строкой. Вы можете так же установить, чтобы экран переключался по необходимости или использовать два монитора. Вы можете так же установить экран вывода в отдельном окне.

Переход на курсор. F4

Run/Go to Сursor Вы можете передвинуть курсор на определенную строку в Вашей программе, а затем указать отладчику выполнить программу до достижения этой строки. Это позволяет обходить циклы или другие утомительные участки программы, это также позволяет перебираться в то место программы, откуда Вы хотите начать отладку.

Прерывание.

С помощью команды Debug/Breakpoints Вы можете пометить строки в Вашей программе как точки прерывания. Когда в процессе выполнения Вашей программы достигается точка прерывания, выполнение программы приостанавливается и отображается исходный текст и курсор останавливается на строке с точкой прерывания. Затем Вы можете проверить значения переменных, начать трассировку или выполнить программу до другой точки прерывания. Вы можете подключить условие к точке прерывания. Вы можете также прерваться в любой точке Вашей программы, нажав клавишу Ctrl-Break. Произойдет остановка на следующей строке исходной программы, как если бы в этой строке была установлена точка прерывания.

Наблюдение.

Debug/Watches Пользователь имеет возможность задавать для просмотра в окне Watch некоторые объекты (переменные, структуры данных, выражения). Просматриваемые данные меняются, отражая текущие изменения в программе при пошаговом выполнении.

Вычисление/модификация Ctrl-F4.

Debug/Evaluate/Modify Пользователь может вызвать окно Evaluate, что проверить значения переменных, структуру данных и выражения в интерактивном режиме. Используя окно Evaluate, Вы можете изменить значение любой переменной, включая строки, указатели, элементы массива и поля записей. Это обеспечивает простой механизм для проверки, как Ваш код реагирует на определенную установку значений или условий.

Поиск.

Пользователь может быстро находить объявления процедур или функций, даже если программа разбита на несколько модулей (Search/Find Рrocedure). Во время трассировки Вы можете быстро вернуться обратно из вызовов процедур или функций и проверить параметры каждого вызова (Window/Call Stack).

Подготовка к использованию отладчика.

До начала отладки Вы должны понимать, что основным элементом выполнения в отладчике является строка, а не оператор. Более точно наименьшим элементом выполнения является строка. Если на одной строке находится несколько операторов, они будут выполняться вместе при нажатии F7. С другой стороны, если один оператор размещен на нескольких строках, то при нажатии F7 будет выполняться весь оператор. Все команды выполнения основываются на строках, включая пошаговую отладку и точки прерывания; строка, на которой находится выполнение, всегда отмечена курсором выполнения.

Прежде, чем начать отладку программы, Вы должны задать для компилятора Turbo Pascal инструкцию по генерации таблицы символов и таблицы номеров строк этой программы. Таблица символов представляет собой небольшую базу данных со всеми используемыми идентификаторами — константами, типами, переменными, процедурами и информацией о номерах строк. Директивы компилятора $D+ и $L+ делают это по умолчанию; они соответствуют элементам меню Options/Compiler/Debug Information и Options/Compiler/Local Symbols. Так же по умолчанию установлена опция Options/Debugger/Integrated, которая генерирует отладочную информацию в выполнимом файле.

Директива {$D+} генерирует таблицу номеров строк, которая устанавливает соответствие между объектным кодом и исходным модулем. Директива {$L+} генерирует локальную отладочную информацию, а именно, строит список идентификаторов, локальных для каждой процедуры или функции, для того, чтобы отладчик мог хранить информацию о них в процессе отладки. Когда Вы используете директивы компилятора, разделяйте их запятыми и без пробелов, и ставя $ только перед первой директивой; например {$D+,L+}.

Примечание: Вы можете отключить эти переключатели для сохранения памяти или дискового пространства во время компиляции.

Когда Вы выполняете пошаговую отладку, Turbo Pascal будет иногда переключаться на экран пользователя, выполнять Ваш код, а затем возвращаться в интегрированную среду, ожидая следующей команды. Вы можете управлять переключением экрана с помощью установок Options/Debugger/Display Swapping, которые могут принимать 3 значения:

Smart: Это режим по умолчанию. Среда IDE переключается на экран пользователя, когда программа обращается к видеопамяти или при вызове программы.

Always: Переключение на экран пользователя происходит на каждом шаге.

None: Переключение экранов не происходит. Интегрированная среда остается видимой все время. Если в программе предусматривается вывод на экран или требуется ввод информации, текст будет писаться на экране среды. Вы можете восстановить окна интегрированной среды, выбирая Ё/Refresh Display.

Начало сеанса отладки.

Наиболее быстрый способ начать отладку состоит в загрузке программы и выборе команды Run/Trace Into (F7). Программа будет компилироваться. Когда компиляция завершится, редактор отобразит на дисплей тело основной программы с индикацией строки выполнения на первом операторе begin. Пользователь может начать трассировку программы с этого места (нажать клавиши F7 или F8) или использовать другие методы которые приведены ниже.

Если пользователю необходимо начать отладку с определенного места программы, он может выполнить программу до этого места, а затем остановиться. Для этого, загрузите нужный раздел исходного модуля в редактор и передвиньте курсор на строку, где Вы желаете остановиться. Затем можно поступить двумя способами:

— Выбрать команду Run/Goto Cursor (или нажать клавишу F4), которая будет выполнять программу пользователя до достижения строки, помеченной курсором, а затем останавить работу программы.

— Задать на указанной строке точку прерывания (выбрать команду Debug/Toggle Breakpoint или нажать на Ctrl-F8), затем выполнить программу (выполнить команду Run/Run или нажать Ctrl-F9); остановка будет происходить каждый раз при достижении заданной строки. Вы можете задать несколько точек прерывания, в этом случае программа будет делать остановку всякий раз при достижении какой-либо из этих точек.

Рестарт сеанса отладки.

Если в процессе отладки программы возникает необходимость начать все сначала, то нужно выполнить команду Program Reset из меню Run. Система отладки повторно инициализируется, и команда следующего шага вернет вас к первой строке главной программы. При этом производится закрытие всех файлов, которые были открыты программой, очистка стека всех вложенных программ, которые вызывались программой, и освобождение всего использованного пространства кучи. Переменные программы, однако, не будут повторно инициализированы или подвержены модификации какого-нибудь другого вида. (Turbo Pascal никогда не инициализирует переменные автоматически). Однако, начальные значения типированных констант программы будут восстановлены.

Turbo Pascal также предлагает рестарт, если Вы производите какие-либо изменения в программе во время отладки. Например, если Вы изменяете часть программы, а затем выбираете любую команду выполнения (нажимаете клавиши F7, F8, F4, Ctrl-F9 и т.д.), Вы получите сообщение : Source modified, rebuild? (Y/N) (исходный модуль модифицирован, нужно повторить сборку? да/нет ). Если Вы отвечаете Y, Turbo Pascal будет перекомпилировать программу и возобновит отладку программы с начала. Если Вы ответите N, Turbo Pascal предполагает, что Вы уверены в своих действиях, и продолжает сеанс отладки дальше. (Любые изменения в программе, которые Вы произвели, не будут влиять на ее выполнение до тех пор, пока Вы не перекомпилируете программу). Если Вы добавили или удалили строки программы, курсор выполнения не реагирует на эти изменения, и может оказаться, что будет выделяться ошибочная строка.

Окончание сеанса отладки.

В процессе отладки программы Turbo Pascal хранит трассу того, что Вы делаете и где находитесь в данный момент. Так как пользователь может в процессе отладки загружать и даже редактировать различные файлы, Turbo Pascal не интерпретирует загрузку другого файла в редактор, как конец сеанса отладки. Поэтому, если вы желаете выполнить или отладить другую программу, нужно выполнить команду Run/Program Reset (клавиша Ctrl -F2).

Трассировка Вашей программы.

Простейшая техника отладки — это пошаговая отладка, которая трассирует внутри процедур и функций. Загрузите программу RANGE.PAS в Turbo Pascal.

{$D+,L+}

{Для того, чтобы обеспечить

полную генерацию отладочной информации}

{$R-} {Для того, чтобы отключить проверку диапазона}

program RangeTest;

var

List:array [1..10] of integer;

Indx:integer;

begin

for Indx:=1 to 10 do List[Indx]:=Indx;

Indx:=0;

while (Indx < 11) do

begin

Indx:=Indx+1;

if List[Indx]>0 then

List[Indx]:=-List[Indx]

end;

for Indx:=1 to 10 do writeln(List[Indx]);

end.

Начните отладку, нажав клавишу F7. Это пошаговая команда. Turbo Pascal произведет компиляцию автоматически, а затем подготовится к пошаговой обработке этой программы. Заметим, что курсор выполнения расположен на операторе begin (строка 7). Помните, что курсор выполнения помечает следующую строку программы, которая должна быть выполнена.

Нажмите клавишу F7 несколько раз. Курсор выполнения переместится на оператор List[Indx]:=Indx и остановится. Это значит, что строка выполняется в цикле.

Выберите команду Debug/Watches/Add Watch (Ctrl-F7) для просмотра в окне Add Watch. Вы можете просматривать значения переменных, структур данных или выражений в окне Watch.

То, что появится в окне Add Watch зависит от того, где располагается курсор, когда Вы нажимаете на клавишу Ctrl-F7. Если курсор расположен на первой букве любой алфавитно-цифровой строки, внутри строки или сразу за ней, строка будет копироваться в окно Add Watch и подсвечиваться. Так, если курсор был спозиционирован на слове Indx, то Indx появится в окне. Если в окне необходимо что-либо изменить, начните набор на клавиатуре и первоначальное выражение и подсветка исчезнут.

Как только появится окно Add Watch, независимо от его содержимого, можно добавить в него текст, если нажать клавишу Ў (которая копирует дополнительный текст из редактора). Поместите List в окно, используя Ў, и нажмите Enter. Тогда в окне Watch в нижней части экрана появится строка:

List : (1,2,0,0,0,0,0,0,0,0)

Cнова нажмите клавишу Ctrl-F7, наберите слово Indx и нажмите Enter. Indx будет первым в списке в окне Watch:

Indx : 3

List : (1,2,0,0,0,0,0,0,0,0)

Нажмите клавишу F7 снова и Вы увидите, что значения Indx и List в окне Watch изменятся, отражая работу Вашей программы.

Как только Вы войдете в цикл while, Вы снова увидите, что значения Indx и List изменяются шаг за шагом. Заметим, что эти изменения в окне Window отражают действия каждой строки цикла после нажатия клавиши F7.

Продолжайте нажимать на клавишу F7, пока не достигнете начала цикла while, c Indx равным 10. Во время прохождения через цикл, Вы можете наблюдать как изменяются значения в окне Watch. Когда выполняется оператор

List [ Indx ] := — List [ Indx ];

значение Indx изменится на -11. Если Вы продолжаете нажимать на F7, то обнаружится, что вы вошли в бесконечный цикл.

Таким образом, если Вы наберете такую программу, она будет компилироваться и выполняться. Получается бесконечный цикл, так как цикл while выполняется 11 раз, а не 10, и последнее значение переменной Indx равно 11. Так как массив List содержит только 10 элементов, значение List(11) будет указывать на некоторую позицию памяти вне массива List. Из-за способа распределения переменных уже окажется, что значение List(11) займет в памяти тоже место, что и переменная Indx. Это значит, что при Indx=11, запись:

List [Indx] := — List [Indx]

идентична записи

Indx := -Indx.

Так как значение переменной Indx равно 11, этот оператор изменит ее значение на -11. В результате в программе начнется повторное выполнение цикла. Этот цикл теперь изменяет дополнительные байты в месте, соответствующем List[-11..0]. И т.к. значение Indx никогда не будет заканчивать цикл со значением большим или равным 11, то цикл никогда не закончится.

Важно отметить то, что используя лишь две клавиши (F7 и Ctrl — F7), через несколько минут, Вы быстро и легко прослеживаете промежуточные значения переменных и находите ошибку.

Пошаговое выполнение программы.

Различие между командами Trace Into (F7) и Step Over (F8) в том, что при использовании F7 осуществляется трассировка внутри процедур и функций, в то время как использование F8 приведет к обходу вызовов подпрограмм. Эти команды имеют особое значение при выполнении оператора begin основной программы, если программа использует модули, имеющие раздел инициализации. В этом случае, использование F7 приведет к трассировке раздела инициализации каждого модуля, что позволяет увидеть, что инициализируется в каждом модуле. При использовании F8 эти разделы не будут трассироваться, и курсор выполнения переходит на следующую строку после begin.

Рассмотрим следующий (неполный) пример программы:

($D+,L+)

program TestSort;

const

NLMax=100;

type

NumList=array[1..NLMax] of integer;

var

List : NumList;

I,Const : word;

procedure Sort ( var L:NumList; Cnt:Integer);

begin

(sort the list) (сортировка списка)

end; (of proc sort) (процедуры Sort)

begin

randomize;

Count:=NLMax;

for I:=1 to Count do

List[I] := Random(1000);

sort(List,Count);

for I:=1 to Count do

Write(List[I] :8);

Readln

end. {программы TestSort}

Предположим, что Вы отлаживаете процедуру Sort. Вы хотите осуществить трассировку процедуры Sort, включая проверку значения внутри List до вызова Sort. Однако, выполнять 100 раз инициализацию внутри List очень утомительно. Есть ли способ выполнять цикл, не останавливаясь на каждой выполняемой строке.

Да, фактически, существует несколько способов. Во-первых, Вы могли бы выделить этот цикл в отдельную процедуру и нажать клавишу F8 для того, чтобы обойти ее трассировку, но это слишком нерационально. Во-вторых, Вы могли бы установить внутри программы точку прерывания. Мы объясним, что это за точки прерывания, и как они используются немного позже. В конце концов, Вы могли бы использовать команду Run/Go to Cursor (F4). Переместите курсор на строку с вызовом Sort, а затем нажмите на клавишу (F4). Ваша программа будет выполняться до достижения строки, помеченной курсором. Курсор выполнения переместится на эту строку; затем Вы можете начать трассировку с этого места, нажимая на клавишу F7, для того, чтобы можно было сделать трассировку внутри Sort.

Команда Run/Goto Cursor (F4) действует на вложенных уровнях вызовов подпрограмм, даже если их исходный код находится в другом файле. Например, Вы могли бы разместить курсор где-либо внутри процедуры Sort и нажать на клавишу F4; программа выполнялась бы до этой строки. По существу, Sort могла бы быть выделена в отдельный модуль, отладчик бы уже знал, когда нужно остановиться и что отобразить.

Существуют три случая, когда команда Go to Cursor (F4) не будет выполнять программу до отмеченной курсором строки.

Первый, когда Вы расположили курсор между двумя выполняемыми строками; например, на пустой строке или строке с комментариями. В этом случае программа будет выполняться до следующей строки, содержащей оператор, который может быть выполнен.

Второй случай, когда курсор расположен вне процедурного блока, например, на операторе объявления переменной или операторе program. Отладчик будет выводить сообщение «no code generated for this line» (для этой строки код не генерируется).

Третий случай, когда Вы располагаете курсор на строке, которая никогда не выполняется. Например, строка располагается выше курсора выполнения (предполагается, что вы находитесь не в цикле) или строка является частью else — условного оператора, когда выражение if имеет значение true. В этом случае отладчик будет действовать так, как если бы выполнялась команда Run/Run (Ctrl-F9); программа будет выполняться до конца или до точки прерывания.

Предположим, что Вы трассируете процедуру Sort,затем хотите завершить работу программы и посмотреть выходные результаты. Каким способом сделать это? Сначала нужно переместить курсор к последнему оператору end основной части программы, а затем выполнить команду Run/Go to Cursor (F4). Или проще, нужно выполнить команду Run/Run (Ctrl-F9). Она позволяет отладчику продолжить нормальное выполнение программы пользователя. Программа будет выполняться до конца, или до тех пор, пока Вы не достигнете точки прерывания или не будет нажат Ctrl-Break.

Использование точек прерывания.

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

Примечание: Вы можете иметь до 16 активных точек прерывания.

Заметим, что точки прерывания существуют только во время сеанса отладки; они не сохраняются в файле .EXE, если программа компилируется на диск. Чтобы задать точку прерывания, используйте обычные команды редактирования для перемещения курсора на каждую строку программы, где Вы хотите сделать паузу. Каждый раз выполняйте команду Debug/Toggle Breakpoint (Ctrl-F8). Когда строка отмечается как точка прерывания, она высвечивается. Это не должна быть пустая строка, комментарии, директивы компиляции; объявления констант, типов, меток, переменных; заголовком программы, модуля, процедуры или функции. Как только Вы задали точки прерывания, выполняйте программу с помощью команды Run/Run (клавиша Ctrl-F9). Сначала программа будет выполняться нормально. Когда встретится точка прерывания, программа остановится. Соответствующий исходный файл (основная программа, модуль или включенный файл) загружается в окно Edit, которое визуализируется на экране и курсор выполнения помещается на строку с точкой прерывания.

Заметим, что точка прерывания не высвечивается, когда на ней находится курсор выполнения. Если какие-либо переменные или выражения были добавлены в окно Watch, то они также выводятся на дисплей со своими текущими значениями.

Затем, пользователь может использовать любой режим отладки.

Вы можете осуществлять пошаговое выполнение программы, используя команду Run / Trace Into, Step Over или Go to Cursor (F7, F8 или F4). Вы можете проверить или изменить значения переменных.

Вы можете добавить или удалить выражения из окна Watch.

Можно назначить или удалить точки прерывания.

Можно просмотреть выходные результаты программы, используя команду Windows/User Screen (Alt-F5).

Вы можете перезапустить программу сначала ( Run/Program Reset и, затем, команду пошагового выполнения).

Можно продолжить выполнение до следующей точки прерывания (или до конца программы), выполнив команду Run/Run (Ctrl-F9).

Для удаления точки прерывания из строки переместите курсор на данную строку и, выполнив команду Debug/Toggle Breakpoint (или нажмите Ctrl-F8) еще раз. Эта команда включает или отключает точку прерывания в строке; если она используется для строки с точкой прерывания, то строка становится нормальной.

Давайте вернемся к примеру, который был рассмотрен ранее.

begin {основная часть программы Test.Sort}

Randomize;

Count := NLMax;

for I := 1 to Count do

List [I] := Random (1000);

Sort ( List,Count );

for I := 1 to Count do

Write ( List [I] : 8 );

Readln

end. {программа Test.Sort}

Как уже говорилось, идея была в том, чтобы обойти первоначальный цикл и начать трассировку с вызова процедуры Sort. Новый вариант. Передвиньте курсор на строку с вызовом процедуры и выполните команду Debug/Toggle Breakpoint ( Ctrl-F8), которая отметит строку, как точку прерывания. Теперь выполните программу до этой точки, используя команду Run/Run (Ctrl-F9 ). Когда программа достигнет этой строки, она остановится и позволит Вам начать отладку.

Использование Ctrl-Break.

Кроме назначения точек прерывания, пользователь может сделать немедленную остановку во время выполнения программы, используя клавишу Ctrl-Break. Это означает, что можно прервать работу программы в любое время. Когда Вы нажимаете на клавишу Ctrl-Break, выполнение программы прекращается. Вы возвращаетесь в редактор, курсор выполнения расположен на следующей строке программы, и программа готова к дальнейшему пошаговому выполнению.

Фактически, отладчик автоматически подключает DOS, BIOS и другие сервисные функции. Он знает, является ли текущий выполняющийся код программой DOS, программой BIOS или программой пользователя. Когда Вы нажимаете на клавишу Ctrl-Break, отладчик ждет, пока программа выполняется сама. Затем он делает пошаговое выполнение инструкций машинного уровня, пока следующая инструкция не будет в начале строки исходного кода на Паскале. С этого момента отладчик прекращает работу, перемещает курсор выполнения на эту строку и предлагает Вам нажать на клавишу ESC.

Примечание: Если пользователь нажимает на клавишу Ctrl-Break второй раз еще до того, как отладчик находит и отображает следующую строку исходного кода для выполнения, то отладчик завершает работу и не пытается найти строку исходного кода. В этом случае, процедуры выхода не выполняются, что означает, что файлы, видеорежим и распределение памяти DOS могут быть не полностью очищены.

Просмотр значений.

Выполнение программы предоставляет много информации, но не в том объеме, как хотелось бы. Может возникнуть необходимость просмотреть за тем, как изменяются значения переменных во время выполнения программы. Рассмотрим процедуру Sort из предыдущей программы:

procedure Sort ( var L : NumList; C : word );

var

Top,Min,k : word;

Temp : integer;

begin

for Top := 1 to C-1 do

begin

Min := Top;

for k := Top+1 to C do

if L[k] Top then

begin

Temp := L[Top];

Top := L[Min];

L[Min] := Temp;

end;

end;

end; {процедуры Sort}

Примечание: Измените NLMax в теле программы на 10 так, чтобы Вы могли работать с меньшим массивом.

В этой процедуре есть ошибки, будем просматривать ее (используя команду Run/Trace Into или клавишу F7) и наблюдать за значениями переменных L, Top, Min и k.

Отладчик дает возможность пользователю задать объекты для просмотра во время выполнения Вашей программы. Как Вы и предполагаете, объектами просмотра являются переменные, структуры данных и выражения, расположенные в окне Watch, где отображаются их текущие значения, обновляемые по мере выполнения каждой строки программы. Давайте вернемся к предыдущему примеру. Установить объекты наблюдения просто.

Передвигайте курсор к каждому идентификатору и выполняйте команду Debug/Watch/Add Watch (Ctrl -F7) для добавления каждого выражения в окно Watch.

Результат может выглядеть так:

k : 21341

Min : 51

Top :21383

L : (163,143,454,622,476,161,850,402,375,34)

Предполагается, что Вы только что вошли в процедуру Sort, курсор выполнения расположен на начальном операторе begin. (Если Вы еще не вошли в процедуру Sort, то для каждого выражения в окне Watch будет появляться сообщение «unknown identifier» (неизвестный идентификатор), пока Вы не войдете в процедуру). Заметим, что переменные K, Min и Top имеют произвольные значения, т.к. они еще не были инициализированы. Значения переменной L, предположительно, тоже должно быть произвольным; они не будут таковыми при выполнении всей программы; все они должны быть неотрицательными и лежать в интервале от 0 до 999.

Если нажать на клавишу F7 четыре раза, то мы продвинемся к строке if L[k]Top then, назад к вершине внешнего цикла, и снова вниз к строке if L[k] < L[Min] then. В этот момент окно Watch будет выглядеть следующим образом (для L даны предыдущие значения):

k : 3

Min : 2

Top : 2

L : ( 34,143,454,622,476,161,850,402,375,34 )

Теперь Вы можете заметить две вещи. Первое, последнее значение переменной L(34), которое является также и наименьшим значением, скопировалось в первое значение L, и значение, которое уже было там раньше (163), исчезло. Второе, переменные Min и Top имели одинаковые значения во время трассировки процедуры. Фактически, Вы можете заметить, что переменная Min получает значение переменной Top, но она никогда не изменяется где-либо еще. Однако, ниже цикла располагается проверка:

if MinTop then.

Или эта проверка ошибочна, или существует какое-то несоответствие между этими двумя частями процедуры. Оказывается, ошибочна пятая строка программы. Она должна выглядеть так:

Min := k, вместо L[Min] := L[k].

Исправьте строку, переместите курсор к первоначальному оператору begin в процедуре Sort и выполните команду Run/Go to Cursor (F4). Так как Вы изменили программу, на экране появится окно с вопросом Source modified, rebild? (Y/N) (исходный модуль модифицирован, нужна ли сборка? Да/Нет). Ответьте Y. Программа будет перекомпилироваться, начнется ее выполнение, затем произойдет остановка на начальном операторе begin процедуры Sort. Теперь программа работает верно. Значение первого элемента теперь не меняется на наименьшее из значений элементов массива L, происходит обмен-перемещение значения первого элемента массива на место, где до этого располагался элемент с наименьшим значением. Затем процесс повторяется со второй позицией, третьей и т.д., пока список элементов не будет отсортирован полностью.

Список литературы

Для подготовки данной работы были использованы материалы с сайта http://bestcode.org/

(Справочное пособие)

Составитель: В.Н.Пильщиков (МГУ, ВМК) (январь 1992 г.)

В пособии рассматривается язык макроассеблера для персональных ЭВМ типа IBM PC (язык MASM, версия 4.0).

Пособие состоит из 4 глав. В главе 1 рассмотрены особенности персональных компьютеров типа IBM PC и приведены начальные сведения о языке MASM. В главе 2 описывается система команд этих компьютеров. Глава 3 посвящена посвящена собственно языку MASM. В главе 4 приведены примеры фрагментов программ и полных программ на MASM для решения различных задач.

В пособии не рассматриваются вопросы, связанные с обработкой двоично-десятичных чисел и работой арифметического сопроцессора 8087 или 80287.

Под термином «ПК» в пособии понимается персональный компьютер типа IBM PC c микропроцессором 8088/8086, 80186 или 80286.

Объем оперативной памяти ПК — 2^20 байтов (1 Мб). Байты нумеруются начиная с 0, номер байта называется его адресом. Для ссылок на байты памяти используются 20-разрядные адреса: от 00000 до FFFFF (в 16-ричной системе).

Байт содержит 8 разрядов (битов), каждый из которых может принимать значение 1 или 0. Разряды нумеруются справа налево от 0 до 7:

——————
| | | | | | | | |
——————
7 6 5 4 3 2 1 0

Байт — это наименьшая адресуемая ячейка памяти. В ПК используются и более крупные ячейки — слова и двойные слова. Слово — это два соседних байта, размер слова — 16 битов (они нумеруются справа налево от 0 до 15). Адресом слова считается адрес его первого байта (с меньшим адресом); этот адрес может быть четным и нечетным. Двойное слово — это любые четыре соседних байта (два соседних слова), размер такой ячейки — 32 бита; адресом двойного слова считается адрес его первого байта.

Байты используются для хранения небольших целых чисел и символов, слова — для хранения целых чисел и адресов, двойные слова — для хранения «длинных» целых чисел и т.н. адресных пар (сегмент:смещение).

Помимо ячеек оперативной памяти для хранения данных (правда, кратковременного) можно использовать и регистры — ячейки, входящие в состав процессора и доступные из машинной программы. Доступ к регистрам осуществляется значительно быстрее, чем к ячейкам памяти, поэтому использование регистров заметно уменьшает время выполнения программ.

Все регистры имеют размер слова (16 битов), за каждым из них закреплено определенное имя (AX, SP и т.п.). По назначению и способу использования регистры можно разбить на следующие группы:

регистры общего назначения (AX, BX, CX, DX, BP, SI, DI, SP);
сегментные регистры (CS, DS, SS, ES);
счетчик команд (IP);
регистр флагов (Flags).

(Расшифровка этих названий: A — accumulator, аккумулятор; B — base, база; C — counter, счетчик; D — data, данные; BP — base pointer, указатель базы; SI — source index, индекс источника; DI — destination index, индекс приемника; SP — stack pointer, указатель стека; CS —

code segment, сегмент команд; DS — data segment, сегмент данных; SS stack segment, сегмент стека; ES — extra segment, дополнительный сегмент; IP — instruction pointer, счетчик команд.)

Регистры общего назначения можно использовать во всех арифметических и логических командах. В то же время каждый их них имеет определенную специализацию (некоторые команды «работают» только с определенными регистрами). Например, команды умножения и деления требуют, чтобы один из операндов находился в регистре AX или в регистрах AX и DX (в зависимости от размера операнда), а команды управления циклом используют регистр CX в качестве счетчика цикла. Регистры BX и BP очень часто используются как базовые регистры, а SI и DI — как индексные. Регистр SP обычно указывает на вершину стека, аппаратно поддерживаемого в ПК.

Регистры AX, BX, CX и DX конструктивно устроены так, что возможен независимый доступ к их старшей и младшей половинам; можно сказать, что каждый из этих регистров состоит из двух байтовых регистров, обозначаемых AH, AL, BH и т.д. (H — high, старший; L — low, младший):

   ————      ————      ————      ————
AX | AH | AL |   BX | BH | BL |   CX | CH | CL |   DX | DH | DL |
   ————      ————      ————      ————
  15   8 7   0

Таким образом, с каждым из этих регистров можно работать как с единым целым, а можно работать и с его «половинками». Например, можно записать слово в AX, а затем считать только часть слова из регистра AH или заменить только часть в регистре AL и т.д. Такое устройство регистров позволяет использовать их для работы и с числами, и с символами.

Все остальные регистры не делятся на «половинки», поэтому считать или записать их содержимое (16 битов) можно только целиком.

Сегментные регистры CS, DS, SS и ES не могут быть операндами никаких команд, кроме команд пересылки и стековых команд. Эти регистры используются только для сегментирования адресов (см. 1.4).

Счетчик команд IP всегда содержит адрес (смещение от начала программы) той команды, которая должна быть выполнена следующей (начало программы хранится в регистре CS). Содержимое регистра IP можно изменить только командами перехода.

И, наконец, в ПК имеется особый регистр флагов. Флаг — это бит, принимающий значение 1 («флаг установлен»), если выполнено некоторое условие, и значение 0 («флаг сброшен») в противном случае. В ПК ис-

пользуется 9 флагов, каждому из них присвоено определенное имя (ZF, CF и т.д.). Все они собраны в регистре флагов (каждый флаг — это один из разрядов регистра, часть его разрядов не используется):

      ————————————————-
Flags | x| x| x| x|OF|DF|IF|TF|SF|ZF| x|AF| x|PF| x|CF|
      ————————————————-
        15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0

Некоторые флаги принято называть флагами условий; они автоматически меняются при выполнении команд и фиксируют те или иные свойства их результата (например, равен ли он нулю). Другие флаги называются флагами состояний; они меняются из программы и оказывают влияние на дальнейшее поведение процессора (например, блокируют прерывания).

Флаги условий:

CF (carry flag) — флаг переноса. Принимает значение 1, если при сложении целых чисел появилась единица переноса, не «влезающая» в разрядную сетку, или если при вычитании чисел без знака первое из них было меньше второго. В командах сдвига в CF заносится бит, вышедший за разрядную сетку. CF фиксирует также особенности команды умножения.

OF (overflow flag) — флаг переполнения. Устанавливается в 1, если при сложении или вычитании целых чисел со знаком получился результат, по модулю превосходящий допустимую величину (произошло переполнение мантиссы и она «залезла» в знаковый разряд).

ZF (zero flag) — флаг нуля. Устанавливается в 1, если результат команды оказался равным 0.

SF (sign flag) — флаг знака. Устанавливается в 1, если в операции над знаковыми числами получился отрицательный результат.

PF (parity flag) — флаг четности. Равен 1, если результат очередной команды содержит четное количество двоичных единиц. Учитывается обычно только при операциях ввода-вывода.

AF (auxiliary carry flag) — флаг дополнительного переноса. Фиксирует особенности выполнения операций над двоично-десятичными числами.

Флаги состояний:

DF (direction flag) — флаг направления. Устанавливает направление просмотра строк в строковых командах: при DF=0 строки просматриваются «вперед» (от начала к концу), при DF=1 — в обратном направлении.

IF (interrupt flag) — флаг прерываний. При IF=0 процессор перестает реагировать на поступающие к нему прерывания, при IF=1 блокировка прерываний снимается.

TF (trap flag) — флаг трассировки. При TF=1 после выполнения каждой команды процессор делает прерывание (с номером 1), чем можно воспользоваться при отладке программы для ее трассировки.

Здесь рассматривается машинное представление целых чисел, строк и адресов. Представление двоично-десятичных чисел, используемых достаточно редко, не рассматривается. Что касается вещественных чисел, то в ПК нет команд вещественной арифметики (операции над этими числами реализуются программным путем или выполняются сопроцессором) и потому нет стандартного представления вещественных чисел. Кроме того, рассматриваются некоторые особенности выполнения арифметических операций.

Шестнадцатиричные числа записываются с буквой h на конце, двоичные

числа — с буквой b (так принято в MASM).

В общем случае под целое число можно отвести любое число байтов, однако система команд ПК поддерживает только числа размером в байт и слово и частично поддерживает числа размером в двойное слово. Именно эти форматы и будут рассмотрены.

В ПК делается различие между целыми числами без знака (неотрицательными) и со знаком. Это объясняется тем, что в ячейках одного и того же размера можно представить больший диапазон беззнаковых чисел, чем неотрицательных знаковых чисел, и если известно заранее, что некоторая числовая величина является неотрицательной, то выгоднее рассматривать ее как беззнаковую, чем как знаковую.

Целые числа без знака.

Эти числа могут быть представлены в виде байта, слова или двойного слова — в зависимости от их размера. В виде байта представляются целые от 0 до 255 (=2^8-1), в виде слова — целые от 0 до 65535 (=2^16-1), в виде двойного слова — целые от 0 до 4 294 967 295 (=2^32-1). Числа записываются в двоичной системе счисления, занимая все разряды ячейки. Например, число 130 записывается в виде байта 10000010b (82h).

Числа размером в слово хранятся в памяти в «перевернутом» виде: младщие (правые) 8 битов числа размещаются в первом байте слова, а старшие 8 битов — во втором байте (в 16-ричной системе: две правые цифры — в первом байте, две левые цифры — во втором байте). Например, число 130 (=0082h) в виде слова хранится в памяти так:
   ————
   | 82 | 00 |
   ————
(Отметим, однако, что в регистрах числа хранятся в нормальном виде:
   ————
AX | 00 | 82 |
   ————
    AH   AL )

«Перевернутое» представление используется и при хранении в памяти целых чисел размером в двойное слово: в первом его байте размещаются младшие 8 битов числа, во втором байте — предыдущие 8 битов и т.д. Например, число 12345678h хранится в памяти так:

———————
| 78 | 56 | 34 | 12 |
———————

Другими словами, в первом слове двойного слова размещаются младшие (правые) 16 битов числа, а во втором слове — старшие 16 битов, причем в каждом из этих двух слов в свою очередь используется «перевернутое» представление.

Такое необычное представление чисел объясняется тем, что в первых моделях ПК за раз можно было считать из памяти только один байт и что все арифметические операции над многозначными числами начинаются с действий над младшими цифрами, поэтому из памяти в первую очередь надо считывать младшие цифры, если сразу нельзя считать все цифры. Учитывая это, в первых ПК и стали размещать младшие цифры числа перед старшими цифрамми, а ради преемственности такое представление чисел сохранили в последующих моделях ПК.

Конечно, «перевернутое» представление неудобно для людей, однако при использовании языка ассемблера это неудобство не чувствуется: в MASM все числа записываются в нормальном, неперевернутом виде (см. ниже).

Целые числа со знаком.

Эти числа также представляются в виде байта, слова и двойного слова. В виде байта записываются числа от -128 до 127, в виде слова числа от -32768 до 32767, а в виде двойного слова — числа от -2147483648 до 2147483647. При этом числа записываются в дополнительном коде: неотрицательное число записывается так же, как и беззнаковое число (т.е. в прямом коде), а отрицательное число -x (x>0) представляется беззнаковым числом 2^8-x (для байтов), 2^16-x (для слов) или 2^32-x (для двойных слов). Например, дополнительным кодом числа -6 является байт FAh (=256-6), слово FFFAh или двойное слово FFFFFFFAh. При этом байт 10000000b (=80h) трактуется как -128, а не как +128 (слово 8000h понимается как -32678), поэтому левый бит дополнительного кода всегда играет роль знакового: для неотрицательных чисел он равен 0, для отрицательных — 1.

Знаковые числа размером в слово и двойное слово записываются в памяти в «перевернутом» виде (при этом знаковый бит оказывается в последнем байте ячейки). Но в MASM эти числа, как и беззнаковые, записываются в нормальной форме.

Иногда число-байт необходимо расширить до слова, т.е. нужно получить такое же по величине число, но размером в слово. Существует два способа такого расширения — без знака и со знаком. В любом случае исходное число-байт попадает во второй (до «переворачивания») байт слова, а вот первый байт заполняется по-разному: при расширении без знака в него записываются нулевые биты (12h -> 0012h), а при расширении со знаком в первый байт записываются нули, если число-байт было неотрицательным, и записывается восемь двоичных единиц в противном случае (81h -> FF81h). Другими словами, при расширении со знаком в первом байте слова копируется знаковый разряд числа-байта.

Аналогично происходит расширение числа-слова до двойного слова.

В ПК имеются команды сложения и вычитания целых чисел размером в слово и байт. Специальных команд для сложения и вычитания двойных слов нет, эти операции реализуются через команды сложения и вычитания слов.

Сложение и вычитание беззнаковаых чисел производится по модулю 2^8

для байтов и 2^16 для слов. Это означает, что если в результате сложения появилась единица переноса, не вмещающаяся в разрядную сетку, то она отбрасывается. Например, при сложении байтов 128 и 130 получается число 258 = 100000010b, поэтому левая двоичная единица отбрасывается и остается число 2 = 10b, которое и объявляется результатом сложения. Ошибка здесь не фиксируется, но в флаг переноса CF записывается 1 (если переноса не было, в CF заносится 0). «Поймать» такое искажение суммы можно только последующим анализом флага CF.

Искажение результата происходит и при вычитание из меньшего числа большего. И здесь не фиксируется ошибка, однако первому числу дается «заем единицы» (в случае байтов это число увеличивается на 256, для

слов — на 2^16), после чего и производится вычитание. Например, вычитание байтов 2 и 3 сводится к вычитанию чисел 256+2=258 и 3, в результате чего получается неправильная разность 255 (а не -1). Для того чтобы можно было обнаружить такую ситуацию, в флаг переноса CF заносится 1 (если заема не было, в CF записывается 0).

Сложение и вычитание знаковых целых чисел производится по тем же алгоритмам, что и для беззнаковых чисел (в этом одно из достоинств дополнительного кода): знаковые числа рассматриваются как соответствующие беззнаковые числа, произодится операция над этими беззнаковыми числами и полученный результат интерпретируется как знаковое число. Например, сложение байтовых чисел 1 и -2 происходит так: берутся их дополнительные коды 1 и (256-2)=254, вычисляется сумма этих величин 1+254=255 и она трактуется как знаковое число -1 (255=256-1). Если при таком сложении возникла единица переноса, то она, как обычно, отбрасывается, а флаг CF получает значение 1. Однако в данном случае это отсечение не представляет интерес — результат операции будет правильным, например: 3+(-2) => 3+254(mod 256) = 257(mod 256) = 1. Зато здесь возможна иная неприятность: модуль суммы (ее мантисса) может превзойти допустимую границу и «залезть» в знаковый разряд, испортив его. Например, при сложении байтовых чисел 127 и 2 получается величина 129 = = 100001001b, представляющая дополнительный код числа -127 (=256-129).

Хотя результат здесь получился и неправильным, процессор не фиксирует ошибку, но зато заносит 1 в флаг переполнения OF (если «переполнения мантиссы» не было, в OF записывается 0). Анализируя затем этот флаг, можно «поймать» такую ошибку.

Таким образом, сложение (вычитание) знаковых и беззнаковых чисел производится по одному и тому же алгоритму. При этом ПК не «знает», какие числа (со знаком или без) он складывает; в любом случае он складывает их как беззнаковые числа и в любом случае формирует флаги CF и OF. А вот как интерпретировать слагаемые и сумму, на какой из этих флагов обращать внимание — это личное дело автора программы.

Что касается умножения и деления знаковых и беззнаковых чисел, то они выполняются по разным алгоритмам, разными машинными командами. Однако и у этих операций есть ряд особенностей. При умножении байтов (слов) первый сомножитель обязан находиться в регистре AL (AX), результатом же умножения является слово (двойное слово), которое заносится в регистр AX (регистры DX и AX). Тем самым при умножении сохраняются все цифры произведения. При делении байтов (слов) первый операнд (делимое) должен быть словом (двойным словом) и обязан находиться в регистре AX (регистрах DX и AX). Результатом деления являются две величины размером в байт (слово) — неполное частное (div) и остаток от деления (mod); неполное частное записывается в регистр AL (AX), а остаток — в регистр AH (DX).

На символ отводится один байт памяти, в который записывается код символа — целое от 0 до 255. В ПК используется система кодировки ASCII (American Standard Code for Information Interchange). Она, естественно, не содержит кодов русских букв, поэтому в нашей стране применяется некоторый вариант этой системы с русскими буквами (обычно это альтернативная кодировка ГОСТа).

Некоторые особенности этих систем кодировки:

— код пробела меньше кода любой буквы, цифры и вообще любого графически представимого символа;

— коды цифр упорядочены по величине цифр и не содержат пропусков,т.е. из неравенства код(‘0’)<=код(c)<=код(‘9’) следует, что c — цифра;

— коды больших латинских букв упорядочены согласно алфавиту и не содержат пропусков; аналогично с малыми латинскими буквами;

— (в альтернативной кодировке ГОСТа) коды русских букв (как больших, так и малых) упорядочены согласно алфавиту, но между ними есть коды других символов.

Строка (последовательность символов) размещается в соседних байтах памяти (в неперевернутом виде): код первого символа строки записывается в первом байте, код второго символа — во втором байте и т.п. Адресом строки считается адрес ее первого байта.

В ПК строкой считается также и последовательность слов (обычно это

последовательность целых чисел). Элементы таких строк располагаются в последовательных ячейках памяти, но каждый элемент представлен в «перевернутом» виде.

Адрес — это порядковый номер ячейки памяти, т.е. неотрицательное целое число, поэтому в общем случае адреса представляются так же, как и беззнаковые числа. Однако в ПК есть ряд особенностей в представлении адресов.

Дело в том, что в ПК термином «адрес» обозначают разные вещи. Часто под адресом понимается 16-битовое смещение (offset) — адрес ячейки, отсчитанный от начала сегмента (области) памяти, которому принадлежит эта ячейка. В этом случае под адрес отводится слово памяти, причем адрес записывается в «перевернутом» виде (как и числа-слова вообще).

В другом случае под «адресом» понимается 20-битовый абсолютный адрес некоторой ячейки памяти. В силу ряда причин в ПК такой адрес задается не как 20-битовое число, а как пара «сегмент:смещение», где «сегмент» (segment) — это первые 16 битов начального адреса сегмента памяти, которому принадлежит ячейка, а «смещение» — 16-битовый адрес этой ячейки, отсчитанный от начала данного сегмента памяти (величина 16*сегмент+смещение даетабсолютный адрес ячейки). Такая пара записывается в виде двойного слова, причем (как и для чисел) в «перевернутом» виде: в первом слове размещается смещение, а во втором — сегмент, причем каждое из этих слов в свою очередь представлено в «перевернутом» виде. Например, пара 1234h:5678h будет записана так:
———————
| 78 | 56 | 34 | 12 |
———————
смещение сегмент

Для того чтобы в программе на MASM зарезервировать ячейки памяти под константы и переменные, необходимо воспользоваться директивами определения данных — с названиями DB (описывает данные размером в байт), DW (размером в слово) и DD (размером в двойное слово). (Директивы, или команды ассемблеру, — это предложения программы, которыми ее автор сообщает какую-то информацию ассемблеру или просит что-то сделать дополнительно, помимо перевода символьных команд на машинный язык.)

В простейшем случае в директиве DB, DW или DD описывается одна константа, которой дается имя для последующих ссылок на нее. По этой директиве ассемблер формирует машинное представление константы (в частности, если надо, «переворачивает» ее) и записывает в очередную ячейку памяти. Адрес этой ячейки становится значением имени: все вхождения имени в программу ассемблер будет заменять на этот адрес. Имена, указанные в директивах DB, DW и DD, называются именами переменных (в отличие от меток — имен команд).

В MASM числа записываются в нормальном (неперевернутом) виде в cистемах счисления с основанием 10, 16, 8 или 2. Десятичные числа записываются как обычно, за шестнадцатиричным числом ставится буква h (если число начинается с «цифры» A, B, …, F, то вначале обязателен 0), за восьмиричным числом — буква q или o, за двоичным числом — буква b.

Примеры:

A DB 162 ;описать константу-байт 162 и дать ей имя A
B DB 0A2h ;такая же константа, но с именем B
С DW -1 ;константа-слово -1 с именем С
D DW 0FFFFh ;такая же константа-слово, но с именем D
E DD -1 ;-1 как двойное слово

Константы-символы описываются в директиве DB двояко: указывается либо код символа (целое от 0 до 255), либо сам символ в кавычках (одинарных или двойных); в последнем случае ассемблер сам заменит символ на его код. Например, следующие директивы эквивалентны (2A — код звездочки в ASCII):
CH DB 02Ah
CH DB ‘*’ CH DB «*»
Константы-адреса, как правило, задаются именами. Так, по директиве
ADR DW CH

будет отведено слово памяти, которому дается имя ADR и в которое запишется адрес (смещение), соответствующий имени CH. Если такое же имя описать в директиве DD, то ассемблер автоматически добавит к смещению имени его сегмент и запишет смещение в первую половину двойного слова, а сегмент — во вторую половину.

По любой из директив DB, DW и DD можно описать переменную, т.е. отвести ячейку, не дав ей начального значения. В этом случае в правой части директивы указывается вопросительный знак:
F DW ? ;отвести слово и дать ему имя F, ничего в этот байт не записывать

В одной директиве можно описать сразу несколько констант и/или переменных одного и того же размера, для чего их надо перечислить через запятую. Они размещаются в соседних ячейках памяти. Пример:

G DB 200, -5, 10h, ?, ‘F’

Имя, указанное в директиве, считается именующим первую из констант. Для ссылок на остальные в MASM используются выражения вида <имя>+<целое>; например, для доступа к байту с числом -5 надо указать выражение G+1, для доступа к байту с 10h — выражение G+2 и т.д.

Если в директиве DB перечислены только символы, например:

S DB ‘a’,’+’,’b’

тогда эту директиву можно записать короче, заключив все эти символы в одни кавычки:

S DB ‘a+b’

И, наконец, если в директиве описывается несколько одинаковых констант (переменных), то можно воспользоваться конструкцией повторения

k DUP(a,b,…,c)

которая эквивалентна повторенной k раз последовательности a,b,…,c. Например, директивы

V1 DB 0,0,0,0,0
V2 DW ?,?,?,?,?,?,?,?,?,’a’,1,2,1,2,1,2,1,2
можно записать более коротко таким образом:
V1 DB 5 DUP(0)
V2 DW 9 DUP(?), ‘a’, 4 DUP(1,2)

1.3.1 Структура команд. Исполнительные адреса
Машинные команды ПК занимают от 1 до 6 байтов.
Код операции (КОП) занимает один или два первых байта команды. В ПК столь много различных операций, что для них не хватает 256 различных КОПов, которые можно представить в одном байте. Поэтому некоторые операции объединяются в группу и им дается один и тот же КОП, во втором же байте этот КОП уточняется. Кроме того, во втором байте указываются типы и способ адресации операндов. Остальные байты команды указывают на операнды.
Команды могут иметь от 0 до 3 операндов, у большинства команд один или два операнда. Размер операндов — байт или слово (редко двойное слово). Операнд может быть указан в самой команде (это т.н. непосредственный операнд), либо может находиться в одном из регистров ПК и тогда в команде указывается этот регистр, либо может находиться в ячейке памяти и тогда в команде тем или иным способом указывается адрес этой ячейки. Некоторые команды требуют, чтобы операнд находился в фиксированном месте (например, в регистре AX), тогда операнд явно не указывается в команде. Результат выполнения команды помещается в регистр или ячейку памяти, из которого (которой), как правило, берется первый операнд. Например, большинство команд с двумя операндами реализуют действие
op1 := op1 _ op2
где op1 — регистр или ячейка, а op2 — непосредственный операнд, регистр или ячейка.
Адрес операнда разрешено модифицировать по одному или двум регистрам. В первом случае в качестве регистра-модификатора разрешено использовать регистр BX, BP, SI или DI (и никакой иной). Во втором случае один из модификаторов обязан быть регистром BX или BP, а другой —
регистром SI или DI; одновременная модификация по BX и BP или SI и DI недопустима. Регистры BX и BP обычно используются для хранения базы (начального адреса) некоторого участка памяти (скажем, массива) и потому называются базовыми регистрами, а регистры SI и DI часто содержат индексы элементов массива и потому называются индексными регистрами. Однако такое распределение ролей необязательно, и, например, в SI может находиться база массива, а в BX — индекс элемента массива.
В MASM адреса в командах записываются в виде одной из следующих конструкции:
A, A[M] или A[M1][M2],
где A — адрес, M — регистр BX, BP, SI или DI, M1 — регистр BX или BP, а M2 — регистр SI или DI. Во второрм и третьем варианте A может отсутствовать, в этом случае считается, что A=0.
При выполнении команды процессор прежде всего вычисляет т.н. исполнительный (эффективный) адрес — как сумму адреса, заданного в команде, и текущих значений указанных регистров-модификаторов, причем все эти величины рассматриваются как неотрицательные и суммирование
ведется по модулю 2^16 ([r] означает содержимое регистра r):
A : Aисп = A
A[M] : Aисп = A+[M] (mod 2^16)
A[M1][M2]: Aисп = A+[M1]+[M2] (mod 2^16)
Полученный таким образом 16-разрядный адрес определяет т.н. смещение — адрес, отсчитанный от начала некоторого сегмента (области) памяти. Перед обращением к памяти процессор еще добавляет к смещению начальный адрес этого сегмента (он хранится в некотором сегментном регистре), в результате чего получается окончательный 20-разрядный адрес, по которому и происходит реальное обращение к памяти (см. 1.4).
1.3.2 Форматы команд
В ПК форматы машинных команд достаточно разнообразны. Для примера приведем лишь основные форматы команд с двумя операндами.
1) Формат «регистр-регистр» (2байта):
————-   —————-
| КОП |d|w|     | 11 |reg1|reg2|
————-   —————-
7     2 1 0    7   6 5   3 2   0
Команды этого формата описывают обычно действие reg1:=reg1_reg2 или
reg2:=reg2_reg1. Поле КОП первого байта указывает на операцию (_), которую надо выполнить. Бит w определяет размер операндов, а бит d указывает, в какой из регистров записывается результат:
w = 1 — слова d = 1 — reg1:=reg1_reg2
= 0 — байты = 0 — reg2:=reg2_reg1
Во втором байте два левых бита фиксированы (для данного формата), а трехбитовые поля reg1 и reg2 указывают на регистры, участвующие в операции, согласно следующей таблице:

reg w=1 w=0 reg w=1 w=0
—————— —————-
000 AX  AL 100   SP AH
001 CX  CL 101   BP CH
010 DX  DL 110   SI DH
011 BX  BL 111   DI BH

2) Формат «регистр-память» (2-4 байта):
————- ————- ——————-
|   КОП |d|w| |mod|reg|mem| |адрес (0-2 байта)|
————- ————- ——————-
Эти команды описывают операции reg:=reg_mem или mem:=mem_reg. Бит w первого байта определяет размер операндов (см. выше), а бит d указывает, куда записывается результат: в регистр (d=1) или в ячейку памяти (d=0). Трехбитовое поле reg второго байта указывает операнд-регистр (см. выше), двухбитовое поле mod определяет, сколько байтов в команде занимает операнд-адрес (00 — 0 байтов, 01 — 1 байт, 10 — 2 байта), а трехбитовое поле mem указывает способ модификации этого адреса. В следующей таблице указаны правила вычисления исполнительного адреса в зависимости от значений полей mod и mem (a8 — адрес размером в байт, a16
— адрес размером в слово):

mem mod |   00     01     10
——————————————————
    000   | [BX]+[SI] [BX]+[SI]+a8 [BX]+[SI]+a16
    001   | [BX]+[DI] [BX]+[DI]+a8 [BX]+[DI]+a16
    010   | [BP]+[SI] [BP]+[SI]+a8 [BP]+[SI]+a16
    011   | [BP]+[DI] [BP]+[DI]+a8 [BP]+[DI]+a16
    100   | [SI]      [SI]+a8      [SI]+a16
    101   | [DI]      [DI]+a8      [DI]+a16
    110   | a16       [BP]+a8      [BP]+a16
    111   | [BX]      [BX]+a8      [BX]+a16
Замечания. Если в команде не задан адрес, то он считается нулевым. Если адрес задан в виде байта (a8), то он автоматически расширяется со знаком до слова (a16). Случай mod=00 и mem=110 указывает на отсутствие регистров-модификаторов, при этом адрес должет иметь размер слова (адресное выражение [BP] ассемблер транслирует в mod=01 и mem=110 при a8=0). Случай mod=11 соответствует формату «регистр-регистр».
3) Формат «регистр-непосредственный операнд» (3-4 байта): ———— ————- —————————

| КОП |s|w| |11|КОП»|reg| |непосред.операнд (1-2 б)|

———— ————- —————————
Команды этого формата описывают операции reg:=reg_immed (immed — непосредственный операнд). Бит w указывает на размер операндов, а поле reg — на регистр-операнд (см. выше). Поле КОП в первом байте определяет лишь класс операции (например, класс сложения), уточняет же операцию поле КОП» из второго байта. Непосредственный операнд может занимать 1 или 2 байта — в зависимости от значения бита w, при этом операнд-слово записывается в команде в «перевернутом» виде. Ради экономии памяти в ПК предусмотрен случай, когда в операции над словами непосредственный операнд может быть задан байтом (на этот случай указывает 1 в бите s при w=1), и тогда перед выполнением операции байт автоматически расширяется (со знаком) до слова.
4) Формат «память-непосредственный операнд» (3-6 байтов):
———— ————— ————— ——————
| КОП |s|w| |mod|КОП»|mem| |адрес (0-2б)| |непоср.оп (1-2б)|
———— ————— ————— ——————
Команды этого формата описывают операции типа mem:=mem_immed. Смысл всех полей — тот же, что и в предыдущих форматах.
Помимо рассмотренных в ПК используются и другие форматы команды с двумя операндами; так, предусмотрен специальный формат для команд, один из операндов которых фиксирован (обычно это регистр AX). Имеют свои форматы и команды с другим числом операндов.
1.3.3 Запись команд в MASM
Из сказанного ясно, что одна и та же операция в зависимости от типов операдов записывается в виде различных машинных команд: например, в ПК имеется 28 команд пересылки байтов и слов. В то же время в MASM
все эти «родственные» команды записываются единообразно: например, все команды пересылки имеют одну и ту же символьную форму записи:
MOV op1,op2 (op1:=op2)
Анализируя типы операндов, ассемблер сам выбирает подходящую машинную команду.

В общем случае команды записываются в MASM следующим образом:
метка: мнемокод операнды ;комментарий
Метка с двоеточием, а также точка с запятой и комментарий могут отсутствовать. Метка играет роль имени команды, ее можно использовать в командах перехода на данную команду. Комментарий не влияет на смысл команды, а лишь поясняет ее.
Мнемонические названия операций полностью перечислены в главе 2. Операнды, если есть, перечисляются через запятую. Основные правила
записи операндов следующие.
Регистры указываются своими именами, например:
MOV AX,SI ;оба операнда — регистры
Непосредственные операнды задаются константными выражениями (их значениями являются константы-числа), например:
MOV BH,5 ;5 — непосредственный операнд
MOV DI,SIZE X ;SIZE X (число байтов, занимаемых перемен;ной X) — непосредственный операнд
Адреса описываются адресными выражениями (например, именами переменных), которые могут быть модифицированы по одному или двум регистрам; например, в следующих командах первые операнды задают адреса:
MOV X,AH
MOV X[BX][DI],5
MOV [BX],CL
При записи команд в символьной форме необходимо внимательно следить за правильным указанием типа (размера) операндов, чтобы не было ошибок. Тип обычно определяется по внешнему виду одного из них, например:
MOV AH,5 ;пересылка байта, т.к. AH — байтовый регистр
MOV AX,5 ;пересылка слова, т.к. AX — 16-битовый регистр
;(операнд 5 может быть байтом и словом, по нему ;нельзя определить размер пересылаемой величины)
MOV [BX],300 ;пересылка слова, т.к. число 300 не может быть ;байтом
Если по внешнему виду можно однозначно определить тип обоих операндов, тогда эти типы должны совпадать, иначе ассемблер зафиксирует ошибку. Примеры:
MOV DS,AX ;оба операнда имеют размер слова
MOV CX,BH ;ошибка: регистры CX и BH имеют разные размеры
MOV DL,300 ;ошибка: DL — байтовый регистр, а число 300 не ;может быть байтом
Возможны ситуации, когда по внешнему виду операндов нельзя определить тип ни одного из них, как, например, в команде
MOV [BX],5
Здесь число 5 может быть и байтом, и словом, а адрес из регистра BX может указывать и на байт памяти, и на слово. В подобных ситуациях ассемблер фиксирует ошибку. Чтобы избежать ее, надо уточнить тип одного из операндов с помощью оператора с названием PTR:
MOV BYTE PTR [BX],5 ;пересылка байта
MOV WORD PTR [BX],5 ;пересылка слова
(Операторы — это разновидность выражений языка MASM, аналогичные функциям.)
Оператор PTR необходим и в том случае, когда надо изменить тип, предписанный имени при его описании. Если, например, X описано как имя переменной размером в слово:
X DW 999
и если надо записать в байтовый регистр AH значение только первого байта этого слова, тогда воспользоваться командой
MOV AH,X
нельзя, т.к. ее операнды имеют разный размер. Эту команду следует записать несколько иначе:
MOV AH,BYTE PTR X
Здесь конструкция BYTE PTR X означает адрес X, но уже рассматриваемый не как адрес слова, а как адрес байта. (Напомним, что с одного и того же адреса может начинаться байт, слово и двойное слово; оператор PTR
уточняет, ячейку какого размера мы имеем в виду.)
И еще одно замечание. Если в символьной команде, оперирующей со словами, указан непосредственный операнд размером в байт, как, например, в команде
MOV AX,80h
то возникает некоторая неоднозначность: что будет записано в регистр AX — число 0080h (+128) или 0FF80h (-128)? В подобных ситуациях ассемблер формирует машинную команду, где операнд-байт расширен до слова, причем расширение происходит со знаком, если операнд был записан как отрицательное число, и без знака в остальных случаях. Например:
MOV AX,-128 ; => MOV AX,0FF80h (A:=-128)
MOV AX,128 ; => MOV AX,0080h (A:=+128) MOV AX,80h ; => MOV AX,0080h (A:=+128)

1.4.1 Сегменты памяти. Сегментные регистры.
Первые модели ПК имели оперативную память объемом 2^16 байтов (64Кб) и потому использовали 16-битовые адреса. В последующих моделях память была увеличена до 2^20 байтов (1Мб=1000Кб), для чего уже необходимы 20-битовые адреса. Однако в этих ПК ради сохранения преемственности были сохранены 16-битовые адреса: именно такие адреса хранятся в регистрах и указываются в командах, именно такие адреса получаются в результате модмфикации по базовым и индексным регистрам. Как же удается 16-битовыми адресами ссылаться на 1Мб памяти?
Эта проблема решается с помощью сегментирования адресов (неявного базирования адресов). В ПК вводится понятие «сегмент памяти». Так называется любой участок памяти размером до 64Кб и с начальным адресом, кратным 16. Абсолютный (20-битовый) адрес A любой ячейки памяти можно
представить как сумму 20-битового начального адреса (базы) B сегмента, которому принадлежит ячейка, и 16-битового смещения D — адреса этой ячейки, отсчитанного от начала сегмента: A=B+D. (Неоднозначность выбора сегмента не играет существенной роли, главное — чтобы сумма B и D давала нужный адрес.) Адрес B заносится в некоторый регистр S, а в команде, где должен быть указан адрес A, вместо него записывается пара из регистра S и смещения D (в MASM такая пара, называемая адресной парой или указателем, записывается как S:D). Процессор же устроен так, что при выполнении команды он прежде всего по паре S:D вычисляет абсолютный адрес A как сумму содержимого регистра S и смещения D и только затем обращается к памяти по этому адресу A. Вот так, заменяя в командах абсолютные адреса на адресные пары, и удается адресовать всю память 16-битовыми адресами (смещениями).
В качестве регистра S разрешается использовать не любой регистр, а только один из 4 регистров, называемых сегментными: CS, DS, SS и ES. В связи с этим одновременно можно работать с 4 сегментами памяти: начало одного из них загружается в регистр CS и все ссылки на ячейки этого сегмента указываются в виде пар CS:D, начало другого заносится в DS и все ссылки на его ячейки задаются в виде пар DS:D и т.д. Если одновременно надо работать с большим числом сегментов, тогда нужно своевременно спасать содержимое сегментных регистров и записывать в них начальные адреса пятого, шестого и т.д. сегментов.
Отметим, что используемые сегменты могут быть расположены в памяти произвольным образом: они могут не пересекаться, а могут пересекаться и даже совпадать. Какие сегменты памяти использовать, в каких сегментных регистрах хранить их начальные адреса — все это личное дело автора машинной программы.
Как и все регистры ПК, сегментные регистры имеют размер слова. Поэтому возникает вопрос: как удается разместить в них 20-битовые начальные адреса сегментов памяти? Ответ такой. Поскольку все эти адреса кратны 16 (см. выше), то в них младшие 4 бита (последняя 16-ричная цифра) всегда нулевые, а потому эти биты можно не хранить явно, а лишь подразумевать. Именно так и делается: в сегментном регистре всегда хранятся только первые 16 битов (первые четыре 16-ричные цифры) начального адреса сегмента (эта величина называется номером сегмента или просто сегментом). При вычислении же абсолютного адреса A по паре S:D процессор сначала приписывает справа к содержимому регистра S четыре нулевых бита (другими словами, умножает на 16) и лишь затем прибавляет смещение D, причем суммирование ведется по модулю 2^20:
Aабс = 16*[S]+D (mod 2^20)
Если, например, в регистре CS хранится величина 1234h, тогда адресная пара 1234h:507h определяет абсолютный адрес, равный 16*1234h+507h = 12340h+507h = 12847h.
1.4.2 Сегментные регистры по умолчанию
Согласно описанной схеме сегментирования адресов, замену абсолютных адресов на адресные пары надо производить во всех командах, имеющих операнд-адрес. Однако разработчики ПК придумали способ, позволяющий избежать выписывания таких пар в большинстве команд. Суть его в том, что заранее договариваются о том, какой сегментный регистр на ка-
кой сегмент памяти будет указывать, и что в командах задается только смещение: не указанный явно сегментный регистр автоматически восстанавливается согласно этой договоренности. И только при необходимости нарушить эту договоренность надо полностью указывать адресную пару.
Что это за договоренность?
Считается, что регистр CS всегда указывает на начало области памяти, в которой размещены команды программы (эта область называется сегментом команд или сегментом кодов), и потому при ссылках на ячейки этой области регистр CS можно не указывать явно, он подразумевается по умолчанию. (Отметим попутно, что абсолютный адрес очередной команды, подлежащей выполнению, всегда задается парой CS:IP: в счетчике команд IP всегда находится смещение этой команды относительно адреса из регистра CS.) Аналогично предполагается, что регистр DS указывает на сегмент данных (область памяти с константами, переменными и другими величинами программы), и потому во всех ссылках на этот сегмент регистр DS можно явно не указывать, т.к. он подразумевается по умолчанию. Регистр SS, считается, указывает на стек — область памяти, доступ к которой осуществляется по принципу «последним записан — первым считан» (см. 1.7), и потому все ссылки на стек, в которых явно не указан сегментный регистр, по умолчанию сегментируются по регистру SS. Регистр ES считается свободным, он не привязан ни к какому сегменту памяти и его можно использовать по своему усмотрению; чаще всего он применяется для доступа к данным, которые не поместились или сознательно не были размещены в сегменте данных.
С учетом такого распределения ролей сегментных регистров машинные программы обычно строятся так: все команды программы размещаются в одном сегменте памяти, начало которого заносится в регистр CS, а все данные размещаются в другом сегменте, начало которого заносится в регистр DS; если нужен стек, то под него отводится третий сегмент памяти, начало которого записывается в регистр SS. После этого практически во всех командах можно указывать не полные адресные пары, а лишь смещения, т.к. сегментные регистры в этих парах будут восстанавливаться автоматически.
Здесь, правда, возникает такой вопрос: как по смещению определить, на какой сегмент памяти оно указывает? Точный ответ приведен ниже (см. 1.4.3), а в общих чертах он такой: ссылки на сегмент команд могут быть только в командах перехода, а ссылки практически во всех других командах (кроме строковых и стековых) — это ссылки на сегмент данных. Например, в команде пересылки
MOV AX,X
имя X воспринимается как ссылка на данное, а потому автоматически восстанавливается до адресной пары DS:X. В команде же безусловного перехода по адресу, находящемуся в регистре BX,
JMP BX
абсолютный адрес перехода определяется парой CS:[BX].
Итак, если в ссылке на какую-то ячейку памяти не указан явно сегментный регистр, то этот регистр берется по умолчанию. Явно же сегментные регистры надо указывать, только если по каким-то причинам регистр по умолчанию не подходит. Если, например, в команде пересылки нам надо сослаться на стек (скажем, надо записать в регистр AH байт стека, помеченный именем X), тогда нас уже не будет устраивать договоренность о том, что по умолчанию операнд команды MOV сегментируется по регистру DS, и потому мы обязаны явно указать иной регистр — в нашем случае регистр SS, т.к. именно он указывает на стек:
MOV AH,SS:X
Однако такие случаи встречаются редко и потому в командах, как правило, указываются только смещения.
Отметим, что в MASM сегментный регистр записывается в самой команде непосредственно перед смещением (именем переменной, меткой и т.п.), однако на уровне машинного языка ситуация несколько иная. Имеется 4 специальные однобайтовые команды, называемые префиксами замены сегмента (обозначаемые как CS:, DS:, SS: и ES:). Они ставятся перед командой, операнд-адрес которой должен быть просегментирован по регистру, отличному от регистра, подразумеваемому по умолчанию. Например, приведенная выше символическая команда пересылки — это на самом деле две машинные команды:
SS:
MOV AH,X
1.4.3 Сегментирование, базирование и индексирование адресов Поскольку сегментирование адресов — это разновидность модификации
адресов, то в ПК адрес, указываемый в команде, в общем случае модифицируется по трех регистрам — сегментному, базовому и индексному. В целом, модификация адреса производится в два этапа. Сначала учитываются только базовый и индексный регистры (если они, конечно, указаны в команде), причем вычисление здесь происходит в области 16-битовых адресов; полученный в результате 16-битовый адрес называется исполнительным (эффективным) адресом. Если в команде не предусмотрено обращение к памяти (например, она загружает адрес в регистр), то на этом модификация адреса заканчивается и используется именно исполнительный адрес (он загружается в регистр). Если же нужен доступ к памяти, тогда на втором этапе исполнительный адрес рассматривается как смещение и к нему прибавляется (умноженное на 16) содержимое сегментного регистра, указанного явно или взятого по умолчанию, в результате чего получается абсолютный (физический) 20-битовый адрес, по которому реально и происходит обращение к памяти.
Отметим, что сегментный регистр учитывается только в «последний» момент, непосредственно перед обращением к памяти, а до этого работа ведется только с 16-битовыми адресами. Если учесть к тому же, что сегментные регистры, как правило, не указываются в командах, то можно в общем-то считать, что ПК работает с 16-битовыми адресами.
Как уже сказано, если в ссылке на ячейку памяти не указан сегментный регистр, то он определяется по умолчанию. Это делается по следующим правилам.
1) В командах перехода адрес перехода сегментируется по регистру CS и только по нему, т.к. абсолютный адрес команды, которая должна быть выполнена следующей, всегда определяется парой CS:IP (попытка изменить в таких командах сегментный регистр будет безуспешной).
Отметим, что сегментиорвание по регистру CS касается именно адреса
перехода, а не адреса той ячейки, где он может находиться. Например, в команде безусловного перехода по адресу, находящемуся в ячейке X:
JMP X
имя X сегментируется по регистру DS, а вот адрес перехода, взятый из ячейки X, уже сегментируется по регистру CS.
2) Адреса во всех других командах, кроме строковых (STOS, MOVS, SCAS и CMPS), по умолчанию сегментируются:
— по регистру DS, если среди указанных регистров-модификаторов нет регистра BP;
— по регистру SS, если один из модификаторов — регистр BP.
Таким образом, адреса вида A, A[BX], A[SI], A[DI], A[BX][SI] и A[BX][DI] сегментируются по регистру DS, а адреса A[BP], A[BP][SI] и A[BP][DI] — по регистру SS, т.е. адреса трех последних видов используются для доступа к ячейкам стека.
3) В строковых командах STOS, MOVS, SCAS и CMPS, имеющих два операнда-адреса, на которые указывают индексные регистры SI и DI, один из операндов (на который указывает SI) сегментируется по регистру DS, а другой (на него указывает DI) — по регистру ES.

1.4.4 Программные сегменты. Директива ASSUME
Рассмотрим, как сегментирование проявляется в программах на MASM.
Для того чтобы указать, что некоторая группа предложений программы на MASM образуют единый сегмент памяти, они оформляются как программный сегмент: перед ними ставится директива SEGMENT, после них — директива ENDS, причем в начале обеих этих директив должно быть указано одно и то же имя, играющее роль имени сегмента. Программа же в целом представляет собой последовательность таких программных сегментов, в конце которой указывается директива конца программы END, например:
DT1 SEGMENT ;программный сегмент с именем DT1 A DB 0
B DW ? DT1 ENDS
;
DT2 SEGMENT ;программный сегмент DT2
C DB ‘hello’
DT2 ENDS
;
CODE SEGMENT ;программный сегмент CODE
ASSUME CS:CODE, DS:DT1, ES:DT2
BEG: MOV AX,DT2
MOV DS,AX
MOV BH,C
…
CODE ENDS
END BEG ;конец текста программы
Предложения программного сегмента ассемблер размещает в одном сегменте памяти (в совокупности они не должны занимать более 64Кб) начиная с ближайшего свободного адреса, кратного 16. Номер (первые 16 битов начального адреса) этого сегмента становится значением имени сегмента. В MASM это имя относится к константным выражениям, а не адресным, в связи с чем в команде
MOV AX,DT2
второй операнд является непосредственным, поэтому в регистр AX будет записано начало (номер) сегмента DT2, а не содержимое начальной ячейки этого сегмента.
Имена же переменных (A, B, C) и метки (BEG) относятся к адресным выражениям, и им ставится в соответствие адрес их ячейки относительно «своего» сегмента: имени A соответствует адрес 0, имени B — адрес 1, имени C — адрес 0, а метке BEG — адрес 0.
Все ссылки на предложения одного программного сегмента ассемблер сегментирует по умолчанию по одному и тому же сегментному регистру. По какому именно — устанавливается специальной директивой ASSUME. В нашем примере эта директива определяет, что все ссылки на сегмент CODE должны, если явно не указан сегментный регистр, сегментироваться по регистру CS, все ссылки на DT1 — по регистру DS, а все ссылки на DT2 — по регистру ES.
Встретив в тексте программы ссылку на какое-либо имя (например, на имя C в команде MOV AX,C), ассемблер определяет, в каком программном сегменте оно описано (у нас — в DT2), затем по информации из директивы ASSUME узнает, какой сегментный регистр поставлен в соответствие этому сегменту (у нас — это ES), и далее образует адресную пару иэ данного регистра и смещения имени (у нас — ES:0), которую и записывает в формируемую машинную команду. При этом ассемблер учитывает используемое в ПК соглашение о сегментных регистрах по умолчанию: если в адресной паре, построенной им самим или явно заданной в программе, сегментный регистр совпадает с регистром по умолчанию, то в машинную команду заносится лишь смещение. Если, скажем, в нашем примере встретится команда MOV CX,B, тогда по имени В ассемблер построит пару DS:1, но раз операнд-адрес команды MOV по умолчанию сегментируется по регистру DS, то записывать этот регистр в машинную команду излишне и ассемблер записывает в нее только смещение 1.
Таким образом, директива ASSUME избавляет программистов от необходимости выписывать полные адресные пары не только тогда, когда используются сегментные регистры по умолчанию (как в случае с именем B), но тогда, когда в машинной команде нужно было бы явно указать сегментный регистр (как в случае с именем C). В MASM сегментный регистр в ссылке на имя требуется указывать лишь тогда, когда имя должно по каким-либо причинам сегментироваться по регистру, отличному от того, что поставлен в соответствие всему сегменту, в котором это имя описано.
Однако все это справедливо только при соблюдении следующих условий. Во-первых, директива ASSUME должна быть указана перед первой командой программы. В противном случае ассемблер, просматривающий текст программы сверху вниз, не будет знать, как сегментировать имена из команд, расположенных до этой директивы, и потому зафиксирует ошибку. Во-вторых, в директиве ASSUME следует каждому сегменту ставить в соответствие сегментный регистр: если ассемблеру встретится ссылка на имя из сегмента, которому не соответствует никакой сегментный регистр, то он зафиксирует ошибку. Правда, в обоих случаях можно избежать ошибки, но для этого в ссылках необходимо явно указывать сегментный регистр.
1.4.5 Начальная загрузка сегментных регистров
Директива ASSUME сообщает ассмеблеру о том, по каким регистрам он должен сегментировать имена из каких сегментов, и «обещает», что в этих регистрах будут находиться начальные адреса этих сегментов. Однако загрузку этих адресов в регистры сама директива не осуществляет. Сделать такую загрузку — обязанность самой программы, с загрузки сегментных регистров и должно начинаться выполнение программы. Делается это так.
Поскольку в ПК нет команды пересылки непосредственного операнда в сегментный регистр (а имя, т.е. начало, сегмента — это непосредственный операнд), то такую загрузку приходится делать через какой-то другой, несегментный, регистр (например, AX):
MOV AX,DT1 ;AX:=начало сегмента DT1
MOV DS,AX ;DS:=AX
Аналогично загружается и регистр ES.
Загружать регистр CS в начале программы не надо: он, как и счетчик команд IP, загружается операционной системой перед тем, как начинается выполнение программы (иначе нельзя было бы начать ее выполнение). Что же касается регистра SS, используемого для работы со стеком, то он может быть загружен так же, как и регистры DS и ES, однако в MASM предусмотрена возможность загрузки этого регистра еще до выполнения программы (см. 1.7).
1.4.6 Ссылки вперед
Встречая в символьной команде ссылку назад — имя, которое описано в тексте программы до этой команды, ассемблер уже имеет необходимую информацию об имени и потому может правильно оттранслировать эту команду. Но если в команде встретится ссылка вперед, т.е. имя, которое не было описано до команды и которое, наверное, будет описано позже, то ассемблер в большинстве случаев не сможет правильно оттранслировать эту команду. Например, не зная, в каком программном сегменте будет описано это имя, ассемблер не может определить, по какому сегментному регистру надо сегментировать имя, и потому не может определить, надо или нет размещать перед соответствующей машинной командой префикс замены сегмента и, если надо, то какой именно.
В подобной ситуации ассемблер действует следующим образом: если в команде встретилась ссылка вперед, то он делает некоторое предположение относительно этого имени и уже на основе этого предположения формирует машинную команду. Если затем (когда встретится описание имени) окажется, что данное предположение было неверным, тогда ассемблер пытается исправить сформированнную им ранее машинную команду. Однако это не всегда удается: если правильная машинная команда должна занимать больше места, чем машинная команда, построенная на основе предположения (например, перед командой надо на самом деле вставить префикс замены сегмента), тогда ассемблер фиксирует ошибку (как правило, это ошибка номер 6: Phase error between passes.)
Какие же предположения делает ассемблер, встречая ссылку вперед? Во всех командах, кроме команд перехода (о них см. 1.5), ассемблер предполагает, что имя будет описано в сегменте данных и потому сегментируется по регистру DS. Это следует учитывать при составлении программы: если в команде встречается ссылка вперед на имя, которое описано в сегменте, на начало которого указывает сегментный регистр, отличный от DS, то перед таким именем автор программы должен написать соотвествующмй префикс. Пример:
code segment
assume cs:code
x dw ?
beg: mov ax,x ;здесь вместо cs:x можно записать просто x mov cs:y,ax ;здесь обязательно надо записать cs:y
…
y dw ?
code ends

В систему команд ПК входит обычный для ЭВМ набор команд перехода: безусловные и условные переходы, переходы с возвратами и др. Однако в ПК эти команды имеют некоторые особенности, которые здесь и рассматриваются.
Абсолютный адрес команды, которая должна быть выполнена следующей, определяется парой CS:IP, поэтому выполнение перехода означает изменение этих регистров, обоих или только одного (IP). Если изменяется только счетчик команд IP, то такой переход называется внутрисегментным или близким (управление остается в том же сегменте команд), а если меняются оба регистра CS и IP, то это межсегментный или дальний переход (начинают выполняться команды из другого сегмента команд). По способу изменения счетчика команд переходы делятся на абсолютные и относительные. Если в команде перехода указан адрес (смещение) той команды, которой надо передать управление, то это абсолютный переход. Однако в команде может быть указана величина (сдвиг), которую надо добавить к текущему значению регистра IP, чтобы получился адрес перехода, и тогда это будет относительный переход; при этом сдвиг может быть положительным и отрицательным, так что возможен переход вперед и назад. По величине сдвига относительные переходы делятся на короткие (сдвиг задается байтом) и длинные (сдвиг — слово). Абсолютные же переходы делятся на прямые и косвенные: при прямом переходе адрес перехода задается в самой команде, а при косвенном — в команде указывается регистр или ячейка памяти, в котором (которой) находится адрес перехода.

1.5.1 Безусловные переходы.
В MASM все команды безусловного перехода обозначаются одинаково:
JMP op
но в зависимости от типа операнда, ассемблер формирует разные машинные команды.
1) Внутрисегментный относительный короткий переход.
JMP i8 (IP:=IP+i8)
Здесь i8 обозначает непосредственный операнд размеров в байт, который интерпретируется как знаковое целое от -128 до 127. Команда прибавляет это число к текущему значению регистра IP, получая в нем адрес (смещение) той команды, которая должна быть выполнена следующей. Регистр CS при этом не меняется.
Необходимо учитывать следующую особенность регистра IP. Выполнение любой команды начинается с того, что в IP заносится адрес следующей за ней команды, и только затем выполняется собственно команда. Для команды относительного перехода это означает, что операнд i8 прибавляется не к адресу этой команды, а к адресу команды, следующей за ней, поэтому, к примеру, команда JMP 0 — это переход на следующую команду программы.
При написании машинной программы сдвиги для относительных переходов приходится вычислять вручную, однако MASM избавляет от этого неприятного занятия: в MASM в командах относительного перехода всегда указывается метка той команды, на которую надо передать управление, и ассемблер сам вычисляет сдвиг, который он и записывает в машинную команду. Отсюда следует, что в MASM команда перехода по метке воспринимается не как абсолютный переход, а как относительный.
По короткому переходу можно передать управление только на ближайшие команды программы — отстоящие от команды, следующей за командой перехода, до 128 байтов назад или до 127 байтов вперед. Для перехода на более дальние команды используется
2) Внутрисегментный относительный длинный переход.
JMP i16 (IP:=IP+i16)
Здесь i16 обозначает непосредственный операнд размером в слово, который рассматривается как знаковое целое от -32768 до 32767. Этот переход аналогичен короткому переходу.
Отметим, что, встретив команду перехода с меткой, которой была помечена одна из предыдущих (по тексту) команд программы, ассемблер вычисляет разность между адресом этой метки и адресом команды перехода и по этому сдвигу определяет, какую машинную команду относительного перехода — короткую или длинную — надо сформировать. Но если метка еще
не встречалась в тексте программы, т.е. делается переход вперед, тогда ассемблер, не зная еще адреса метки, не может определить, какую именно машинную команду относительного перехода формировать, поэтому он на всякий случай выбирает команду длинного перехода. Однако эта машинная команда занимает 3 байта, тогда как команда короткого перехода — 2 байта, и если автор программы на MASM стремится к экономии памяти и знает заранее, что переход вперед будет на близкую метку, то он должен сообщить об этом ассемблеру, чтобы тот сформировал команду короткого перехода. Такое указание делается с помощью оператора SHORT:
JMP SHORT L
Для переходов назад оператор SHORT не нужен: уже зная адрес метки, ассемблер сам определит вид команды относительного перехода.
3) Внутрисегментный абсолютный косвенный переход.
JMP r16 (IP:=[r])
или JMP m16 (IP:=[m16])
Здесь r16 обозначает любой 16-битовый регистр общего назначения, а m16 — адрес слова памяти. В этом регистре (слове памяти) должен находиться адрес, по которому и будет произведен переход. Например, по команде JMP BX осушествляется переход по адресу, находящемуся в регистре BX.
4) Межсегментный абсолютный прямой переход.
JMP seg:ofs (CS:=seg, IP:=ofs)
Здесь seg — начало (первые 16 битов начального адреса) некоторого сегмента памяти, а ofs — смещение в этом сегменте. Пара seg:ofs определяет абсолютный адрес, по которому делается переход. В MASM эта пара всегда задается конструкцией FAR PTR <метка>, которая «говорит», что надо сделать переход по указанной метке, причем эта метка — «дальняя», из другого сегмента. Отметим, что ассемблер сам определяет, какой это сегмент, и сам подставляет в машинную команду его начало, т.е. seg.
5) Межсегментный абсолютный косвенный переход.
JMP m32 (CS:=[m32+2], IP:=[m32])
Здесь под m32 понимается адрес двойного слова памяти, в котором находится пара seg:ofs, задающая абсолютный адрес, по которому данная команда должна выполнить переход. Напомним, что в ПК величины размером в двойное слово хранятся в «перевернутом» виде, поэтому смещение ofs находится в первом слове двойного слова m32, а смещение seg — во втором слове (по адресу m32+2).
Команды межсегментного перехода используются тогда, когда команды программы размещены не в одном сегменте памяти, а в нескольких (например, команд столь много, что в совокупности они занимают более 64Кб, т.е. более максимального размера сегмента памяти). При переходе из одного такого сегмента в другой необходимо менять не только счетчик команд IP, но и содержимое регистра CS, загружая в последний начальный адрес второго сегмента. Такое одновременное изменение обоих этих регистров и делают команды межсегментного перехода.
При записи в MASM команд перехода следует учитывать, что они могут восприниматься неоднозначно. Скажем, как воспринимать команду
JMP A
— как переход по метке A или как переход по адресу, хранящемуся в ячейке с именем A? Кроме того, какой это переход — внутрисегментный или межсегментный? Ответ зависит от того, как описано имя A, и от того, когда описано имя A — до или после команды перехода.
Пусть A описано до команды перехода («ссылка назад»). Если именем A помечена некоторая команда текущего сегмента команда (т.е. A — метка), тогда ассемблер формирует машинную команду внутрисегментного относительного перехода. Если же A — имя переменной, тогда ассемблер формирует машинную команду косвенного перехода — внутрисегментного, если A описано в директиве DW, или межсегментного, если A описано в директиве DD.
В случае же, если имя A описано после команды перехода («ссылка вперед»), ассемблер всегда формирует машинную команду внутрисегментного относительного длинного перехода. С учетом этого имя A обязательно должно метить команду из текущего сегмента команд, иначе будет зафиксирована ошибка. Если такая трактовка ссылки вперед не удовлетворяет автора программы, тогда он обязан с помощью оператора SHORT или PTR уточнить тип имени A:
JMP SHORT A ;внутрисегментный короткий переход по метке
JMP WORD PTR A ;внутрисегментный косвенный переход
JMP DWORD PTE A ;межсегментный косвенный переход
Отметим, что переход по метке A из другого сегмента команд всегда должен указываться с помощью FAR PTR (независимо от того, описана метка A до или после команды перехода):
JMP FAR PTR A ;межсегментный переход по метке
1.5.2 Условные переходы.
Практически во всех командах условного перехода проверяется значение того или иного флага (например, флага нуля ZF) и, если он имеет определенное значение, выполняется переход по адресу, указанному в команде. Значение флага должно быть установлено предыдущей командой, например, командой сравнения
CMP op1,op2
которая вычисляет разность op1-op2, однако результат никуда не записывает, а только меняет флаги, на которые и будет реагировать команда
условного перехода.
В MASM команды условного перехода имеют следующую форму:
Jxx op
где xx — одна или несколько букв, в сокращенном виде отражающие проверяемое условие (обычно в предположении, что перед этой командой находится команда сравнения). Примеры некоторых мнемоник:
JE — переход «по равно» (jump if equal)
JL — переход «по меньше» (jump if less)
JNL — переход «по неменьше» (jump if not less)
Особеностью всех машинных команд условного перехода является то, что они реализуют внутрисегментный относительный короткий переход, т.е. добавляют к счетчику команд IP свой операнд, рассматриваемый как знаковое число от -128 до 127. В MASM этот операнд всегда должен записываться как метка, которую ассемблер заменит на соответствующий сдвиг (см. выше).
Такая особенность команд условного перехода вызывает неудобство при переходах на «дальние» команды. Например, если надо сделать переход при A<B на команду, помеченную меткой L и расположенную далеко от команды перехода, то приходится использовать команду длинного безусловного перехода:
MOV AX,A
CMP AX,B ;сравнение A и B
JNL M ;не меньше —> M (обход команды JMP)
JMP L ;меньше —> L (длинный переход)
M: …

1.5.3 Команды управление циклом
В ПК есть несколько команд, упрощающих программирование циклов с заранее известным числом повторений. Применение этих команд требует, чтобы к началу цикла в регистр CX было занесено число шагов цикла. Сами команды размещаются в конце цикла, они уменьшают значение CX на 1 и, если CX еще не равно 0, передают управление на начало цикла. Например, найти S — сумму элементов массива X из 10 чисел-слов можно так:
MOV AX,0 ;начальное значение суммы (накапливается в AX)
MOV SI,0 ;начальное значение индексного регистра
MOV CX,10 ;число повторений цикла
L: ADD AX,X[SI] ;AX:=AX+X[i]
ADD SI,2 ;SI:=SI+2
LOOP L ;CX:=CX-1; if CX<>0 then goto L
MOV S,AX ;S:=AX
Помимо команды LOOP есть еще две «циклические» команды — LOOPZ и LOOPNZ (они имеют синонимичные названия LOOPE и LOOPNE), которых кроме регистра CX проверяют еще и флаг нуля ZF; например, команда LOOPZ «выходит» из цикла, если CX=0 или ZF=1. Эту команду можно, например, использовать при поиске в массиве первого нулевого элемента, где должно быть предусмотрено два условия выхода из цикла: либо будет найден ну-
левой элемент (ZF=1, если перед LOOPZ поставить команду сравнения очередного элемента с 0), либо будет исчерпан весь мсассив (CX=0)
Отметим, что все эти «циклические» команды реализуют короткий относительный переход, как и команды условного перехода, поэтому их можно использовать только для циклов с небольшим числом команд.
В MASM есть еще две команды перехода — CALL (переход с возвратом) и RET (возврат из подпрограммы), они рассматриваются в 1.7.

В ПК под строкой понимается последовательность соседних байтов или слов. В связи с этим все строковые команды имеют две разновидности для работы со строками из байтов (в мнемонику операций входит буква B) и для работы со строками из слов (в мнемонику входит W).
Имеются следующие операции над строками:
пересылка элементов строк (в память, из памяти, память-память);
сравнение двух строк; просмотр строки с целью поиска элемента, равного заданному.
Каждая из этих операций выполняется только над одним элементом строки, однако одновременно происходит автоматическая настройка на следующий или предыдущий элемент строки. Имеются специальные команды повторения (REP и др.), которые заставляют следующую за ними строковую команду многократно повторяться (до 2^16 раз), в связи с чем такая пара команд позволяет обработать всю строку, причем намного быстрее, чем запрограммированный цикл.
Кроме того, строки можно просматривать вперед (от их начала к концу) и назад. Направление просмотра зависит от флага направления DF, значение которого можно менять с помощью команд STD (DF:=1) и CLD (DF:=0). При DF=0 все последующие строковые команды программы просматривают строки вперед, а при DF=1 — назад.
В строковых командах операнды явно не указываются, а подразумеваются. Если команда работает с одной строкой, то адрес очередного, обрабатываемого сейчас элемента строки задается парой регистров DS и SI или парой ES и DI, а если команда работает с двумя строками, то адрес элемента одной из них определяется парой DS:SI, а адрес элемента другой — парой ES:DI. После выполнения операции значение регистра SI и/или DI увеличивается (при DF=0) или уменьшается (при DF=1) на 1 (для байтовых строк) или на 2 (для строк из слов).
Начальная установка всех этих регистров, а также флага DF должна быть выполнена до начала операции над строкой. Если сегментный регистр DS уже имеет нужное значение, тогда загрузить регистр SI можно с помощью команды
LEA SI,<начальный/конечный адрес строки>
Если же надо загрузить сразу оба регистра DS и SI, тогда можно воспользоваться командой
LDS SI,m32
которая в регистр SI заносит первое слово, а в регистр DS — второе слово из двойного слова, имеющего адреc m32 (таким образом, по адресу m32+2 должен храниться сегмент, а по адресу m32 — смещение начального или конечного элемента строки). Начальную загрузку регистров ES и DI обычно осуществляют одной командой
LES DI,m32
которая действует аналогично команде LDS.
Перечислим вкратце строковые команды ПК.
Команда загрузки элемента строки в аккумулятор (LODSB или LODSW) пересылает в регистр AL или AX очередной элемент строки, на который указывает пара DS:SI, после чего увеличивает (при DF=0) или уменьшает (при DF=1) регистр SI на 1 или 2.
Команда записи аккумулятора в строку (STOSB или STOSW) заносит содержимое регистра AL или AX в тот элемент строки, на который указывает пара ES:DI, после чего изменяет регистр DI на 1 или 2.
Команда пересылки строк (MOVSB или MOVSW) считывает элемент первой строки, определяемый парой DS:SI, в элемент второй строки, определяемый парой ES:DI, после чего одновременно меняет регистры SI и DI.
Команда сравнения строк (CMPSB или CMPSW) сравнивает очередные элементы строк, указываемые парами DS:SI и ES:DI, и результат сравнения (равно, меньше и т.п.) фиксирует в флагах, после чего меняет регистры SI и DI.
Команда сканирования строки (SCASB или SCASW) сравнивает элемент строки, адрес которого задается парой ES:DI, со значением регистра AL или AX и результат сравнения фиксирует в флагах, после чего меняет содержимое регистра DI.
Перед любой строковой командой можно поставить одну из двух команд, называемых «префиксами повторения», которая заставит многократно повториться эту строковую команду. Число повторений (обычно это длина строки) должно быть указано в регистре CX. Префикс повторения REPZ (синонимы — REPE, REP) сначала заносит 1 в флаг нуля ZF, после чего, постоянно уменьшая CX на 1, заставляет повторяться следующую за ним строковую команду до тех пор, пока в CX не окажется 0 или пока флаг ZF не изменит свое значение на 0. Другой префикс повторения REPNZ (синоним — REPNE) действует аналогично, но только вначале устанавливает флаг ZF в 0, а при при изменении его на 1 прекращает повторение строковой команды.
Пример. Пусть надо переписать 10000 байтов начиная с адреса A в другое место памяти начиная с адреса B. Если оба этих имени относятся к сегменту данных, на начало которого указывает регистр DS, тогда эту пересылку можно сделать так:
CLD ;DF:=0 (просмотр строки вперед)
MOV CX,1000 ;CX — число повторений
MOV AX,DS
MOV ES,AX ;ES:=DS
LEA SI,A ;ES:SI — «откуда»
LEA DI,B ;DS:DI — «куда»
REP MOVSB ;пересылка CX байтов

1.7.1 Стек
В ПК имеются специальные команды работы со стеком, т.е. областью памяти, доступ к элементам которой осуществляется по принципу «последним записан — первым считан». Но для того, чтобы можно было воспользоваться этими командами, необходимо соблюдение ряда условий.
Под стек можно отвести область в любом месте памяти. Размер ее может быть любым, но не должен превосходить 64Кб, а ее начальный адрес должен быть кратным 16. Другими словами, эта область должна быть сегментом памяти; он называется сегментом стека. Начало этого сегмента (первые 16 битов начального адреса) должно обязательно храниться в сегментном регистре SS.
Хранимые в стеке элементы могут иметь любой размер, однако следует учитывать, что в ПК имеются команды записи в стек и чтения из него только слов. Поэтому для записи байта в стек его надо предварительно расширить до слова, а запись или чтение двойных слов осуществляются парой команд.
В ПК принято заполнять стек снизу вверх, от больших адресов к меньшим: первый элемент записывается в конец области, отведенной под стек, второй элемент — в предыдущую ячейку области и т.д. Считывается всегда элемент, записанный в стек последним. В связи с этим нижняя граница стека всегда фиксирована, а верхняя — меняется. Слово памяти, в котором находится элемент стека, записанный последним, называется вершиной стека. Адрес вершины, отсчитанный от начала сегмента стека, обязан находиться в указателе стека — регистре SP. Таким образом, абсолютный адрес вершины стека определяется парой SS:SP.

Значение 0 в регистре SP свидетельствует о том, что стек полностью заполнен (его вершина «дошла» до начала области стека). Поэтому для
контроля за переполнением стека надо перед новой записью в стек проверять условие SP=0 (сам ПК этого не делает). Для пустого стека значение SP должно равняться размеру стека, т.е. пара SS:SP должна указывать на байт, следующий за последним байтом области стека. Контроль за чтением из пустого стека, если надо, обязана делать сама программа.
Начальная установка регистров SS и SP может быть произведена в самой программе, однако в MASM предусмотрена возможность автоматической загрузки этих регистров. Если в директиве SEGMENT, начинающей описание сегмента стека, указать параметр STACK, тогда ассемблер (точнее, загрузчик) перед тем, как передать управление на первую команду машинной программы, загрузит в регистры SS и SP нужные значения. Например, если в программе сегмент стека описан следующим образом:
ST SEGMENT STACK
DB 256 DUP(?) ;размер стека — 256 байтов
ST ENDS
и если под этот сегмент была выделена область памяти начиная с абсолютного адреса 12340h, тогда к началу выполнения программы в регистре SS окажется величина 1234h, а в регистре SP — величина 100h (=256). Отметим, что эти значения соответствуют пустому стеку.
1.7.2 Основные стековые команды
При соблюдении указанных требований в программе можно использовать команды, предназначенные для работы со стеком. Основными из них являются следующие.
Запись слова в стек: PUSH op
Здесь op обозначает любой 16-битовый регистр (в том числе и сегментный) или адрес слова памяти. По этой команде значение регистра SP уменьшается на 2 (вычитание происходит по модулю 2^16), после чего указанное операндом слово записывается в cтек по адресу SS:SP.
Чтение слова из стека: POP op
Слово, считанное из вершины стека, присваивается операнду op (регистру, в том числе сегментному, но не CS, или слову памяти), после чего значение SP увеличивается на 2.
Переход с возвратом: CALL op
Эта команда записывает адрес следующей за ней команды в стек и затем делает переход по адресу, определяемому операндом op. Она используется для переходов на подпрограммы с запоминанием в стеке адреса возврата.
Имеются следующие разновидности этой команды (они аналогичны вариантам команды безусловного перехода JMP):
внутрисегментный относительный длинный переход (op — непосредственный операнд размером в слово, а в MASM — это метка из текущего сегмента команд или имя близкой процедуры (см. ниже)); в этом случае в стек заносится только текущее значение счетчика команд IP, т.е. смещение следующей команды; внутрисегментный абсолютный косвенный переход (op — адрес слова памяти, в которой находится адрес (смещение) той команды, на которую и будет сделан переход); и здесь в стек записывается только смещение адреса возврата; межсегментный абсолютный прямой переход (op — непосредственный операнд вида seg:ofs, а в MASM — это FAR PTR <метка> или имя дальней процедуры (см. ниже)); здесь в стек заносится текущие значение регистров CS и IP (первым в стек записывается содержимое CS), т.е. абсолютный адрес возврата, после чего меняются регистры CS и IP; межсегментный абсолютный косвенный переход (op — адрес двойного слова, в котором находится пара seg:ofs, задающая абсолютный адрес перехода); и здесь в стеке спасается содержимое регистров CS и IP. Переход (возврат) по адресу из стека: RET op
Из стека считывается адрес и по нему производится переход. Если указан операнд (а это должно быть неотрицательное число), то после чтения адреса стек еще очищается на это число байтов (к SP добавляется это число). Команда используется для возврата из подпрограммы по адресу, записанному в стек по команде CALL при вызове подпрограммы, и одновременной очистки стека от параметров, которые основная программа занесла
в стек перед обращением к подпрограмме.
Команда RET имеет две разновидности (хотя в MASM они записываются и одинаково): в одном случае из стека считывается только одно слово смещение адреса возврата, а во втором — из стека считывается пара seg: ofs, указывающая абсолютный адрес возврата. Как ассемблер определяет, какой из этих двух случаев имеет место, объяснено ниже.
В ПК стек в основном используется для организации подпрограмм и прерываний. Подпрограммы рассматриваются ниже, а прерывания — в главе 3. Однако, даже если программе не нужен стек, она все равно должна отвести под него место. Дело в том, что стеком будет неявно пользоваться операционная система при обработке прерываний, которые возникают (например, при нажатии клавиш на клавиатуре) в то время, когда выполняется программа. Для нужд ОС рекомендуется выделять в стеке 64 байта.

1.7.3 Подпрограммы
Типичная схема огранизации подпрограмм, обычно используемая трансляторами с языков высокого уровня для реализации процедур и функций (в частности, рекурсивных), следующая.
При обращении к подпрограмме в стек заносятся параметры для нее и адрес возрата, после чего делается переход на ее начало:
PUSH param1 ;запись 1-го параметра в стек
…
PUSH paramk ;запись последнего (k-го) параметра в стек
CALL subr ;переход в возратом на подпрограмму
(Замечание: если необходимо вычислить параметр или если его размер отличен от слова, тогда для записи параметра в стек нужно, конечно, несколько команд, а не одна.) Состояние стека после выполнения этих команд обращения к подпрограмме показано на рис. a

Первыми командами подпрограммы обычно являются следующие:
PUSH BP ;спасти в стеке старое значение BP
MOV SP,BP ;установить BP на вершину стека
SUB SP,m ;отвести в стеке место (m байтов) под локальные
;величины подпрограммы (состояние стека в этот ;момент показано на рис. б)
Поясним эти «входные» команды. В подпрограмме для обращения к ячейкам стека, занятых параметрами, используется (как базовый) регистр BP: если в BP занести адрес вершины стека, то для доступа к этим ячейкам следует использовать адресные выражения вида i[BP] или, что то же самое, [BP+i]. (Отметим, что применять здесь регистры-модификаторы BX, SI и DI нельзя, т.к. формируемые по ним исполнительные адреса будут сегментироваться по умолчанию по регистру DS, а в данном случае нужно сегментирование по SS.) Однако данная подпрограмма может быть вызвана из другой, также использующей регистр BP, поэтому прежде, чем установить BP на вершину стека, надо спасти в стеке старое значение этого регистра, что и делает первая из «входных» команд. Вторая же команда устанавливает BP на вершину стека. Если предположить, что каждый параметр и адрес возврата занимают по слову памяти, тогда доступ к первому параметру обеспечивается адресным выражением [BP+4], ко второму — выражением [BP+6] и т.д. (см. рис. б).
Подпрограмме может потребоваться место для ее локальных величин.
Такое место обычно отводится в стеке (а для рекурсивных подпрограмм только в стеке) «над» ячейкой, занимаемой старым значением BP. Если под эти величины нужно m байтов, то такой «захват» места можно реализовать простым уменьшением значения регистра SP на m, что и делает 3-я «входная» команда. Доступ к локальным величинам обеспечивается адресными выражениями вида [BP-i]. Если подпрограмме не нужно место под локальные величины, тогда третью из «входных» команд следует опустить.
Выход из подпрограммы реализуется следующими командами:
MOV SP,BP ;очистить стек от локальных величин
POP BP ;восстановить старое значение BP
RET 2*k ;возврат из подпрограммы и очистка стека от
;параметров (считаем, что они занимают 2*k байтов) Первая из этих «выходных» команд заносит в регистр SP адрес той ячейки стека, где хранится старое значение регистра BP, т.е. происходит очистка стека от локальных величин (если их не было, то данную команду надо опустить). Вторая команда восстанавливает в BP это старое значение, одновременно удаляя его из стека. В этот момент состояние стека будет таким же, как и перед входом в подпрограмму (см. рис а). Третья команда считывает из стека адрес возврата (в результате чего SP «опускается» на 2 байта), затем добавляет к SP число, которое должно равняться числу байтов, занимаемых всеми параметрами подпрограммы, и затем осуществляет переход по адресу возврата. В этот момент состояние стека будет таким же, каким оно было перед обращением к подпрограмме.
Здесь описана универсальная схема организации работы подпрограмм.
В кокретных же случаях можно использовать более простые схемы. Например, параметры можно передавать не через стек, а через регистры, место под локальные величины можно отводить не в стеке, а в сегменте данных и т.п.

1.7.4 Процедуры в языке ассемблера
При составлении и вызове подпрограмм необходимо следить за тем, чтобы команды CALL и RET действовали согласовано — были одновременно близкими или дальними. В MASM эта проблема снимается, если подпрограмму описать как процедуру. Процедуры имеют следующий вид:
имя_процедуры PROC [NEAR или FAR]
…
имя_процедуры ENDP
Хотя в директиве PROC после имени процедуры не ставится двоеточие, это имя относится к меткам и его можно указывать в командах перехода, в частности в команде CALL, когда надо вызвать процедуру. Это же имя должно быть повторено в директиве ENDP, заканчивающей описание процедуры. Предложения между этими двумя директивами образуют тело процедуры (подпрограмму). Имя процедуры является фактически меткой первой из команд тела, поэтому данную команду не надо специально метить.
Если в директиве PROC указан параметр NEAR или он вообще не указан, то такая процедура считается «близкой» и обращаться к ней можно только из того сегмента команд, где она описана. Дело в том, что ассемблер будет заменять все команды CALL, где указано имя данной процедуры, на машинные команды близкого перехода с возвратом, а все команды RET внутри процедуры — на близкие возвраты. Если же в директиве PROC указан параметр FAR, то это «дальняя» процедура: все обращения к ней и все команды RET внутри нее рассматриваются ассемблером как дальние переходы. Обращаться к этой процедуре можно из любых сегментов команд. Таким образом, достаточно лишь указать тип процедуры (близкая она или дальняя), всю же остальную работу возьмет на себя ассемблер: переходы на нее и возвраты из нее будут автоматически согласованы с этим типом. В этом главное (и единственное) достоинство описания подпрограмм в виде процедур. (Отметим, что метки и имена, описанные в процедуре, не локализуются в ней.)
Например, вычисление ax:=sign(ax) можно описать в виде процедуры следующим образом:
sing proc far ;дальняя процедура
cmp ax,0
je sgn1 ;ax=0 — перейти к sgn1
mov ax,1 ;ax:=1 (флаги не изменились!)
jg sgn1 ;ax>0 — перейти к sgn1
mov ax,-1 ;ax:=-1
sgn1: ret ;дальний возврат
sign endp
…
Возможный пример обращения к этой процедуре:
;cx:=sign(var)
mov ax,var
call sign ;дальний вызов
mov cx,ax