| scrattr.bsd | screen attributes | [ scrattr ] |
| temp | | |
| aclm_down | deassert subsystem manager rights
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/aclm.h>
void aclm_$down(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/aclm.ins.pas';
procedure aclm_$down;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/aclm.ins.ftn'
call aclm_$down | [ aclm_$down ] |
| aclm_intro | change the protected subsystem privilege level
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/aclm.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/aclm.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/aclm.ins.ftn' | [ intro ] |
| aclm_up | assert subsystem manager rights
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/aclm.h>
void aclm_$up(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/aclm.ins.pas';
procedure aclm_$up;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/aclm.ins.ftn'
call aclm_$up | [ aclm_$up ] |
| cal_add_clock | add two clock values
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$add_clock(
time_$clock_t *clock1,
time_$clock_t &clock2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$add_clock(
var clock1: time_$clock_t;
in clock2: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock1(3), clock1h, clock2(3), clock2h
integer*4 clock1l, clock2l
equivalence (clock1l, clock1(2)), (clock1h, clock1(1))
equivalence (clock2l, clock2(2)), (clock2h, clock2(1))
call cal_$add_clock(clock1, clock2) | [ cal_$add_clock ] |
| cal_apply_local_offset | convert a UTC clock value to a local one
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$apply_local_offset(
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$apply_local_offset(
var clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call cal_$apply_local_offset(clock_value) | [ cal_$apply_local_offset ] |
| cal_clock_to_sec | convert clock ticks into whole seconds
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
unsigned long cal_$clock_to_sec(
time_$clock_t &clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
function cal_$clock_to_sec(
in clock_value: time_$clock_t): linteger;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl, seconds
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
seconds = cal_$clock_to_sec(clock_value) | [ cal_$clock_to_sec ] |
| cal_cmp_clock | compare two clock values
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
short cal_$cmp_clock(
time_$clock_t &clock1,
time_$clock_t &clock2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
function cal_$cmp_clock(
in clock1: time_$clock_t;
in clock2: time_$clock_t):integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 cmp, clock1(3), clock1h, clock2(3), clock2h
integer*4 clock1l, clock2l
equivalence (clock1l, clock1(2)), (clock1h, clock1(1))
equivalence (clock2l, clock2(2)), (clock2h, clock2(1))
cmp = cal_$cmp_clock(clock1, clock2) | [ cal_$cmp_clock ] |
| cal_decode_ascii_date | decode an ASCII date
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$decode_ascii_date(
char *date_string,
short &string_length,
short *year,
short *month,
short *day,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$decode_ascii_date(
in date_string: univ cal_$string_t;
in string_length: integer;
out year: integer;
out month: integer;
out day: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 string_length, year, month, day
integer*4 status
character date_string*80
call cal_$decode_ascii_date(date_string, string_length, year,
& month, day, status) | [ cal_$decode_ascii_date ] |
| cal_decode_ascii_time | decode an ascii time
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$decode_ascii_time(
char *time_string,
short &string_length,
short *hour,
short *minute,
short *second,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$decode_ascii_time(
in time_string: univ cal_$string_t;
in string_length: integer;
out hour: integer;
out minute: integer;
out second: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 string_length, hour, minute, second
integer*4 status
character time_string*80
call cal_$decode_ascii_time(time_string, string_length, hour,
& minute, second, status) | [ cal_$decode_ascii_time ] |
| cal_decode_ascii_tzdif | decode an ASCII time zone
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$decode_ascii_tzdif(
char *tz_string,
short &string_length,
short *tz_dif,
cal_$tz_name_t *tz_name,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$decode_ascii_tzdif(
in tz_string: univ cal_$string_t;
in string_length: integer;
out tz_dif: integer;
out tz_name: cal_$tz_name_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 string_length, tz_dif
integer*4 status
character tz_string*80, tz_name*4
call cal_$decode_ascii_tzdif(tz_string, string_length,
& tz_dif, tz_name, status) | [ cal_$decode_ascii_tzdif ] |
| cal_decode_local_time | get the local date and time
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$decode_local_time(
cal_$timedate_rec_t *local_date_time)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$decode_local_time(
out local_date_time: cal_$timedate_rec_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 local_date_time(6), year, month, day, hour, minute, second
equivalence (year, local_date_time(1)), (month, local_date_time(2))
equivalence (day, local_date_time(3)), (hour, local_date_time(4))
equivalence (minute, local_date_time(5)), (second, local_date_time(2))
call cal_$decode_local_time(local_date_time) | [ cal_$decode_local_time ] |
| cal_decode_time | decode a clock value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$decode_time(
time_$clock_t &clock_value,
cal_$timedate_rec_t *date_time)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$decode_time(
in clock_value: time_$clock_t;
out date_time: cal_$timedate_rec_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 date_time(6), clock_value(3), clockh
integer*2 year, month, day, hour, minute, second
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
equivalence (year, date_time(1)), (month, date_time(2))
equivalence (day, date_time(3)), (hour, date_time(4))
equivalence (minute, date_time(5)), (second, date_time(2))
call cal_$decode_time(clock_value, date_time) | [ cal_$decode_time ] |
| cal_encode_time | encode a date and time
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$encode_time(
cal_$timedate_rec_t &date_time,
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$encode_time(
in date_time: cal_$timedate_rec_t ;
out clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 date_time(6), clock_value(3), clockh
integer*2 year, month, day, hour, minute, second
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
equivalence (year, date_time(1)), (month, date_time(2))
equivalence (day, date_time(3)), (hour, date_time(4))
equivalence (minute, date_time(5)), (second, date_time(2))
call cal_$encode_time(date_time, clock_value) | [ cal_$encode_time ] |
| cal_float_clock | convert clock ticks into seconds
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$float_clock(
time_$clock_t &clock_value,
double *float_seconds)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$float_clock(
in clock_value: time_$clock_t;
out float_seconds: univ cal_$dpval_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
double precision float_seconds
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call cal_$float_clock(clock_value, float_seconds) | [ cal_$float_clock ] |
| cal_get_info | get the local time zone
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$get_info(
cal_$timezone_rec_t *time_zone)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$get_info(
out time_zone: cal_$timezone_rec_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 time_zone(6), utc_delta, drift(3), drifth
integer*4 driftl
character tz_name*4
equivalence (utc_delta, time_zone(1))
equivalence (tz_name, time_zone(2))
equivalence (drift, time_zone(4))
equivalence (driftl, drift(2)), (drifth, drift(1))
call cal_$get_info(time_zone) | [ cal_$get_info ] |
| cal_get_local_time | get the local time
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$get_local_time(
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$get_local_time(
out clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call cal_$get_local_time(clock_value) | [ cal_$get_local_time ] |
| cal_intro | the Domain/OS calendar service
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn' | [ intro ] |
| cal_remove_local_offset | convert local time to UTC
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$remove_local_offset(
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$remove_local_offset(
var clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call cal_$remove_local_offset(clock_value) | [ cal_$remove_local_offset ] |
| cal_sec_to_clock | convert seconds to a clock value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$sec_to_clock(
unsigned long &seconds,
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$sec_to_clock(
in seconds: linteger;
out clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock(3), clockh
integer*4 clockl, seconds
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call cal_$sec_to_clock(seconds, clock_value) | [ cal_$sec_to_clock ] |
| cal_sub_clock | subtract two clock values
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
boolean cal_$sub_clock(
time_$clock_t *clock1,
time_$clock_t &clock2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
function cal_$sub_clock(
var clock1: time_$clock_t;
in clock2: time_$clock_t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 clock1(3), clock1h, clock2(3), clock2h
integer*4 clock1l, clock2l
logical value
equivalence (clock1l, clock1(2)), (clock1h, clock1(1))
equivalence (clock2l, clock2(2)), (clock2h, clock2(1))
value = cal_$sub_clock(clock1, clock2) | [ cal_$sub_clock ] |
| cal_weekday | return the weekday for a date
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
cal_$weekday_t cal_$weekday(
short &year,
short &month,
short &day)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
function cal_$weekday(
in year: integer;
in month: integer;
in day: integer): cal_$weekday_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 weekday, year, month, day
weekday = cal_$weekday(year, month, day) | [ cal_$weekday ] |
| cal_write_timezone | set the local time zone
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/cal.h>
void cal_$write_timezone(
cal_$timezone_rec_t &time_zone,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/cal.ins.pas';
procedure cal_$write_timezone(
in time_zone: cal_$timezone_rec_t ;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/cal.ins.ftn'
integer*2 time_zone(6), utc_delta, drift(3), drifth
integer*4 driftl, status
character tz_name*4
equivalence (utc_delta, time_zone(1))
equivalence (tz_name, time_zone(2))
equivalence (drift, time_zone(4))
equivalence (driftl, drift(2)), (drifth, drift(1))
call cal_$write_timezone(time_zone, status) | [ cal_$write_timezone ] |
| ctm_alloc_pv | allocate unused pixel values
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
void ctm_$alloc_pv(
short &count,
ctm_$alloc_options_t &option,
short &plane,
ctm_$pixel_value_vector_t *pixel_values,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
procedure ctm_$alloc_pv(
in count: integer;
in option: ctm_$alloc_options_t;
var plane: integer;
out pixel_values: univ ctm_$pixel_value_vector_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn'
integer*2 count, option, plane
integer*4 status, pixel_values(256)
call ctm_$alloc_pv(count, option, plane, pixel_values, status) | [ ctm_$alloc_pv ] |
| ctm_find_color | find a color in the color map
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
void ctm_$find_color(
gpr_$color_t &color,
short &color_radius,
void *pixel_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
procedure ctm_$find_color(
in color: gpr_$color_t;
in color_radius: integer;
out pixel_value: univ gpr_$pixel_value_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn'
integer*2 color_radius
integer*4 status, pixel_value, color
call ctm_$find_color(color, color_radius, pixel_value, status) | [ ctm_$find_color ] |
| ctm_inc_use_count | increment pixel value use counts
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
void ctm_$inc_use_count(
short &count,
ctm_$alloc_options_t &option,
short &plane,
void *pixel_values,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
procedure ctm_$inc_use_count(
in count: integer;
in option: ctm_$alloc_options_t;
in plane: integer;
in pixel_values: univ ctm_$pixel_value_vector_t;
out status: status_$t );
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn'
integer*2 count, option, plane
integer*4 status, pixel_values(256)
call ctm_$inc_use_count(count, option, plane, pixel_values, status) | [ ctm_$inc_use_count ] |
| ctm_intro | Color Table Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn' | [ intro ] |
| ctm_mark_read_only | share pixel values with other processes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
void ctm_$mark_read_only(
short &count,
ctm_$alloc_options_t &option,
short &plane,
void *pixel_values,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
procedure ctm_$mark_read_only(
in count: integer;
in option: ctm_$alloc_options_t;
in plane: integer;
in pixel value: univ ctm_$pixel_value_vector_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn'
integer*2 count, option, plane
integer*4 status, pixel_values(256)
call ctm_$mark_read_only(count, option, plane, pixel_values, status) | [ ctm_$mark_read_only ] |
| ctm_release_pv | decrement pixel value use counts
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gpr.h>
#include <apollo/ctm.h>
void ctm_$release_pv(
short &count,
ctm_$alloc_options_t &option,
short &plane,
void *pixel_values,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gpr.ins.pas';
%include '/sys/ins/ctm.ins.pas';
procedure ctm_$release_pv(
in count: integer;
in option: ctm_$alloc_options_t;
in plane: integer;
in pixel_values: univ ctm_$pixel_value_vector_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ctm.ins.ftn'
integer*2 count, option, plane
integer*4 status, pixel_values(256)
call ctm_$release_pv(count, option, plane, pixel_values, status) | [ ctm_$release_pv ] |
| ec2_advance | increment an eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
void ec2_$advance(
ec2_$eventcount_t *eventcount,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
procedure ec2_$advance(
var eventcount: ec2_$eventcount_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 status, value
integer*2 eventcount(3)
equivalence (value, eventcount(1))
call ec2_$advance(eventcount, status) | [ ec2_$advance ] |
| ec2_init | initialize an eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
void ec2_$init(ec2_$eventcount_t *eventcount)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
procedure ec2_$init(out eventcount: ec2_$eventcount_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 value
integer*2 eventcount(3)
equivalence (value, eventcount(1))
call ec2_$init(eventcount) | [ ec2_$init ] |
| ec2_intro | Level 2 Eventcount Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn' | [ intro ] |
| ec2_read | return an eventcount value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
long ec2_$read(ec2_$eventcount_t &eventcount)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
function ec2_$read(in eventcount: ec2_$eventcount_t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 ec_value, value
integer*2 eventcount(3)
equivalence (value, eventcount(1))
ec_value = ec2_$read(eventcount) | [ ec2_$read ] |
| ec2_wait | wait for an eventcount trigger
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
pinteger ec2_$wait(
ec2_$ptr_t *ec_plist,
long *ec_vlist,
short &ec_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
function ec2_$wait(
in ec_plist: univ ec2_$ptr_list_t;
in ec_vlist: univ ec2_$val_list_t;
ec_count: integer;
out status: status_$t): pinteger;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 ec_plist(128), ec_vlist(128), status
integer*2 ec_satisfied, ec_count
ec_satisfied = ec2_$wait(ec_plist, ec_vlist, ec_count, status) | [ ec2_$wait ] |
| ec2_wait_slow_io | wait for an eventcount trigger during I/O
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
pinteger ec2_$wait_slow_io(
ec2_$ptr_t *ec_plist,
long *ec_vlist,
short &ec_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
function ec2_$wait_slow_io(
in ec_plist: univ ec2_$ptr_list_t;
in ec_vlist: univ ec2_$val_list_t;
ec_count: integer;
out status: status_$t): pinteger;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 ec_plist(128), ec_vlist(128), status
integer*2 ec_satisfied, ec_count
ec_satisfied = ec2_$wait_slow_io(ec_plist, ec_vlist, ec_count, status) | [ ec2_$wait_slow_io ] |
| ec2_wait_svc | wait for an eventcount trigger or asynchronous fault
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ec2.h>
pinteger ec2_$wait_svc(
ec2_$ptr_t *ec_plist,
long *ec_vlist,
short &ec_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ec2.ins.pas';
function ec2_$wait_svc(
in ec_plist: univ ec2_$ptr_list_t;
in ec_vlist: univ ec2_$val_list_t;
ec_count: integer;
out status: status_$t): pinteger;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ec2.ins.ftn'
integer*4 ec_plist(128), ec_vlist(128), status
integer*2 ec_satisfied, ec_count
ec_satisfied = ec2_$wait_svc(ec_plist, ec_vlist, ec_count, status) | [ ec2_$wait_svc ] |
| errlog_close | close an error log
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/errlog.h>
void errlog_$close(short &stream_id)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/errlog.ins.pas';
procedure errlog_$close(in stream_id: ios_$id_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/errlog.ins.ftn'
integer*4 stream_id
call errlog_$close(stream_id) | [ errlog_$close ] |
| errlog_fault_status | log a fault status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/errlog.h>
void errlog_$fault_status(short &stream_id)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/errlog.ins.pas';
procedure errlog_$fault_status(in stream_id: ios_$id_t)
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/errlog.ins.ftn'
integer*4 stream_id
call errlog_$fault_status(stream_id) | [ errlog_$fault_status ] |
| errlog_intro | Domain/OS error logging
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/errlog.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/errlog.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/errlog.ins.ftn' | [ intro ] |
| errlog_open | open an error log file and log an error
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/errlog.h>
short errlog_$open(
char *path_name,
short &path_length,
long &min_size,
long &time_out,
char *entry_comment,
short &comment_length,
long &fault_status,
short &errlog_options,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/errlog.ins.pas';
function errlog_$open(
in path_name: univ name_$pname_t;
in path_length: integer;
in min_size: integer32;
in time_out: integer32;
in entry_comment: univ string;
in comment_length: integer;
in fault_status: univ status_$t;
in errlog_options: errlog_$option_set_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/errlog.ins.ftn'
integer*2 path_length, comment_length, errlog_options
integer*4 min_size, time_out, status, stream_id
character path_name(1023), entry_comment(80)
stream_id = errlog_$open(path_name, path_length, min_size,
& time_out, entry_comment, comment_length,
& fault_status, errlog_options, status) | [ errlog_$open ] |
| errlog_traceback | log a stack traceback
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/errlog.h>
void errlog_$traceback(
short &stream_id,
short &traceback_options,
long &max_frames)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/errlog.ins.pas';
procedure errlog_$traceback(
in stream_id: ios_$id_t;
in traceback_options: errlog_$tb_opt_set_t;
in max_frames: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/errlog.ins.ftn'
integer*2 traceback_options
integer*4 stream_id, max_frames
call errlog_$traceback(stream_id, traceback_options, max_frames) | [ errlog_$traceback ] |
| error_code | return the error code from a completion status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
short error_$code(status_$t &status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
function error_$code(in status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 code
integer*4 status
code = error_$code(status) | [ error_$code ] |
| error_fail | test the fail bit in a completion status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
boolean error_$fail(status_$t &status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
function error_$fail(in status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
logical fail
integer*4 status
fail = error_$fail(status) | [ error_$fail ] |
| error_find_text | find error reporting text
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$find_text(
status_$t &status,
error_$string_t *subsys_p,
short *subsys_l,
error_$string_t *module_p,
short *module_l,
error_$string_t *code_p,
short *code_l)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$find_text(
in status: status_$t;
out subsys_p: univ_ptr;
out subsys_l: integer;
out module_p: univ_ptr;
out module_l: integer;
out code_p: univ_ptr;
out code_l: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*4 status
integer*2 subsys_l, module_l, code_l
character subsys_text*80, module_text*80, code_text*80
integer*4 subsys_p, module_p, code_p
pointer /subsys_p/ subsys_text
pointer /module_p/ module_text
pointer /code_p/ code_text
call error_$find_text(status, subsys_p, subsys_l, module_p,
& module_l, code_p, code_l) | [ error_$find_text ] |
| error_get_text | get error reporting text
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$get_text(
status_$t &status,
error_$string_t subsys_t,
short *subsys_l,
error_$string_t module_t,
short *module_l,
error_$string_t code_t,
short *code_l)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$get_text(
in status: status_$t;
out sub_n: error_$string_t;
out sub_nl: integer;
out mod_n: error_$string_t;
out mod_nl: integer;
out err_t: error_$string_t;
out err_l: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*4 status
integer*2 subsys_l, module_l, code_l
character subsys_t*80, module_t*80, code_t*80
call error_$get_text(status, subsys_t, subsys_l, module_t,
& module_l, code_t, code_l) | [ error_$get_text ] |
| error_init_std_format | initialize standard error reporting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$init_std_format(
stream_$id_t &stream_id,
char &prefix_char,
error_$string_t command_name,
short &command_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$init_std_format(
in stream_id: stream_$id_t;
in prefix_char: char;
in command_name: univ error_$string_t;
in command_length: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 stream_id, command_length
character prefix_char*1, command_name*80
call error_$init_std_format(stream_id, prefix_char,
& command_name, command_length) | [ error_$init_std_format ] |
| error_intro | Domain/OS error reporting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn' | [ intro ] |
| error_module | return the module code from a completion status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
short error_$module(status_$t &status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
function error_$module(in status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 module
integer*4 status
module = error_$module(status) | [ error_$module ] |
| error_print | print an error message
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$print(status_$t &status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$print(in status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*4 status
call error_$print(status) | [ error_$print ] |
| error_print_format | print an error message in standard format
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$print_format(
status_$t &status,
stream_$id_t &stream_id,
char &prefix_char,
error_$string_t command_name,
short &name_length,
error_$string_t control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$print_format(
in status: univ status_$t;
in stream_id: stream_$id_t;
in prefix_char: char;
in command_name: univ error_$string_t;
in name_length: integer;
in control_string: univ error_$string_t;
in a1,a2,a3,a4,a5,a6,a7,a8,a9,a10: univ error_$integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 stream_id, name_length
character prefix_char*1, command_name*80, control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call error_$print_format(status, stream_id, prefix_char, command_name,
& name_length, control_string, a1, a2, a3, a4,
& a5, a6, a7, a8, a9, a10) | [ error_$print_format ] |
| error_print_name | print error text with a name
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$print_name(
status_$t &status,
error_$string_t source_name,
pinteger &name_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$print_name(
in status: status_$t;
in source_name: univ error_$string_t;
in name_length: pinteger);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*4 status
integer*2 name_length
character source_name*80
call error_$print_name(status, source_name, name_length) | [ error_$print_name ] |
| error_std_format | print a standard error message
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
void error_$std_format(
status_$t &status,
error_$string_t control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
procedure error_$std_format(
in status: univ status_$t;
in control_string: univ error_$string_t;
in a1,a2,a3,a4,a5,a6,a7,a8,a9,a10: univ error_$integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call error_$std_format(status, control_string, a1, a2, a3, a4,
& a5, a6, a7, a8, a9, a10) | [ error_$std_format ] |
| error_subsys | return the subsystem code from a completion status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/error.h>
short error_$subsys(status_$t &status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/error.ins.pas';
function error_$subsys(in status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/error.ins.ftn'
integer*2 subsys
integer*4 status
subsys = error_$subsys(status) | [ error_$subsys ] |
| ev_delete_var | delete an environment variable
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
boolean ev_$delete_var(
char *variable_name,
short &name_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
function ev_$delete_var(
in variable_name: univ ev_$string_t;
in name_length: integer): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn'
integer*2 name_length
character variable_name*256
logical variable_found
variable_found = ev_$delete_var(variable_name, name_length) | [ ev_$delete_var ] |
| ev_exist_var | test an environment variable
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
boolean ev_$exist_var(
char *variable_name,
short &name_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
function ev_$exist_var(
in variable_name: univ ev_$string_t;
in name_length: integer): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn'
integer*2 name_length
character variable_name*256
logical variable_exists
variable_exists = ev_$exist_var(variable_name, name_length) | [ ev_$exist_var ] |
| ev_get_var | get an environment variable
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
boolean ev_$get_var(
char *variable_name,
short &name_length,
char **value_ptr,
short *value_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
function ev_$get_var(
in variable_name: univ ev_$string_t;
in name_length: integer;
out value_p: ev_$string_ptr_t;
out value_length: integer): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn'
integer*2 name_length, value_length
character variable_name*256, value*256
logical variable_exists
integer*4 value_ptr
pointer /value_ptr/ value
variable_exists = ev_$get_var(variable_name, name_length,
& value_ptr, value_length) | [ ev_$get_var ] |
| ev_intro | manipulating Domain/OS environment variables
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn' | [ intro ] |
| ev_read_var_entry | read an environment entry
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
extern boolean ev_$read_var_entry(
short *environment_index,
char **name_ptr,
short *name_length,
char **value_ptr,
short *value_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
function ev_$read_var_entry(
var environment_index: integer;
out name_ptr: ev_$string_ptr_t;
out name_length: integer;
out value_ptr: ev_$string_ptr_t;
out value_length: integer): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn'
integer*2 environment_index, name_length, value_length
character name*256, value*256
logical entry_exists
integer*4 name_ptr, value_ptr
pointer /name_ptr/ name
pointer /value_ptr/ value
entry_exists = ev_$read_var_entry(environment_index,
& name_ptr, name_length,
& value_ptr, value_length) | [ ev_$read_var_entry ] |
| ev_set_var | set an environment variable
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ev.h>
boolean ev_$set_var(
char *variable_name,
short &name_length,
char *variable_value,
short &value_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ev.ins.pas';
function ev_$set_var(
in variable_name: univ ev_$string_t;
in name_length: integer;
in variable_value: univ ev_$string_t;
in value_length: integer): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ev.ins.ftn'
integer*2 name_length, value_length
character variable_name*256, variable_value*256
logical variable_set
variable_set = ev_$set_var(variable_name, name_length,
& variable_value, value_length) | [ ev_$set_var ] |
| fault_intro | Domain/OS fault codes
SYNOPSIS (C)
#include <apollo/fault.h>
SYNOPSIS (Pascal)
%include '/sys/ins/fault.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/fault.ins.ftn' | [ intro ] |
| fpp_control | modify the floating-point control register
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$control(
fpp_op_t &option,
unsigned long int *control_reg,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$control(
in option: fpp_op_t;
var control_reg: set_32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status, control_reg
integer*2 option
call fpp_$control(option, control_reg, status) | [ fpp_$control ] |
| fpp_dp_infinity | return double-precision infinity
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_infinity(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_infinity: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 infinity
infinity = fpp_$dp_infinity() | [ fpp_$dp_infinity ] |
| fpp_dp_max_normal | return maximum positive normalized double-precision
value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_max_normal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_max_normal: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 max_normal
max_normal = fpp_$dp_max_normal() | [ fpp_$dp_max_normal ] |
| fpp_dp_max_subnormal | return maximum positive denormalized double-
precision value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_max_subnormal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_max_subnormal: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 max_subnormal
max_subnormal = fpp_$dp_max_subnormal() | [ fpp_$dp_max_subnormal ] |
| fpp_dp_min_normal | return minimum positive normalized double-precision
value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_min_normal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_min_normal: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 min_normal
min_normal = fpp_$dp_min_normal() | [ fpp_$dp_min_normal ] |
| fpp_dp_min_subnormal | return minimum positive denormalized double-
precision value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_min_subnormal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_min_subnormal: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 min_subnormal
min_subnormal = fpp_$dp_min_subnormal() | [ fpp_$dp_min_subnormal ] |
| fpp_dp_quiet_nan | return double-precision quiet NaN
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_quiet_nan(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_quiet_nan: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 quiet_nan
quiet_nan = fpp_$dp_quiet_nan() | [ fpp_$dp_quiet_nan ] |
| fpp_dp_signaling_nan | return double-precision signaling NaN
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
double fpp_$dp_signaling_nan(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$dp_signaling_nan: double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 signaling_nan
signaling_nan = fpp_$dp_signaling_nan() | [ fpp_$dp_signaling_nan ] |
| fpp_get_accrued_exceptions | read accrued exception status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$get_accrued_exceptions(
fpp_$accumulated_status_t *accrued_exceptions,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$get_accrued_exceptions(
out accrued_exceptions: fpp_$accumulated_status_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 accrued_exceptions
integer*4 status
call fpp_$get_accrued_exceptions(accrued_exceptions, status) | [ fpp_$get_accrued_exceptions ] |
| fpp_get_ieee_underflow_mode | report the underflow mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$get_ieee_underflow_mode(
boolean *ieee_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$get_ieee_underflow_mode(
out ieee_mode: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
logical ieee_mode
integer*4 status
call fpp_$get_ieee_underflow_mode(ieee_mode, status) | [ fpp_$get_ieee_underflow_mode ] |
| fpp_get_mc68881_precision_mode | report the precision mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$get_mc68881_precision_mode(
fpp_$mc68881_precision_mode_t *precision_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$get_mc68881_precision_mode(
out precision_mode: fpp_$mc68881_precision_mode_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 precision_mode
integer*4 status
call fpp_$get_mc68881_precision_mode(precision_mode, status) | [ fpp_$get_mc68881_precision_mode ] |
| fpp_get_rounding_mode | report the current rounding mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$get_rounding_mode(
fpp_$rounding_mode_t *rounding_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$get_rounding_mode(
out rounding_mode: fpp_$rounding_mode_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 rounding_mode
integer*4 status
call fpp_$get_rounding_mode(rounding_mode, status) | [ fpp_$get_rounding_mode ] |
| fpp_get_trap_enables | report enabled floating-point exception traps
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$get_trap_enables(
fpp_$trap_enables_t *enabled_traps,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$get_trap_enables(
out enabled_traps: fpp_$trap_enables_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 enabled_traps
integer*4 status
call fpp_$get_trap_enables(enabled_traps, status) | [ fpp_$get_trap_enables ] |
| fpp_intro | the Domain/OS Floating-Point Package
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn' | [ intro ] |
| fpp_restore | load a new floating-point state
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
short int fpp_$restore(
void *&save_area_ptr,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$restore(
in save_area_ptr: univ_ptr;
out status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status, save_area_ptr, save_area(26)
integer*2 bytes_restored
pointer /save_area_ptr/ save_area
bytes_restored = fpp_$restore(save_area_ptr, status) | [ fpp_$restore ] |
| fpp_save | save the floating-point state
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
short int fpp_$save(
void *&save_area_ptr,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$save(
in save_area_ptr: univ_ptr;
out status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status, save_area_ptr, save_area(26)
integer*2 bytes_saved
pointer /save_area_ptr/ save_area
bytes_saved = fpp_$save(save_area_ptr, status) | [ fpp_$save ] |
| fpp_save_restore | save the current and load a new floating-point state
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
short int fpp_$save_restore(
void *&save_area_ptr,
void *&restore_area_ptr,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$save_restore(
in save_area_ptr: univ_ptr;
in restore_area_ptr: univ_ptr;
out status: status_$t): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status, save_area_ptr, restore_area_ptr
integer*4 save_area(26), restore_area(26)
integer*2 bytes_moved
pointer /save_area_ptr/ save_area
pointer /restore_area_ptr/ restore_area
bytes_moved = fpp_$save_restore(save_area_ptr, restore_area_ptr,
& status) | [ fpp_$save_restore ] |
| fpp_save_restore_size | return the size of a floating-point state
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
short int fpp_$save_restore_size(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$save_restore_size: integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 save_area_size
save_area_size = fpp_$save_restore_size | [ fpp_$save_restore_size ] |
| fpp_set_accrued_exceptions | set accrued exception status
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_accrued_exceptions(
fpp_$accumulated_status_t accrued_exceptions,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_accrued_exceptions(
in accrued_exceptions: fpp_$accumulated_status_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 accrued_exceptions
integer*4 status
call fpp_$set_accrued_exceptions(accrued_exceptions, status) | [ fpp_$set_accrued_exceptions ] |
| fpp_set_default_modes | restore default floating-point modes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_default_modes(status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_default_modes(out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status
call fpp_$set_default_modes(status) | [ fpp_$set_default_modes ] |
| fpp_set_ieee_underflow_mode | set the underflow mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_ieee_underflow_mode(
boolean ieee_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_ieee_underflow_mode(
in ieee_mode: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
logical ieee_mode
integer*4 status
call fpp_$set_ieee_underflow_mode(ieee_mode, status) | [ fpp_$set_ieee_underflow_mode ] |
| fpp_set_mc68881_precision_mode | set the precision mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_mc68881_precision_mode(
fpp_$mc68881_precision_mode_t precision_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_mc68881_precision_mode(
in precision_mode: fpp_$mc68881_precision_mode_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 precision_mode
integer*4 status
call fpp_$set_mc68881_precision_mode(precision_mode, status) | [ fpp_$set_mc68881_precision_mode ] |
| fpp_set_rounding_mode | set the rounding mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_rounding_mode(
fpp_$rounding_mode_t rounding_mode,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_rounding_mode(
in rounding_mode: fpp_$rounding_mode_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 rounding_mode
integer*4 status
call fpp_$set_rounding_mode(rounding_mode, status) | [ fpp_$set_rounding_mode ] |
| fpp_set_trap_enables | set floating-point exception traps
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$set_trap_enables(
fpp_$trap_enables_t enabled_traps,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$set_trap_enables(
in enabled_traps: fpp_$trap_enables_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*2 enabled_traps
integer*4 status
call fpp_$set_trap_enables(enabled_traps, status) | [ fpp_$set_trap_enables ] |
| fpp_sp_infinity | return single-precision infinity
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_infinity(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_infinity: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 infinity
infinity = fpp_$sp_infinity() | [ fpp_$sp_infinity ] |
| fpp_sp_max_normal | return maximum positive normalized single-precision
value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_max_normal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_max_normal: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 max_normal
max_normal = fpp_$sp_max_normal() | [ fpp_$sp_max_normal ] |
| fpp_sp_max_subnormal | return maximum positive denormalized single-
precision value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_max_subnormal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_max_subnormal: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 max_subnormal
max_subnormal = fpp_$sp_max_subnormal() | [ fpp_$sp_max_subnormal ] |
| fpp_sp_min_normal | return minimum positive normalized single-precision
value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_min_normal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_min_normal: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 min_normal
min_normal = fpp_$sp_min_normal() | [ fpp_$sp_min_normal ] |
| fpp_sp_min_subnormal | return minimum positive denormalized single-
precision value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_min_subnormal(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_min_subnormal: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*8 min_subnormal
min_subnormal = fpp_$sp_min_subnormal() | [ fpp_$sp_min_subnormal ] |
| fpp_sp_quiet_nan | return single-precision quiet NaN
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_quiet_nan(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_quiet_nan: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 quiet_nan
quiet_nan = fpp_$sp_quiet_nan() | [ fpp_$sp_quiet_nan ] |
| fpp_sp_signaling_nan | return single-precision signaling NaN
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
float fpp_$sp_signaling_nan(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
function fpp_$sp_signaling_nan: real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
real*4 signaling_nan
signaling_nan = fpp_$sp_signaling_nan() | [ fpp_$sp_signaling_nan ] |
| fpp_status | modify the floating-point status register
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/fpp.h>
void fpp_$status(
fpp_op_t &option,
unsigned long int *status_reg,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/fpp.ins.pas';
procedure fpp_$status(
in option: fpp_op_t;
var status_reg: set_32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/fpp.ins.ftn'
integer*4 status, status_reg
integer*2 option
call fpp_$status(option, status_reg, status) | [ fpp_$status ] |
| gmf_close | close a GMF
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
void gmf_$close(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
procedure gmf_$close(
in stream_id: ios_$id_t;
out status: status_$t );
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn'
integer*4 status
integer*2 stream_id
call gmf_$close(stream_id, status) | [ gmf_$close ] |
| gmf_copy_plane | copy a bitmap plane to a GMF
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
void gmf_$copy_plane(
ios_$id_t &stream_id,
boolean &black_or_white,
short &bpi,
void *&plane_ptr,
short &x_dimension,
short &y_dimension,
short &wpl,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
procedure gmf_$copy_plane(
in sid: ios_$id_t;
in black_or_white: boolean;
in bpi: integer;
in plane_ptr: univ gmf_$memory_ptr_t;
in x_dimension: integer;
in y_dimension: integer;
in wpl: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn'
integer*4 status
integer*2 stream_id, bpi, x_dimension, y_dimension
integer*2 wpl, bits(65535)
logical black_or_white
integer*4 plane_ptr
pointer /plane_ptr/ bits
call gmf_$copy_plane(stream_id, black_or_white, bpi, plane_ptr,
& x_dimension, y_dimension, wpl, status) | [ gmf_$copy_plane ] |
| gmf_copy_subplane | copy part of a bitmap plane to a GMF
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
void gmf_$copy_subplane(
ios_$id_t &stream_id,
boolean &black_or_white,
short &bpi,
void *&plane_origin,
short &x_dimension,
short &y_dimension,
short &x_offset,
short &y_offset,
short &wpl,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
procedure gmf_$copy_subplane(
in stream_id: ios_$id_t;
in black_or_white: boolean;
in bpi: integer;
in plane_origin: univ gmf_$memory_ptr_t;
in x_dimension: integer;
in y_dimension: integer;
in x_off: integer;
in y_off: integer;
in wpl: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn'
integer*4 status
integer*2 stream_id, bpi, x_dimension, y_dimension, wpl
integer*2 x_offset, y_offset, bits(65535)
logical black_or_white
integer*4 plane_origin
pointer /plane_origin/ bits
call gmf_$copy_subplane(stream_id, black_or_white, bpi,
& plane_origin, x_dimension, y_dimension,
& x_offset, y_offset, wpl, status) | [ gmf_$copy_subplane ] |
| gmf_intro | using graphics metafiles
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn' | [ intro ] |
| gmf_open | open a GMF
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
void gmf_$open(
char *path_name,
short &name_length,
gmf_$opos_t &option,
ios_$id_t *stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
procedure gmf_$open(
in path_name: univ name_$long_pname_t;
in name_length: integer;
in option: gmf_$opos_t;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn'
integer*4 status
integer*2 stream_id, name_length, option
character path_name*1023
call gmf_$open(path_name, name_length, option, stream_id, status) | [ gmf_$open ] |
| gmf_restore_plane | restore a bitmap from a GMF
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/gmf.h>
void gmf_$restore_plane(
ios_$id_t &stream_id,
short &x_dimension,
short &y_dimension,
short &wpl,
short *&plane_ptr,
short *bpi,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/gmf.ins.pas';
procedure gmf_$restore_plane(
in stream_id: ios_$id_t;
in x_dimension: integer
in y_dimension: integer;
in wpl: integer;
in plane_ptr: univ_ptr;
out bpi: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/gmf.ins.ftn'
integer*4 status
integer*2 stream_id, bpi, x_dimension, y_dimension
integer*2 wpl, bits(65535)
integer*4 plane_ptr
pointer /plane_ptr/ bits
call gmf_$restore_plane(stream_id, x_dimension, y_dimension,
& wpl, plane_ptr, bpi, status) | [ gmf_$restore_plane ] |
| ios_change_path_name | change an object's pathname
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$change_path_name(
ios_$id_t &stream_id,
char *new_pathname,
short &new_namelength,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$change_path_name(
in stream_id: ios_$id_t;
in new_pathname: univ name_$long_pname_t;
in new_namelength: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, new_name_length
integer*4 status
character new_pathname*1023
call ios_$change_path_name(stream_id, new_pathname,
& new_namelength, status) | [ ios_$change_path_name ] |
| ios_close | close a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$close(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$close(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$close(stream_id, status) | [ ios_$close ] |
| ios_create | create an object and open a stream to it
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/type_uids.h>
#include <apollo/ios.h>
void ios_$create(
char *pathname,
short &name_length,
uid_$t &type_uid,
ios_$create_mode_t &create_option,
ios_$open_options_t &open_options,
ios_$id_t *stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/type_uids.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$create(
in pathname: univ name_$long_pname_t;
in namelength: integer;
in type_uid: uid_$t;
in create_option: ios_$create_mode_t;
in open_options: ios_$open_options_t;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/type_uids.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 name_length, create_option, open_options, stream_id
integer*4 type_uid(2), status
character pathname*1023
call ios_$create(pathname, name_length, type_uid, create_option,
& open_options, stream_id, status) | [ ios_$create ] |
| ios_delete | delete an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$delete(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$delete(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$delete(stream_id, status) | [ ios_$delete ] |
| ios_dir_intro | stream access to directories
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn' | [ intro ] |
| ios_dir_isa | test whether a stream is open on a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios_dir.h>
void ios_dir_$isa(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
procedure ios_dir_$isa(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_dir_$isa(stream_id, status) | [ ios_dir_$isa ] |
| ios_dir_open | open an object in an open directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
ios_$id_t ios_dir_$open(
ios_$id_t &dir_id,
name_$long_name_t leaf_name,
short &leaf_namelen,
ios_$open_options_t &open_options,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
function ios_dir_$open(
in dir_id: ios_$id_t;
in leaf_name: univ name_$long_name_t;
in leaf_namelen: integer;
in open_options: ios_$open_options_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, dir_id, leaf_namelen, open_options
integer*4 status
character leaf_name*256
stream_id = ios_dir_$open(dir_id, leaf_name, leaf_namelen,
& open_options, status) | [ ios_dir_$open ] |
| ios_dir_readdir | read a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
boolean ios_dir_$readdir(
ios_$id_t &stream_id,
long &max_count,
long &dir_list_size,
ios_dir_$buf_t dir_list,
long *read_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
function ios_dir_$readdir(
in stream_id: ios_$id_t;
in max_count: integer32;
in dir_list_size: integer32;
out dir_list: univ ios_dir_$buf_t;
out read_count: integer32;
out status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 maxbuf
parameter (maxbuf = 1000)
integer*2 stream_id, dir_list(maxbuf)
integer*4 max_count, dir_list_size, read_count, status
logical value
value = ios_dir_$readdir(stream_id, max_count, dir_list_size,
& dir_list, read_count, status) | [ ios_dir_$readdir ] |
| ios_dir_rewinddir | rewind a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
void ios_dir_$rewindddir(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
procedure ios_dir_$rewinddir(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_dir_$rewinddir(stream_id, status) | [ ios_dir_$rewinddir ] |
| ios_dir_seekdir | seek in a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
void ios_dir_$seekdir(
ios_$id_t &stream_id,
long &seek_key,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
procedure ios_dir_$seekdir(
in stream_id: ios_$id_t;
in seek_key: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id
integer*4 seek_key, status
call ios_dir_$seekdir(stream_id, seek_key, status) | [ ios_dir_$seekdir ] |
| ios_dir_telldir | return a seek key for a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
#include <apollo/ios_dir.h>
long ios_dir_$telldir(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
%include '/sys/ins/ios_dir.ins.pas';
function ios_dir_$telldir(
in stream_id: ios_$id_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id
integer*4 status
integer*4 seek_key
seek_key = ios_dir_$telldir(stream_id, status) | [ ios_dir_$telldir ] |
| ios_dup | duplicate a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$id_t ios_$dup(
ios_$id_t &old_stream_id,
ios_$id_t &new_stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$dup(
in old_stream_id: ios_$id_t;
in new_stream_id: ios_$id_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 return_stream_id, old_stream_id, new_stream_id
integer*4 status
return_stream_id = ios_$dup(old_stream_id,
& new_stream_id, status) | [ ios_$dup ] |
| ios_equal | determine if two streams are open on the same object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
boolean ios_$equal(
ios_$id_t &stream_id,
ios_$id_t &stream_id_too,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$equal(
in stream_id: ios_$id_t;
in stream_id_too: ios_$id_t;
out status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, stream_id_too
integer*4 status
character*1 csame
logical same
equivalence (csame, same)
csame = ios_$equal(stream_id, stream_id_too, status) | [ ios_$equal ] |
| ios_force_write_file | save an object to permanent storage
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$force_write_file(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$force_write_file(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$force_write_file(stream_id, status) | [ ios_$force_write_file ] |
| ios_get | read data from a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$get(
ios_$id_t &stream_id,
ios_$put_get_opts_t &get_options,
char *get_buffer,
long &buffer_size,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$get(
in stream_id: ios_$id_t;
in get_options: ios_$put_get_opts_t;
out get_buffer: univ string;
in buffer_size: integer32;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 buf_length
parameter (buf_length = 128)
integer*2 stream_id, get_options
integer*4 ret_length, buffer_size, status
character get_buffer*(buf_length)
ret_length = ios_$get(stream_id, get_options, get_buffer,
& buffer_size, status) | [ ios_$get ] |
| ios_get_dir_lc | get the current working or naming directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$get_dir_lc(
ios_$dir_type_t &dir_type,
short &buffer_length,
char *path_name,
short *path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$get_dir_lc(
in dir_type: ios_$dir_type_t;
in buffer_length: integer;
out path_name: univ name_$long_pname_t;
out path_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 dir_type, buffer_length, name_length
integer*4 status
character path_name*1023
call ios_$get_dir_lc(dir_type, buffer_length, path_name, path_length, status) | [ ios_$get_dir_lc ] |
| ios_get_ec | get a pointer to a stream eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$get_ec(
ios_$id_t &stream_id,
ios_$ec_key_t &stream_key,
ec2_$ptr_t *eventcount_pointer,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$get_ec(
in stream_id: ios_$id_t;
in stream_key: ios_$ec_key_t;
out eventcount_pointer: ec2_$ptr_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, stream_key, event(3)
integer*4 status, value
integer*4 eventcount_pointer
pointer /eventcount_pointer/ event
equivalence (value, event(1))
call ios_$get_ec(stream_id, stream_key, eventcount_pointer, status) | [ ios_$get_ec ] |
| ios_get_handle | convert a stream ID to a handle
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/type_uids.h>
#include <apollo/ios.h>
void *ios_$get_handle(
ios_$id_t &stream_id,
uid_$t &type_uid,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/type_uids.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$get_handle(
in stream_id: ios_$id_t;
in type_uid: uid_$t;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/type_uids.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 handle, type_uid(2), status
handle = ios_$get_handle(stream_id, type_uid, status) | [ ios_$get_handle ] |
| ios_inq_byte_pos | return the byte position of a stream marker
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$inq_byte_pos(
ios_$id_t &stream_id,
ios_$pos_opt_t &position_option,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_byte_pos(
in stream_id: ios_$id_t;
in position_option: ios_$pos_opt_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, position_option
integer*4 byte_position, status
byte_pos = ios_$inq_byte_pos(stream_id, position_option, status) | [ ios_$inq_byte_pos ] |
| ios_inq_conn_flags | return connection attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$conn_flag_set ios_$inq_conn_flags(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_conn_flags(
in stream_id: ios_$id_t;
out status: status_$t): ios_$conn_flag_set;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 conn_flags, status
conn_flags = ios_$inq_conn_flags(stream_id, status) | [ ios_$inq_conn_flags ] |
| ios_inq_cur_rec_len | return the length of the next record
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$inq_cur_rec_len(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_cur_rec_len(
in stream_id: ios_$id_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 rec_length, status
rec_length = ios_$inq_cur_rec_len(stream_id, status) | [ ios_$inq_cur_rec_len ] |
| ios_inq_file_attr | get file attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$inq_file_attr(
ios_$id_t &stream_id,
time_$clockh_t *dt_created,
time_$clockh_t *dt_modified,
time_$clockh_t *dt_used,
long *blocks,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$inq_file_attr(
in stream_id: ios_$id_t;
out dt_created: time_$clockh_t;
out dt_modified: time_$clockh_t;
out dt_used: time_$clockh_t;
out blocks: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 dt_created, dt_modified, dt_used, blocks, status
call ios_$inq_file_attr(stream_id, dt_created, dt_modified,
& dt_used, blocks, status) | [ ios_$inq_file_attr ] |
| ios_inq_full_key | return a full seek key
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$inq_full_key(
ios_$id_t &stream_id,
ios_$pos_opt_t &positon_option,
ios_$seek_key_t *full_key,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$inq_full_key(
in stream_id: ios_$id_t;
in position_option: ios_$pos_opt_t;
out full_key: ios_$seek_key_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, position_option
integer*4 full_key(2), status
call ios_$inq_full_key(stream_id, position_option,
& full_key, status) | [ ios_$inq_full_key ] |
| ios_inq_mgr_flags | return manager attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$mgr_flag_set ios_$inq_mgr_flags(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_mgr_flags(
in stream_id: ios_$id_t;
out status: status_$t): ios_$mgr_flag_set;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 mgr_flags, status
mgr_flags = ios_$inq_mgr_flags(stream_id, status) | [ ios_$inq_mgr_flags ] |
| ios_inq_obj_flags | return object attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$obj_flag_set ios_$inq_obj_flags(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_obj_flags(
in stream_id: ios_$id_t;
out status: status_$t): ios_$obj_flag_set;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 obj_flags, status
obj_flags = ios_$inq_obj_flags(stream_id, status) | [ ios_$inq_obj_flags ] |
| ios_inq_path_name_lc | get an object's pathname
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$inq_path_name_lc(
ios_$id_t &stream_id,
ios_$name_type_t &name_type,
short &buffer_length,
char *pathname,
short *namelength,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$inq_path_name_lc(
in stream_id: ios_$id_t;
in name_type: ios_$name_type_t;
in buffer_length: integer;
out pathname: univ name_$long_pname_t;
out namelength: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, name_type
integer*2 buffer_length, name_length
integer*4 status
character pathname*1023
call ios_$inq_path_name_lc(stream_id, name_type, buffer_length
& pathname, name_length, status) | [ ios_$inq_path_name_lc ] |
| ios_inq_rec_pos | return the record position of a stream marker
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$inq_rec_pos(
ios_$id_t &stream_id,
ios_$pos_opt_t &position_option,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_rec_pos(
in stream_id: ios_$id_t;
in position_option: ios_$pos_opt_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, position_option
integer*4 record_position, status
rec_pos = ios_$inq_rec_pos(stream_id, position_option, status) | [ ios_$inq_rec_pos ] |
| ios_inq_rec_remainder | return the number of bytes left in a record
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$inq_rec_remainder(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_rec_remainder(
in stream_id: ios_$id_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 bytes, status
bytes = ios_$inq_rec_remainder(stream_id, status) | [ ios_$inq_rec_remainder ] |
| ios_inq_rec_type | return the record type of an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$rtype_t ios_$inq_rec_type(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_rec_type(
in stream_id: ios_$id_t;
out status: status_$t): ios_$rtype_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, record_type
integer*4 status
record_type = ios_$inq_rec_type(stream_id, status) | [ ios_$inq_rec_type ] |
| ios_inq_short_key | return a short seek key
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$inq_short_key(
ios_$id_t &stream_id,
ios_$pos_opt_t &position_option,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$inq_short_key(
in stream_id: ios_$id_t;
in position_option: ios_$pos_opt_t;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, position_option
integer*4 short_key, status
short_key = ios_$inq_short_key(stream_id, position_option, status) | [ ios_$inq_short_key ] |
| ios_inq_type_uid | get the type of an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/type_uids.h>
#include <apollo/ios.h>
void ios_$inq_type_uid(
ios_$id_t &stream_id,
uid_$t *type_uid,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/type_uids.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$inq_type_uid(
in stream_id: ios_$id_t;
out type_uid: uid_$t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/type_uids.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 type_uid(2), status
call ios_$inq_type_uid(stream_id, type_uid, status) | [ ios_$inq_type_uid ] |
| ios_intro | device-independent I/O
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/type_uids.h>
#include <apollo/ios.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/type_uids.ins.pas';
%include '/sys/ins/ios.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/type_uids.ins.ftn'
%include '/sys/ins/ios.ins.ftn' | [ intro ] |
| ios_locate | get a pointer to data in a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
long ios_$locate(
ios_$id_t &stream_id,
ios_$put_get_opts_t &get_options,
char **data_ptr,
long &data_size,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$locate(
in stream_id: ios_$id_t;
in get_options: ios_$put_get_opts_t;
out data_ptr: univ_ptr;
in data_size: integer32;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 nbytes
parameter (nbytes=12)
integer*2 stream_id, get_options
integer*4 ret_length, data_size, status
character*1 data(nbytes)
integer*4 data_ptr
pointer /data_ptr/ data
ret_length = ios_$locate(stream_id, get_options, data_ptr,
& data_size, status) | [ ios_$locate ] |
| ios_open | open an existing object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$id_t ios_$open(
char *path_name,
short &path_length,
ios_$open_options_t &open_options,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$open(
in path_name: univ name_$long_pname_t;
in path_length: integer;
in open_options: ios_$open_options_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, name_length, open_options
integer*4 status
character path_name*1023
stream_id = ios_$open(path_name, name_length, open_options, status) | [ ios_$open ] |
| ios_put | write to an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$put(
ios_$id_t &stream_id,
ios_$put_get_opts_t &put_options,
char *put_buffer,
long &buffer_size,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$put(
in stream_id: ios_$id_t;
in put_options: ios_$put_get_opts_t;
in put_buffer: univ string;
in buffer_size: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 nbytes
parameter (nbytes = 128)
integer*2 stream_id, put_options
integer*4 buffer_size, status
character put_buffer*(nbytes)
call ios_$put(stream_id, put_options, put_buffer, buffer_size, status) | [ ios_$put ] |
| ios_replicate | replicate a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$id_t ios_$replicate(
ios_$id_t &old_stream_id,
ios_$id_t &new_stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$replicate(
in old_stream_id: ios_$id_t;
in new_stream_id: ios_$id_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 return_stream_id, old_stream_id, new_stream_id
integer*4 status
return_stream_id = ios_$replicate(old_stream_id,
& new_stream_id, status) | [ ios_$replicate ] |
| ios_seek | seek on a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$seek(
ios_$id_t &stream_id,
ios_$abs_rel_t &abs_rel,
ios_$seek_type_t &seek_type,
long &offset,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$seek(
in stream_id: ios_$id_t;
in abs_rel: ios_$abs_rel_t;
in seek_type: ios_$seek_type_t;
in offset: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, abs_rel, seek_type
integer*4 offset, status
call ios_$seek(stream_id, abs_rel, seek_type, offset, status) | [ ios_$seek ] |
| ios_seek_full_key | seek with a full key
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$seek_full_key(
ios_$id_t &stream_id,
ios_$seek_key_t &full_key,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$seek_full_key(
in stream_id: ios_$id_t;
in full_key: ios_$seek_key_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 full_key(2), status
call ios_$seek_full_key(stream_id, full_key, status) | [ ios_$seek_full_key ] |
| ios_seek_short_key | seek with a short key
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$seek_short_key(
ios_$id_t &stream_id,
long &short_key,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$seek_short_key(
in stream_id: ios_$id_t;
in short_key: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 short_key, status
call ios_$seek_short_key(stream_id, short_key, status) | [ ios_$seek_short_key ] |
| ios_seek_to_bof | seek to the beginning of an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$seek_to_bof(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$seek_to_bof(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$seek_to_bof(stream_id, status) | [ ios_$seek_to_bof ] |
| ios_seek_to_eof | seek to the end of an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$seek_to_eof(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$seek_to_eof(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$seek_to_eof(stream_id, status) | [ ios_$seek_to_eof ] |
| ios_set_conn_flag | set connection attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$set_conn_flag(
ios_$id_t &stream_id,
ios_$conn_flag_t &conn_flag,
boolean &on_off,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$set_conn_flag(
in stream_id: ios_$id_t;
in conn_flag: ios_$conn_flag_t;
in on_off: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, conn_flag
integer*4 status
logical on_off
call ios_$set_conn_flag(stream_id, conn_flag, on_off, status) | [ ios_$set_conn_flag ] |
| ios_set_dir | change the current working or naming directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$set_dir(
char *pathname,
pinteger &namelength,
ios_$dir_type_t &dir_type,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$set_dir(
in pathname: univ name_$long_pname_t;
in namelength: pinteger;
in dir_type: ios_$dir_type_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 name_length, dir_type
integer*4 status
character pathname*1023
call ios_$set_dir(pathname, name_length, dir_type, status) | [ ios_$set_dir ] |
| ios_set_locate_buffer_size | set the locate buffer size
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$set_locate_buffer_size(
ios_$id_t &stream_id,
short &buffer_size,
status_$t *status )
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$set_locate_buffer_size(
in stream_id: ios_$id_t;
in buffer_size: integer;
out status: status_$t );
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, buffer_size
integer*4 status
call ios_$locate_buffer_size( stream_id, buffer_size, status ) | [ ios_$set_locate_buffer_size ] |
| ios_set_obj_flag | set object attributes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$set_obj_flag(
ios_$id_t &stream_id,
ios_$obj_flag_t &obj_flag,
boolean &on_off,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$set_obj_flag(
in stream_id: ios_$id_t;
in obj_flag: ios_$obj_flag_t;
in on_off: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, obj_flag
integer*4 status
logical on_off
call ios_$set_obj_flag(stream_id, obj_flag, on_off, status) | [ ios_$set_obj_flag ] |
| ios_set_rec_type | change an object's record type
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$set_rec_type(
ios_$id_t &stream_id,
ios_$rtype_t &record_type,
long &record_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$set_rec_type(
in stream_id: ios_$id_t;
in record_type: ios_$rtype_t;
in record_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id, record_type
integer*4 record_length, status
call ios_$set_rec_type(stream_id, record_type,
& record_length, status) | [ ios_$set_rec_type ] |
| ios_switch | switch a stream to another ID
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
ios_$id_t ios_$switch(
ios_$id_t &old_stream_id,
ios_$id_t &new_stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
function ios_$switch(
in old_stream_id: ios_$id_t;
in new_stream_id: ios_$id_t;
out status: status_$t): ios_$id_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 ret_stream_id, old_stream_id, new_stream_id
integer*4 status
ret_stream_id = ios_$switch(old_stream_id, new_stream_id, status) | [ ios_$switch ] |
| ios_truncate | truncate an object at the current stream marker
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ios.h>
void ios_$truncate(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ios.ins.pas';
procedure ios_$truncate(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ios.ins.ftn'
integer*2 stream_id
integer*4 status
call ios_$truncate(stream_id, status) | [ ios_$truncate ] |
| ipc_close | close an IPC socket
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$close(
char *path_name,
unsigned short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$close(
in path_name: univ name_$long_pname_t;
in path_length: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 path_length
integer*4 status
character path_name*1023
call ipc_$close(path_name, path_length, status) | [ ipc_$close ] |
| ipc_create | create an IPC socket
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$create(
char *path_name,
unsigned short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$create(
in path_name: univ name_$long_pname_t;
in path_length: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 path_length
integer*4 status
character path_name*1023
call ipc_$create(path_name, path_length, status) | [ ipc_$create ] |
| ipc_delete | delete an IPC socket
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$delete(
char *path_name,
unsigned short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$delete(
in path_name: univ name_$long_pname_t;
in path_length: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 path_length
integer*4 status
character path_name*1023
call ipc_$delete(path_name, path_length, status) | [ ipc_$delete ] |
| ipc_get_ec | get an IPC eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$get_ec(
ipc_$socket_handle_t socket_handle,
ec2_$ptr_t *eventcount_ptr,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$get_ec(
in socket_handle: ipc_$socket_handle_t;
out eventcount_ptr: ec2_$ptr_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*4 status, ec_value
character socket_handle*20
integer*2 event(3)
equivalence (ec_value, event(1))
integer*4 eventcount_ptr
pointer /eventcount_ptr/ event
call ipc_$get_ec(socket_handle, eventcount_ptr, status) | [ ipc_$get_ec ] |
| ipc_intro | Domain/OS Interprocess Communication
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn' | [ intro ] |
| ipc_open | open an IPC socket
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$open(
char *path_name,
unsigned short &path_length,
unsigned short &socket_depth,
ipc_$socket_handle_t *socket_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$open(
in path_name: univ name_$long_pname_t;
in path_length: pinteger;
in socket_depth: pinteger;
out socket_handle: ipc_$socket_handle_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 path_length, socket_depth
integer*4 status
character path_name*1023, socket_handle*20
call ipc_$open(path_name, path_length, socket_depth,
& socket_handle, status) | [ ipc_$open ] |
| ipc_rcv | retrieve an IPC datagram
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$rcv(
ipc_$socket_handle_t receive_socket,
unsigned short &header_buffer_size,
unsigned short &data_buffer_size,
ipc_$socket_handle_t from_socket,
void *header_buffer,
unsigned short *header_length,
void *data_buffer,
unsigned short *data_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$rcv(
in receive_socket: ipc_$socket_handle_t;
in header_buffer_size: pinteger;
in data_buffer_size: pinteger;
out from_socket: ipc_$socket_handle_t;
out header_buffer: univ ipc_$hdr_info_t;
out header_length: pinteger;
out data_buffer: univ ipc_$data_t;
out data_length: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 header_buffer_size, data_buffer_size
integer*2 header_length, data_length
integer*4 status
character receive_socket*20, from_socket*20
character header_buffer*128, data_buffer*1024
call ipc_$rcv(receive_socket, header_buffer_size,
& data_buffer_size, from_socket,
& header_buffer, header_length,
& data_buffer, data_length, status) | [ ipc_$rcv ] |
| ipc_resolve | get an IPC socket handle
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$resolve(
char *path_name,
unsigned short &path_length,
ipc_$socket_handle_t *socket_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$resolve(
in path_name: univ name_$long_pname_t;
in path_length: pinteger;
out socket_handle: ipc_$socket_handle_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 path_length
integer*4 status
character path_name*1023, socket_handle*20
call ipc_$resolve(path_name, path_length,
& socket_handle, status) | [ ipc_$resolve ] |
| ipc_sar | send an IPC datagram and await a reply
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$sar(
unsigned short &wait_time,
ipc_$socket_handle_t to_socket,
void *send_header,
unsigned short &send_header_size,
void *send_data,
unsigned short &send_data_size,
unsigned short &receive_header_limit,
unsigned short &receive_data_limit,
void *receive_header,
unsigned short *receive_header_size,
void *receive_data,
unsigned short *receive_data_size,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$sar(
in wait_time: pinteger;
in to_socket: ipc_$socket_handle_t;
in send_header: univ ipc_$hdr_info_t;
in send_header_size: pinteger;
in send_data: univ ipc_$data_t;
in send_data_size: pinteger;
in receive_header_limit: pinteger;
in receive_data_limit: pinteger;
out receive_header: univ ipc_$hdr_info_t;
out receive_header_size: pinteger;
out receive_data: univ ipc_$data_t;
out receive_data_size: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 wait_time, send_header_size, send_data_size,
integer*2 receive_header_limit, receive_data_limit
integer*2 receive_header_size, receive_data_size
integer*4 status
character to_socket*20, send_header*128, send_data*1024
character receive_header*128, receive_data*1024
call ipc_$sar(wait_time, to_socket,
& send_header, send_header_size,
& send_data, send_data_size,
& receive_header_limit, receive_data_limit,
& receive_header, receive_header_size,
& receive_data, receive_data_size, status) | [ ipc_$sar ] |
| ipc_send | send an IPC datagram
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$send(
ipc_$socket_handle_t to_socket,
ipc_$socket_handle_t from_socket,
void *header_buffer,
unsigned short &header_size,
void *data_buffer,
unsigned short &data_size,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$send(
in to_socket: ipc_$socket_handle_t;
in from_socket: ipc_$socket_handle_t;
in header_buffer: univ ipc_$hdr_info_t;
in header_size: pinteger;
in data_buffer: univ ipc_$data_t;
in data_size: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 header_size, data_size
integer*4 status
character to_socket*20, from_socket*20
character header_buffer*128, data_buffer*1024
call ipc_$send(to_socket, from_socket,
& header_buffer, header_size,
& data_buffer, data_size, status) | [ ipc_$send ] |
| ipc_wait | wait for an IPC datagram
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ipc.h>
void ipc_$wait(
ipc_$socket_handle_t socket_handle,
unsigned short &wait_time,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ipc.ins.pas';
procedure ipc_$wait(
in socket_handle: ipc_$socket_handle_t;
in wait_time: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ipc.ins.ftn'
integer*2 wait_time
integer*4 status
character socket_handle*20
call ipc_$wait(socket_handle, wait_time, status) | [ ipc_$wait ] |
| lib_intro | calls to manipulate predefined large sets
SYNOPSIS (C)
#include <apollo/base.h>
void lib_$init_set(
void *set,
short &set_size)
void lib_$add_to_set(
void *set,
short &set_size,
short &element)
void lib_$clr_from_set(
void *set,
short &set_size,
short &element)
boolean lib_$member_of_set(
void *set,
short &set_size,
short &element)
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*4 set(8)
integer*2 set_size, element
logical in_set
call lib_$init_set(set, set_size)
call lib_$add_to_set(set, set_size, element)
call lib_$clr_from_set(set, set_size, element)
in_set = lib_$member_of_set(set, set_size, element) | [ intro ] |
| loader_clear_inlib | clear the installed library list
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$clear_inlib(status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$clear_inlib(
out status: status_$t); | [ loader_$clear_inlib ] |
| loader_cond_load | ensure a module is loaded
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
boolean loader_$cond_load(
char *path_name,
short &path_length,
loader_$opts &load_options,
loader_$handle_t *image_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
function loader_$cond_load(
in path_name: univ name_$long_pname_t;
in path_length: integer;
in load_options: loader_$opts;
out image_handle: loader_$handle_t;
out status: status_$t): boolean; | [ loader_$cond_load ] |
| loader_inlib | create a privately installed library
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$inlib(
char *path_name,
short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$inlib(
in path_name: univ name_$long_pname_t;
in path_length: integer;
out status: status_$t); | [ loader_$inlib ] |
| loader_inquire_image | get image information
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$inquire_image(
loader_$handle_t &image_handle,
loader_$image *image_info,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$inquire_image(
in image_handle: loader_$handle_t;
out image_info: loader_$image;
out status: status_$t); | [ loader_$inquire_image ] |
| loader_inquire_known_lib | get information on known libraries
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$inquire_known_lib(
loader_$handle_t &image_handle,
loader_$known_lib *lib_info,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$inquire_known_lib(
in image_handle: loader_$handle_t;
out lib_info: loader_$known_lib;
out status: status_$t) | [ loader_$inquire_known_lib ] |
| loader_inquire_section | get information on an image section
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$inquire_section(
loader_$handle_t &image_handle,
unsigned long &load_index,
loader_$section *section_info,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$inquire_section(
in image_handle: loader_$handle_t;
in load_index: linteger;
out section_info: loader_$section;
out status: status_$t); | [ loader_$inquire_section ] |
| loader_inquire_stat | get a load history summation
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$inquire_stat(
unsigned long *load_count,
unsigned long *unload_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$inquire_stat(
out load_count: linteger;
out unload_count: linteger;
out status: status_$t); | [ loader_$inquire_stat ] |
| loader_intro | the Domain/OS loader
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas'; | [ intro ] |
| loader_kg_define | add to the Known Global Table (KGT)
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$kg_define(
char *global_name,
short &name_length,
void *&global_address,
long &global_size,
loader_$kg_define_opts &define_options,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$kg_define(
in global_name: univ loader_$string;
in name_length: loader_$string_index;
in global_address: univ_ptr;
in global_size: integer32;
in define_options: loader_$kg_define_opts;
out status: status_$t); | [ loader_$kg_define ] |
| loader_kg_lookup | look up a symbol
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
loader_$sym_flags loader_$kg_lookup(
char *global_name,
short &name_length,
long &global_type,
loader_$kg_lookup_opts &lookup_options,
void **global_address)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
function loader_$kg_lookup(
in global_name: univ loader_$string ;
in name_length: loader_$string_index;
in global_type: integer32;
in lookup_options: loader_$kg_lookup_opts;
out global_address: univ_ptr): loader_$sym_flags; | [ loader_$kg_lookup ] |
| loader_load | load a module
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void loader_$load(
char *path_name,
short &path_length,
loader_$opts &load_options,
loader_$handle_t *image_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
procedure loader_$load(
in path_name: univ name_$long_pname_t;
in path_length: integer;
in load_options: loader_$opts;
out image_handle: loader_$handle_t;
out status: status_$t); | [ loader_$load ] |
| loader_lookup_stack_size | get the stack size requirement of an image
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
unsigned long loader_$lookup_stack_size(
loader_$handle_t &image_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
function loader_$lookup_stack_size(
in image_handle: loader_$handle_t;
out status: status_$t): linteger; | [ loader_$lookup_stack_size ] |
| loader_lookup_start_addr | get the start address of an image
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/loader.h>
void *loader_$lookup_start_addr(
loader_$handle_t &image_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/loader.ins.pas';
function loader_$lookup_start_addr(
in image_handle: loader_$handle_t;
out status: status_$t): univ_ptr; | [ loader_$lookup_start_addr ] |
| mbx_client_window | return client buffer size
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
int mbx_$client_window(
void *&mbx_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
function mbx_$client_window(
in mbx_handle: univ_ptr;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 size, mbx_handle, status
size = mbx_$client_window(mbx_handle, status) | [ mbx_$client_window ] |
| mbx_close | close a channel or mailbox
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$close(
void *&mbx_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$close(
in mbx_handle: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, status
call mbx_$close(mbx_handle, status) | [ mbx_$close ] |
| mbx_cond_get_rec_chan | read a channel without waiting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$cond_get_rec_chan(
void *&mbx_handle,
short &mbx_channel,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$cond_get_rec_chan(
in mbx_handle: univ_ptr;
in mbx_channel: integer;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, return_length, status
integer*2 mbx_channel
integer*4 buffer_pointer, return_pointer
character buffer*32766, ret_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ ret_buffer
call mbx_$cond_get_rec_chan(mbx_handle, mbx_channel,
& buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$cond_get_rec_chan ] |
| mbx_cond_get_rec_chan_set | read a set of channels without waiting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_rec_chan_set(
void *&mbx_handle,
mbx_$chan_set_t &channel_set,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$cond_get_rec_chan_set(
in mbx_handle: univ_ptr;
in channel_set: mbx_$chan_set_t;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, channel_set(8)
integer*4 buffer_length, return_length, status
integer*4 buffer_pointer, return_pointer
character buffer*32766, ret_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ ret_buffer
call mbx_$cond_get_rec_chan_set(mbx_handle, channel_set,
& buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$cond_get_rec_chan_set ] |
| mbx_create_server | create a mailbox
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$create_server(
char *path_name,
short &path_length,
short &buffer_size,
short &max_channels,
void **mbx_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$create_server(
in path_name: univ mbx_$name_t;
in path_length: integer;
in buffer_size: integer;
in max_channels: integer;
out mbx_handle: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, status
integer*2 path_length, buffer_size, max_channels
character path_name*1023
call mbx_$create_server(path_name, path_length, buffer_size,
& max_channels, mbx_handle, status) | [ mbx_$create_server ] |
| mbx_deallocate | deallocate a channel
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$deallocate(
void *&mbx_handle,
short &mbx_channel,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$deallocate(
in mbx_handle: univ_ptr;
in mbx_channel: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, status
integer*2 mbx_channel
call mbx_$deallocate(mbx_handle, mbx_channel, status) | [ mbx_$deallocate ] |
| mbx_get_conditional | read a message without waiting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_conditional(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$get_conditional(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, return_length, status
integer*4 buffer_pointer, return_pointer
character buffer*32766, ret_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ return_buffer
call mbx_$get_conditional(mbx_handle, buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$get_conditional ] |
| mbx_get_ec | get a pointer to a mailbox eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_ec(
void *&mbx_handle,
mbx_$ec_key_t &mbx_key,
ec2_$ptr_t *eventcount_pointer,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$get_ec(
in mbx_handle: univ_ptr;
in mbx_key: mbx_$ec_key_t;
out eventcount_pointer: ec2_$ptr_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, status, ec_value
integer*2 mbx_key, event(3)
equivalence (ec_value, event(3))
integer*4 eventcount_pointer
pointer /eventcount_pointer/ event
call mbx_$get_ec(mbx_handle, mbx_key, eventcount_pointer, status) | [ mbx_$get_ec ] |
| mbx_get_rec | get a message from a mailbox
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_rec(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$get_rec(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, return_length, status
integer*4 buffer_pointer, return_pointer
character buffer*32766, return_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ return_buffer
call mbx_$get_rec(mbx_handle, buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$get_rec ] |
| mbx_get_rec_chan | read a mailbox channel
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_rec_chan(
void *&mbx_handle,
short &mbx_channel,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$get_rec_chan(
in mbx_handle: univ_ptr;
in mbx_channel: integer;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, return_length, status
integer*2 mbx_channel
integer*4 buffer_pointer, return_pointer
character buffer*32766, return_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ return_buffer
call mbx_$get_rec_chan(mbx_handle, mbx_channel,
& buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$get_rec_chan ] |
| mbx_get_rec_chan_set | read a set of channels
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$get_rec_chan_set(
void *&mbx_handle,
mbx_$chan_set_t &channel_set,
void *&buffer_pointer,
long &buffer_length,
void **return_pointer,
long *return_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$get_rec_chan_set(
in mbx_handle: univ_ptr;
in channel_set: mbx_$chan_set_t;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out return_pointer: univ_ptr;
out return_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, channel_set(8)
integer*4 buffer_length, return_length, status
integer*4 buffer_pointer, return_pointer
character buffer*32766, ret_buffer*32766
pointer /buffer_pointer/ buffer
pointer /return_pointer/ ret_buffer
call mbx_$get_rec_chan_set(mbx_handle, channel_set,
& buffer_pointer, buffer_length,
& return_pointer, return_length, status) | [ mbx_$get_rec_chan_set ] |
| mbx_intro | using mailboxes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn' | [ intro ] |
| mbx_open | open a client channel in a mailbox
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$open(
char *path_name,
short &path_length,
void *&buffer_pointer,
long &buffer_length,
void **mbx_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$open(
in path_name: univ mbx_$name_t;
in path_length: integer;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out mbx_handle: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, status
integer*2 path_length
character path_name*1023
integer*4 buffer_pointer
character buffer*32766
pointer /buffer_pointer/ buffer
call mbx_$open(path_name, path_length, buffer_pointer,
& buffer_length, mbx_handle, status) | [ mbx_$open ] |
| mbx_put_chr | send a partial message
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$put_chr(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$put_chr(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, status
integer*4 buffer_pointer
character buffer*32760
pointer /buffer_pointer/ buffer
call mbx_$put_chr(mbx_handle, buffer_pointer, buffer_length, status) | [ mbx_$put_chr ] |
| mbx_put_chr_cond | send a partial message without waiting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$put_chr_cond(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$put_chr_cond(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, status
integer*4 buffer_pointer
character buffer*32760
pointer /buffer_pointer/ buffer
call mbx_$put_chr_cond(mbx_handle, buffer_pointer, buffer_length, status) | [ mbx_$put_chr_cond ] |
| mbx_put_rec | send a message
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$put_rec(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$put_rec(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, status
integer*4 buffer_pointer
character buffer*32760
pointer /buffer_pointer/ buffer
call mbx_$put_rec(mbx_handle, buffer_pointer, buffer_length, status) | [ mbx_$put_rec ] |
| mbx_put_rec_cond | send a message without waiting
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$put_rec_cond(
void *&mbx_handle,
void *&buffer_pointer,
long &buffer_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$put_rec_cond(
in mbx_handle: univ_ptr;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 mbx_handle, buffer_length, status
integer*4 buffer_pointer
character buffer*32760
pointer /buffer_pointer/ buffer
call mbx_$put_rec_cond(mbx_handle, buffer_pointer, buffer_length, status) | [ mbx_$put_rec_cond ] |
| mbx_server_window | return server buffer size
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
int mbx_$server_window(
void *&mbx_handle,
short &mbx_channel,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
function mbx_$server_window(
in mbx_handle: univ_ptr;
in mbx_channel: integer;
out status: status_$t): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 size, mbx_handle, mbx_channel, status
size = mbx_$server_window(mbx_handle, mbx_channel, status) | [ mbx_$server_window ] |
| mbx_start_helper | start a mailbox helper
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
boolean mbx_$start_helper(status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
function mbx_$start_helper(
out status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*4 status
logical started
started = mbx_$start_helper(status) | [ mbx_$start_helper ] |
| mbx_timed_open | open a client channel with a timeout
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mbx.h>
void mbx_$timed_open(
char *path_name,
short &path_length,
void *&buffer_pointer,
long &buffer_length,
time_$clockh_t &wait_time,
void **mbx_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mbx.ins.pas';
procedure mbx_$timed_open(
in path_name: univ mbx_$name_t;
in path_length: integer;
in buffer_pointer: univ_ptr;
in buffer_length: integer32;
in wait_time: time_$clockh_t;
out mbx_handle: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mbx.ins.ftn'
integer*2 path_length, wait_time(3)
integer*4 buffer_length, mbx_handle, status
character path_name*1023
integer*4 buffer_pointer
character buffer*32760
pointer /buffer_pointer/ buffer
call mbx_$timed_open(path_name, path_length,
& buffer_pointer, buffer_length,
& wait_time, mbx_handle, status) | [ mbx_$timed_open ] |
| ms_addmap | map more of a object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$addmap(
void *&old_address,
unsigned long int &start,
unsigned long int &desired_length,
unsigned long int *mapped_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$addmap(
in old_address: univ_ptr;
in start: linteger;
in desired_length: linteger;
out mapped_length: linteger;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 start, desired_length, mapped_length, status
integer*4 address, old_address
integer*4 dummy1, dummy2
pointer /address/ dummy1
pointer /old_address/ dummy2
address = ms_$addmap(old_address, start, desired_length,
& mapped_length, status) | [ ms_$addmap ] |
| ms_advice | advise the system on mapped object access
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$advice(
void *&address,
unsigned long int &length,
ms_$access_t &access,
ms_$advice_t &options,
unsigned long int &record_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$advice(
in address: univ_ptr;
in length: linteger;
in access: ms_$access_t;
in options: ms_$advice_t;
in record_length: linteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 length, options, record_length, status
integer*2 access
integer*4 address, dummy
pointer /address/ dummy
call ms_$advice(address, length, access, options,
& record_length, status) | [ ms_$advice ] |
| ms_attributes | get the file attributes of a mapped object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$attributes(
void *&address,
ms_$attrib_t *attrib_buf,
short int *attrib_len,
short int &attrib_max,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$attributes(
in address: univ_ptr;
out attrib_buf: ms_$attrib_t;
out attrib_len: integer;
in attrib_max: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
integer*2 attrib_len, attrib_max
character*1 attrib_buf(22)
integer*4 cur_len, blocks_used, dtu, dtm, dtcr
character*1 permanent, immutable
equivalence (permanent, attrib_buf(1)),
equivalence (immutable, attrib_buf(2)),
equivalence (cur_len, attrib_buf(3)),
equivalence (blocks_used, attrib_buf(7)),
equivalence (dtu, attrib_buf(11)),
equivalence (dtm, attrib_buf(15)),
equivalence (dtcr, attrib_buf(19))
integer*4 address, dummy
pointer /address/ dummy
call ms_$attributes(address, attrib_buf, attrib_len, attrib_max, status) | [ ms_$attributes ] |
| ms_crmapl | create, map, and lock an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$crmapl(
char *name,
short int &name_length,
unsigned long int &start,
unsigned long int &desired_length,
ms_$conc_mode_t &concurrency,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$crmapl(
in name: univ name_$pname_t;
in name_length: integer;
in start: linteger;
in desired_length: linteger;
in concurrency: ms_$conc_mode_t;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 start, desired_length, status
integer*2 name_length, concurrency
character name*1023
integer*4 address, dummy
pointer /address/ dummy
address = ms_$crmapl(name, name_length, start, desired_length,
& concurrency, status) | [ ms_$crmapl ] |
| ms_crtemp | create, map, and lock a temporary object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$crtemp(
char *volume_name,
short int &name_length,
unsigned long int &start,
unsigned long int &desired_length,
ms_$conc_mode_t &concurrency,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$crtemp(
in volume_name: univ name_$pname_t;
in name_length: integer;
in start: linteger;
in desired_length: linteger;
in concurrency: ms_$conc_mode_t;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 start, desired_length, status
integer*2 name_length, concurrency
character volume_name*1023
integer*4 address, dummy
pointer /address/ dummy
address = ms_$crtemp(volume_name, name_length, start,
& desired_length, concurrency, status) | [ ms_$crtemp ] |
| ms_fw_file | synchronize a mapped object with the file system
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$fw_file(
void *&address,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$fw_file(
in address: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
integer*4 address, dummy
pointer /address/ dummy
call ms_$fw_file(address, status) | [ ms_$fw_file ] |
| ms_fw_partial | partially synchronize a mapped object with the file sys-
tem
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$fw_partial(
void *&address,
long int &length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$fw_partial(
in address: univ_ptr;
in length: integer32;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status, length
integer*4 address, dummy
pointer /address/ dummy
call ms_$fw_file(address, length, status) | [ ms_$fw_partial ] |
| ms_intro | mapping file system objects
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn' | [ intro ] |
| ms_mapl | map and lock an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$mapl(
char *name,
short int &name_length,
unsigned long int &start,
unsigned long int &desired_length,
ms_$conc_mode_t &concurrency,
ms_$acc_mode_t &access,
boolean &extend,
unsigned long int *length_mapped,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$mapl(
in name: univ name_$pname_t;
in name_length: integer;
in start: linteger;
in desired_length: linteger;
in concurrency: ms_$conc_mode_t;
in access: ms_$acc_mode_t;
in extend: boolean;
out length_mapped: linteger;
out status: status_$t) : univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 start, desired_length, length_mapped, status
integer*2 name_length, concurrency, access
logical extend
character name*1023
integer*4 address, dummy
pointer /address/ dummy
address = ms_$mapl(name, name_length, start, desired_length,
& concurrency, access, extend, length_mapped,
& status) | [ ms_$mapl ] |
| ms_mapl_stream | permanently map an object via its XOID
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$mapl_stream(
xoid_$t &xoid,
unsigned long int &start,
unsigned long int &desired_length,
ms_$conc_mode_t &concurrency,
ms_$acc_mode_t &access,
boolean &extend,
unsigned long int *length_mapped,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$mapl_stream(
in xoid: xoid_$t;
in start: linteger;
in desired_length: linteger;
in concurrency: ms_$conc_mode_t;
in access: ms_$acc_mode_t;
in extend: boolean;
out length_mapped: linteger;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 xoid(4), uid(2), start,
integer*4 desired_length, length_mapped, status
integer*2 concurrency, access
logical extend
equivalence (xoid(3), uid(1))
integer*4 address, dummy
pointer /address/ dummy
address = ms_$mapl_stream(xoid, start, desired_length,
& concurrency, access, extend,
& length_mapped, status) | [ ms_$mapl_stream ] |
| ms_mk_permanent | make a temporary object permanent
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$ms_permanent(
void *&address,
ms_$perm_opt_t &option,
char *name,
short int &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$mk_permanent(
in address: univ_ptr;
in option: ms_$perm_opt_t;
in name: univ name_$pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
integer*2 name_length, option
character name*1023
integer*4 address, dummy
pointer /address/ dummy
call ms_$mk_permanent(address, option, name, name_length, status) | [ ms_$mk_permanent ] |
| ms_mk_temporary | make a permanent object temporary
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$mk_temporary(
void *&address,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$mk_temporary(
in address: univ_ptr;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
integer*4 address, dummy
pointer /address/ dummy
call ms_$mk_temporary(address, status) | [ ms_$mk_temporary ] |
| ms_neighbors | find out if two mapped objects are on the same volume
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
boolean ms_$neighbors(
void *&address1,
void *&address2,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$neighbors(
in address1: univ_ptr;
in address2: univ_ptr;
out status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
logical same_volume
integer*4 address1, address2, dummy1, dummy2
pointer /address1/ dummy1
pointer /address2/ dummy2
same_volume = ms_$neighbors(address1, address2, status) | [ ms_$neighbors ] |
| ms_relock | change the lock on an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$relock(
void *&address,
ms_$acc_mode_t &access,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$relock(
in address: univ_ptr;
in access: ms_$acc_mode_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status
integer*2 access
integer*4 address, dummy
pointer /address/ dummy
call ms_$relock(address, access, status) | [ ms_$relock ] |
| ms_remap | map a different portion of a mapped object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void *ms_$remap(
void *&old_address,
unsigned long int &start,
unsigned long int &desired_length,
unsigned long int *remapped_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
function ms_$remap(
in old_address: univ_ptr;
in start: linteger;
in desired_length: linteger;
out remapped_length: linteger;
out status: status_$t): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 start, desired_length, remapped_length, status
integer*4 address, old_address, dummy, old_dummy
pointer /old_address/ old_dummy
pointer /address/ dummy
address = ms_$remap(old_address, start, desired_length,
& remapped_length, status) | [ ms_$remap ] |
| ms_truncate | truncate a mapped object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$truncate(
void *&address,
unsigned long int &length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$truncate(
in address: univ_ptr;
in length: linteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status, length
integer*4 address, dummy
pointer /address/ dummy
call ms_$truncate(address, length, status) | [ ms_$truncate ] |
| ms_unmap | unmap an object
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/ms.h>
void ms_$unmap(
void *&address,
unsigned long int &length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/ms.ins.pas';
procedure ms_$unmap(
in address: univ_ptr;
in length: linteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/ms.ins.ftn'
integer*4 status, length
integer*4 address, dummy
pointer /address/ dummy
call ms_$unmap(address, length, status) | [ ms_$unmap ] |
| mts_close_desc | close a magtape descriptor file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
void mts_$close_desc(
mts_$handle_t &mt_handle,
boolean &update,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
procedure mts_$close_desc(
in mt_handle: mts_$handle_t;
in update: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 mt_handle, status
logical update
call mts_$close_desc(mt_handle, update, status) | [ mts_$close_desc ] |
| mts_copy_desc | copy a magtape descriptor file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
mts_$handle_t mts_$copy_desc(
char *src_path,
unsigned short &src_length,
char *dst_path,
unsigned short &dst_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
function mts_$copy_desc (
in src_path: univ name_$long_pname_t;
in src_length: integer;
in dst_path: univ name_$long_pname_t;
in dst_length: integer;
out status: status_$t): mts_$handle_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 handle, status
integer*2 src_length, dst_length
character src_path*1023, dst_path*1023
handle = mts_$copy_desc(src_path, src_length,
& dst_path, dst_length, status) | [ mts_$copy_desc ] |
| mts_create_default_desc | create a default magtape descriptor file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
mts_$handle_t mts_$create_default_desc(
char *path_name,
unsigned short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
function mts_$create_default_desc(
in path_name: univ name_$long_pname_t;
in path_length: integer;
out status: status_$t): mts_$handle_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 handle, status
integer*2 path_length
character path_name*1023
handle = mts_$create_default_desc(path_name, path_length, status) | [ mts_$create_default_desc ] |
| mts_get_attr | get a magtape descriptor attribute
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
void mts_$get_attr(
mts_$handle_t &mt_handle,
mts_$attr_t &mt_attribute,
void *attribute_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
procedure mts_$get_attr(
in mt_handle: mts_$handle_t;
in mt_attribute: mts_$attr_t;
out attribute_value: univ mts_$attr_value_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*2 nchar
parameter (nchar = 32)
integer*4 mt_handle, status, attribute_value
integer*2 mt_attribute, i2_value
logical l_value
character c_value*(nchar)
equivalence (i2_value, attribute_value)
equivalence (l_value, attribute_value)
equivalence (c_value, attribute_value)
call mts_$get_attr(mt_handle, mt_attribute,
& attribute_value, status) | [ mts_$get_attr ] |
| mts_intro | using magtape descriptor files
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn' | [ intro ] |
| mts_label | label a magtape
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
void mts_$label(
char *path_name,
unsigned short &path_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
procedure mts_$label(
in path_name: univ name_$long_pname_t;
in path_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 status
integer*2 path_length
character path_name*1023
call mts_$label(path_name, path_length, status) | [ mts_$label ] |
| mts_open_desc | open a magtape descriptor file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
mts_$handle_t mts_$open_desc(
char *path_name,
unsigned short &path_length,
mts_$rw_t &read_write,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
function mts_$open_desc(
in path_name: univ name_$long_pname_t;
in path_length: integer;
in read_write: mts_$rw_t;
out status: status_$t): mts_$handle_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 handle, status
integer*2 path_length, read_write
character path_name*1023
handle = mts_$open_desc(path_name, path_length,
& read_write, status) | [ mts_$open_desc ] |
| mts_open_desc_uid | open a magtape descriptor file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
mts_$handle_t mts_$open_desc_uid(
uid_$t &desc_uid,
mts_$rw_t &read_write,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
function mts_$open_desc_uid(
in desc_uid: uid_$t;
in read_write: mts_$rw_t;
out status: status_$t): mts_$handle_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*4 handle, desc_uid(2), status
integer*2 read_write
handle = mts_$open_desc(desc_uid, read_write, status) | [ mts_$open_desc_uid ] |
| mts_set_attr | set a magtape descriptor attribute
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mts.h>
void mts_$set_attr(
mts_$handle_t &mt_handle,
mts_$attr_t &mt_attribute,
void &attribute_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mts.ins.pas';
procedure mts_$set_attr(
in mt_handle: mts_$handle_t;
in mt_attribute: mts_$attr_t;
in attribute_value: univ mts_$attr_value_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mts.ins.ftn'
integer*2 nchar
parameter (nchar = 32)
integer*4 mt_handle, status, attribute_value
integer*2 mt_attribute, i2_value
logical l_value
character c_value*(nchar)
equivalence (i2_value, attribute_value)
equivalence (l_value, attribute_value)
equivalence (c_value, attribute_value)
call mts_$set_attr(mt_handle, mt_attribute,
& attribute_value, status) | [ mts_$set_attr ] |
| mutex_init | initialize a mutual exclusion lock record
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mutex.h>
extern void mutex_$init(mutex_$lock_rec_t *lock_record)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mutex.ins.pas';
procedure mutex_$init(out lock_record: mutex_$lock_rec_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mutex.ins.ftn'
integer*2 lock_record(4), lock_ec_awaiters
integer*4 lock_ec_value
character*1 lock_byte
equivalence (lock_byte, lock_record(1))
equivalence (lock_ec_value, lock_record(2))
equivalence (lock_ec_awaiters, lock_record(4))
call mutex_$init(lock_record) | [ mutex_$init ] |
| mutex_intro | mutually exclusive resource locking
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mutex.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mutex.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mutex.ins.ftn' | [ intro ] |
| mutex_lock | obtain a mutual exclusion lock
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mutex.h>
boolean mutex_$lock(
mutex_$lock_rec_t *lock_record,
time_$clock_t &wait_time)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mutex.ins.pas';
function mutex_$lock(
var lock_record: mutex_$lock_rec_t;
in wait_time: univ time_$clock_t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mutex.ins.ftn'
integer*2 wait_time(3), lock_record(4)
integer*2 lock_ec_awaiters, clockh
integer*4 lock_ec_value, clockl
character*1 lock_byte
logical lock_status
equivalence (lock_byte, lock_record(1))
equivalence (lock_ec_value, lock_record(2))
equivalence (lock_ec_awaiters, lock_record(4))
equivalence (clockh, wait_time(1))
equivalence (clockl, wait_time(2))
lock_status = mutex_$lock(lock_record, wait_time) | [ mutex_$lock ] |
| mutex_unlock | release a mutual exclusion lock
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/mutex.h>
void mutex_$unlock(mutex_$lock_rec_t *lock_record)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/mutex.ins.pas';
procedure mutex_$unlock(var lock_record: mutex_$lock_rec_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/mutex.ins.ftn'
integer*2 lock_record(4), lock_ec_awaiters
integer*4 lock_ec_value
character*1 lock_byte
equivalence (lock_byte, lock_record(1))
equivalence (lock_ec_value, lock_record(2))
equivalence (lock_ec_awaiters, lock_record(4))
call mutex_$unlock(lock_record) | [ mutex_$unlock ] |
| name_add_link | create a link
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$add_link(
char *link_name,
unsigned short &name_length,
char *link_text,
unsigned short &text_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$add_link(
in link_name: univ name_$long_pname_t;
in name_length: integer;
in link_text: univ name_$long_pname_t;
in text_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length, text_length
character link_name*1023, link_text*1023
call name_$add_link(link_name, name_length, link_text,
& text_length, status) | [ name_$add_link ] |
| name_cname | change a leaf name
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$cname(
char *old_pathname,
unsigned short &old_length,
char *new_leaf,
unsigned short &leaf_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$cname(
in old_pathname: univ name_$long_pname_t;
in old_length: integer;
in new_leaf: univ name_$long_name_t;
in leaf_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 old_length, leaf_length
character old_pathname*1023, new_leaf*255
call name_$cname(old_pathname, old_length, new_leaf,
& leaf_length, status) | [ name_$cname ] |
| name_create_directory | create a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$create_directory(
char *directory_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$create_directory(
in directory_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character directory_name*1023
call name_$create_directory(directory_name, name_length, status) | [ name_$create_directory ] |
| name_create_file | create a permanent file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$create_file(
char *file_name,
unsigned short &name_length,
status_$t *status);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$create_file(
in file_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character file_name*1023
call name_$create_file(file_name, name_length, status) | [ name_$create_file ] |
| name_delete_directory | delete a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$delete_directory(
char *directory_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$delete_directory(
in directory_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character directory_name*1023
call name_$delete_directory(directory_name, name_length, status) | [ name_$delete_directory ] |
| name_delete_file | delete a file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$delete_file(
char *file_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$delete_file(
in file_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character file_name*1023
call name_$delete_file(file_name, name_length, status) | [ name_$delete_file ] |
| name_drop_link | delete a link
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$drop_link(
char *link_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$drop_link(
in link_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character link_name*1023
call name_$drop_link(link_name, name_length, status) | [ name_$drop_link ] |
| name_extract_data_lc | extract a directory entry
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$extract_data_lc(
name_$canonical_dir_entry_t &canonical_entry,
short *enttype,
unsigned short *entlen,
unsigned short &maxentlen,
name_$long_name_t *entname,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$extract_data_lc(
in canonical_entry: univ name_$canonical_dir_entry_t;
out enttype: integer;
out entlen: integer;
in maxentlen: pinteger;
out entname: univ name_$long_name_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
character canonical_entry*278, entname*255
integer*2 enttype, entlen, maxentlen
integer*4 status
equivalence (enttype, canonical_entry(3, 4))
equivalence (entlen, canonical_entry(21, 22))
equivalence (entname, canonical_entry(23, 278))
call name_$extract_data(canonical_entry, enttype, entlen,
& maxentlen, entname, status) | [ name_$extract_data_lc ] |
| name_get_ndir_lc | get the naming directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$get_ndir_lc(
unsigned short &max_len,
char *naming_directory,
unsigned short *name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$get_ndir_lc(
in max_len: integer;
out naming_directory: univ name_$long_pname_t;
out name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 max_len, name_length
character naming_directory*1023
call name_$get_ndir_lc(max_len, naming_directory,
& name_length, status) | [ name_$get_ndir_lc ] |
| name_get_path_lc | get a full pathname
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$get_path_lc(
char *partial_path,
unsigned short &partial_len,
unsigned short &max_len,
char *full_name,
unsigned short *full_len,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$get_path_lc(
in partial_path: univ name_$long_pname_t;
in partial_len: integer;
in maxpnamlen: pinteger;
out full_name: univ name_$long_pname_t;
out full_len: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 partial_len, max_len, full_len
character partial_path*1023, full_name*1023
call name_$get_path_lc(partial_path, partial_len, max_len,
& full_name, full_len, status) | [ name_$get_path_lc ] |
| name_get_wdir_lc | get the working directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$get_wdir_lc(
unsigned short &max_len,
char *working_directory,
unsigned short *name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$get_wdir_lc(
in max_len: integer;
out working_directory: univ name_$long_pname_t;
out name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 max_len, working_directory
character name*1023
call name_$get_wdir_lc(max_len, working_directory,
& name_length, status) | [ name_$get_wdir_lc ] |
| name_intro | the Naming Server
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn' | [ intro ] |
| name_read_dir_lc | read a directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$read_dir_lc(
char *dir_name,
unsigned short &name_length,
boolean *seek_to_bof,
name_$cursor_t *index,
unsigned short &max_count,
unsigned long &dir_list_size,
char *dir_list,
unsigned short *read_count,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$read_dir_lc(
in dir_name: univ name_$long_pname_t;
in name_length: integer;
var seek_to_bof: boolean;
var index: name_$cursor_t;
in max_count: pinteger;
in dir_list_size: linteger;
out dir_list: univ name_$buf_t;
out read_count: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 name_buf_size
parameter name_buf_size = 100000
character dir_name*1023, index*300, dir_list*(name_buf_size)
integer*2 name_length, max_count, read_count
logical seek_to_bof
integer*4 dir_list_size, status
character canonical_entry*278, entname*255
integer*2 entnxt, enttype, entlen
equivalence (entnxt, canonical_entry(1, 2))
equivalence (enttype, canonical_entry(3, 4))
equivalence (entlen, canonical_entry(21, 22))
equivalence (entname, canonical_entry(23, 278))
call name_$read_dir(dir_name, name_length, seek_to_bof,
& index, max_count, dir_list_size,
& dir_list, read_count, status) | [ name_$read_dir_lc ] |
| name_read_link_lc | return the pathname associated with a link
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$read_link_lc(
char *link_name,
unsigned short &name_length,
unsigned short &maxlinklen,
char *link_text,
unsigned short *text_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$read_link_lc(
in link_name: univ name_$long_pname_t;
in name_length: integer;
in maxlinklen: integer;
out link_text: univ name_$long_pname_t;
out text_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length, maxlinklen, text_length
character link_name*1023, link_text*1023
call name_$read_link_lc(link_name, name_length, maxlinklen,
& link_text, text_length, status) | [ name_$read_link_lc ] |
| name_set_ndir | set the naming directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$set_ndir(
char *directory_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$set_ndir(
in directory_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character directory_name*1023
call name_$set_ndir(directory_name, name_length, status) | [ name_$set_ndir ] |
| name_set_wdir | sets the working directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/name.h>
void name_$set_wdir(
char *directory_name,
unsigned short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/name.ins.pas';
procedure name_$set_wdir(
in directory_name: univ name_$long_pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/name.ins.ftn'
integer*4 status
integer*2 name_length
character directory_name*1023
call name_$set_wdir(directory_name, name_length, status) | [ name_$set_wdir ] |
| osinfo_get_rev | get Domain/OS revision information
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/osinfo.h>
void osinfo_$get_rev(
char *node_spec,
short &spec_length,
short &version_number,
int &revision_size,
os_rev_$t *revision_info,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/osinfo.ins.pas';
procedure osinfo_$get_rev(
in node_spec: univ os_rev_str_$t;
in spec_length: pinteger;
in version_number: pinteger;
in revision_size: linteger;
out revision_info: os_rev_$t;
out status: status_$t); | [ osinfo_$get_rev ] |
| osinfo_intro | Domain/OS information
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/osinfo.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/osinfo.ins.pas'; | [ intro ] |
| pad_clear_frame | clear a frame
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$clear_frame(
ios_$id_t &stream_id,
stream_$sk_t &seek_key,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$clear_frame(
in stream_id: ios_$id_t;
in seek_key: univ stream_$sk_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 seek_key(3), rec_adr, byte_adr, flags, status
integer*2 stream_id
equivalence (rec_adr, seek_key(1))
equivalence (byte_adr, seek_key(2))
equivalence (flags, seek_key(3))
call pad_$clear_frame(stream_id, seek_key, status) | [ pad_$clear_frame ] |
| pad_close_frame | close a frame
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$close_frame(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$close_frame(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$close_frame(stream_id, status) | [ pad_$close_frame ] |
| pad_cooked | put a transcript pad in cooked mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$cooked(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$cooked(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$cooked(stream_id, status) | [ pad_$cooked ] |
| pad_cpr_enable | enable cursor position reports
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$cpr_enable(
ios_$id_t &stream_id,
short &report_cpr_type,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$cpr_enable(
in stream_id: ios_$id_t;
in report_cpr_type: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 report_cpr_type, stream_id
call pad_$cpr_enable(stream_id, report_cpr_type, status) | [ pad_$cpr_enable ] |
| pad_create | create a new pad and window pane
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$create(
char *pathname,
pinteger name_length,
pad_$type_t pad_type,
ios_$id_t stream_id,
pad_$side_t side,
pad_$cre_opt_t pane_options,
short pane_size,
ios_$id_t *pane_stream_id,
status_$t status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$create(
in pathname: univ name_$long_pname_t;
in name_length: pinteger;
in pad_type: pad_$type_t;
in related_stream_id: ios_$id_t;
in side: pad_$side_t;
in pane_options: pad_$cre_opt_t;
in pane_size: integer;
out pane_stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
character pathname*1023
integer*4 status
integer*2 name_length, pad_type, related_stream_id
integer*2 side, pane_options, pane_size, pane_stream_id
call pad_$create(pathname, name_length, pad_type,
& related_stream_id, side, pane_options,
& pane_size, pane_stream_id, status) | [ pad_$create ] |
| pad_create_frame | create a frame
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$create_frame(
ios_$id_t &stream_id,
short &width,
short &height,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$create_frame(
in stream_id: ios_$id_t;
in width: integer;
in height: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, width, height
call pad_$create_frame(stream_id, width, height, status) | [ pad_$create_frame ] |
| pad_create_icon | create a new pad and associated window icon
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$create_icon(
char *pathname,
unsigned short &name_length,
pad_$type_t &type,
short &unit,
pad_$position_t &icon_pos,
char &icon_char,
pad_$window_desc_t *window,
ios_$id_t *stream_id,
status_$t *status);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$create_icon(
in pathname: univ name_$long_pname_t;
in name_length: pinteger;
in type: pad_$type_t;
in unit: integer;
in icon_pos: pad_$position_t;
in icon_char: char;
in window: pad_$window_desc_t;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 name_length, type, unit, icon_pos(2)
integer*2 x_icon, y_icon, window(4), top, left
integer*2 width, height, stream_id
character pathname*1023, icon_char*1
equivalence (top, window(1)), (left, window(2))
equivalence (width, window(3)), (height, window(4))
equivalence (x_icon, icon_pos(1)), (y_icon, icon_pos(2))
call pad_$create_icon(pathname, name_length, type,
& unit, icon_pos, icon_char,
& window, stream_id, status) | [ pad_$create_icon ] |
| pad_create_window | create a new pad and a window to view it
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$create_window(
char *pathname,
unsigned short &name_length,
pad_$type_t &pad_type,
short &unit,
pad_$window_desc_t &window,
ios_$id_t *stream_id,
status_$t *status);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$create_window(
in pathname: univ name_$long_pname_t;
in name_length: pinteger;
in pad_type: pad_$type_t;
in unit: integer;
in window: pad_$window_desc_t;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 name_length, pad_type, unit, window(4)
integer*2 top, left, width, height, stream_id
character pathname*1023
equivalence (top, window(1)), (left, window(2))
equivalence (width, window(3)), (height, window(4))
call pad_$create_window(pathname, name_length, pad_type,
& unit, window, stream_id, status) | [ pad_$create_window ] |
| pad_def_pfk | define a program function key
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$def_pfk(
ios_$id_t &stream_id,
char *key_name,
char *definition,
short &def_len,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$def_pfk(
in stream_id: ios_$id_t;
in key_name: pad_$key_name_t;
in definition: univ pad_$key_def_t;
in def_len: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, def_len
character key_name*4, definition*128
call pad_$def_pfk(stream_id, key_name, definition,
& def_len, status) | [ pad_$def_pfk ] |
| pad_delete_frame | clear and delete a frame
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$delete_frame(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$delete_frame(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$delete_frame(stream_id, status) | [ pad_$delete_frame ] |
| pad_dm_cmd | execute a Display Manager command
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$dm_cmd(
ios_$id_t &stream_id,
char *command,
short &command_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$dm_cmd(
in stream_id: ios_$id_t;
in command: univ pad_$string_t;
in command_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, command_length
character command*256
call pad_$dm_cmd(stream_id, command, command_length, status) | [ pad_$dm_cmd ] |
| pad_edit_wait | wait until an edit window closes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$edit_wait(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$edit_wait(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$edit_wait(stream_id, status) | [ pad_$edit_wait ] |
| pad_force_prompt | force an incomplete record to an input pad
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$force_prompt(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$force_prompt(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$force_prompt(stream_id, status) | [ pad_$force_prompt ] |
| pad_icon_wait | wait until an icon expands or moves
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$icon_wait(
ios_$id_t &stream_id,
short &window_no,
boolean *icon_moved,
pad_$position_t *icon_pos,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$icon_wait(
in stream_id: ios_$id_t;
in window_no: integer;
out icon_moved: boolean;
out icon_pos: pad_$position_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
integer*2 icon_pos(2), x_coord, y_coord
logical icon_moved
equivalence (x_coord, icon_pos(1)), (y_coord, icon_pos(2))
call pad_$icon_wait(stream_id, window_no, icon_moved,
& icon_pos, status) | [ pad_$icon_wait ] |
| pad_inq_disp_type | find out the display type
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_disp_type(
ios_$id_t &stream_id,
pad_$display_type_t *display_type,
short *unit,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_disp_type(
in stream_id: ios_$id_t;
out display_type: pad_$display_type_t;
out unit: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, display_type, unit
call pad_$inq_disp_type(stream_id, display_type, unit, status) | [ pad_$inq_disp_type ] |
| pad_inq_font | find out about the current font
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_font(
ios_$id_t &stream_id,
short *font_width,
short *font_height,
char *font_name,
short &font_buf_len,
short *font_len,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_font(
in stream_id: ios_$id_t;
out font_width: integer;
out font_height: integer;
out font_name: univ name_$long_pname_t;
in font_buf_len: integer;
out font_len: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, font_width, font_height
integer*2 font_len, font_buf_len
character font_name*1023
call pad_$inq_font(stream_id, font_width, font_height,
& font_name, font_buf_len, font_len, status) | [ pad_$inq_font ] |
| pad_inq_full_window | get the total display region occupied by a window
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_full_window(
ios_$id_t &stream_id,
short &window_no,
pad_$window_desc_t *window,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_full_window(
in stream_id: ios_$id_t;
in window_no: integer;
out window: pad_$window_desc_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, window(4)
integer*2 top, left, width, height
equivalence (top, window(1)), (left, window(2))
equivalence (width, window(3)), (height, window(4))
call pad_$inq_full_window(stream_id, window_no, window, status) | [ pad_$inq_full_window ] |
| pad_inq_icon | get icon information
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_icon(
ios_$id_t &stream_id,
short &window_no,
pad_$position_t *icon_pos,
char *icon_char,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_icon(
in stream_id: ios_$id_t;
in window_no: integer;
out icon_pos: pad_$position_t;
out icon_char: char;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, icon_pos(2), x_coord, y_coord
character icon_char*1
equivalence (icon_pos(1), x_coord), (icon_pos(2), y_coord)
call pad_$inq_icon(stream_id, window_no, icon_pos,
& icon_char, status) | [ pad_$inq_icon ] |
| pad_inq_icon_font | get the current icon font
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_icon_font(
ios_$id_t &stream_id,
short &window_no,
char *font_name,
short &font_buf_len,
short *font_len,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_icon_font(
in stream_id: ios_$id_t;
in window_no: integer;
out font_name: univ name_$long_pname_t;
in font_buf_len: integer;
out font_len: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, font_width
integer*2 font_buf_len, font_len
character font_name*1023
call pad_$inq_icon_font(stream_id, window_no, font_name,
& font_buf_len, font_len, status) | [ pad_$inq_icon_font ] |
| pad_inq_kbd | find out about the keyboard
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_kbd(
ios_$id_t &stream_id,
short &buffer_size,
char *kbd_suffix,
short *length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_kbd(
in stream_id: ios_$id_t;
in buffer_size: integer;
out kbd_suffix: univ pad_$string_t;
out length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, buffer_size, length
character kbd_suffix*256
call pad_$inq_kbd(stream_id, buffer_size, kbd_suffix,
& length, status) | [ pad_$inq_kbd ] |
| pad_inq_position | find the output cursor
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_position(
ios_$id_t &stream_id,
short *y,
short *x,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_position(
in stream_id: ios_$id_t;
out x: integer;
out y: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, x, y
call pad_$inq_position(stream_id, x, y, status) | [ pad_$inq_position ] |
| pad_inq_view | find out the pad region under the window
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_view(
ios_$id_t &stream_id,
short &window_no,
long *line,
long *eof_linenum,
short *x_offset,
short *y_offset,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_view(
in stream_id: ios_$id_t;
in window_no: integer;
out line: integer32;
out eof_linenum: integer32;
out x_offset: integer;
out y_offset: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status, length, line, eof_linenum
integer*2 stream_id, window_no, x_offset, y_offset
call pad_$inq_view(stream_id, window_no, line, eof_linenum,
& x_offset, y_offset, status) | [ pad_$inq_view ] |
| pad_inq_windows | list the windows on a pad
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$inq_windows(
ios_$id_t &stream_id,
pad_$window_desc_t *windowlist,
short &window_list_size,
short *window_no,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$inq_windows(
in stream_id: ios_$id_t;
out windowlist: univ pad_$window_list_t;
in window_list_size: integer;
out window_no: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*2 max_window_list, desired_window
parameter (max_window_list = 10, desired_window = 3)
integer*4 status, window_list(2 * max_window_list)
integer*2 stream_id, window_list_size, window_no
integer*2 window_desc(4), top, left, width, height
equivalence (top, window_desc(1)), (left, window_desc(2))
equivalence (width, window_desc(3)), (height, window_desc(4))
equivalence (window_desc(1),
& window_list(1 + (2 * (desired_window - 1))))
call pad_$inq_windows(stream_id, window_list, window_list_size,
& window_no, status) | [ pad_$inq_windows ] |
| pad_intro | the Display Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn' | [ intro ] |
| pad_is_icon | find out whether a window is an icon
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
boolean pad_$is_icon(
ios_$id_t &stream_id,
short &window_no,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
function pad_$is_icon(
in stream_id: ios_$id_t;
in window_no: integer;
out status: status_$t): boolean;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
logical is_icon
is_icon = pad_$is_icon(stream_id, window_no, status) | [ pad_$is_icon ] |
| pad_isa | test a stream for the pad trait
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$force_prompt(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$isa(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$isa(stream_id, status) | [ pad_$isa ] |
| pad_isa_dm_pad | test whether a stream is open on a local DM pad
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$force_prompt(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$isa_dm_pad(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$isa_dm_pad(stream_id, status) | [ pad_$isa_dm_pad ] |
| pad_load_font | load a character font
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$load_font(
ios_$id_t &stream_id,
char *font_name,
short &name_length,
short *font_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$load_font(
in stream_id: ios_$id_t;
in font_name: univ pad_$string_t;
in name_length: integer;
out font_id: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, name_length, font_id
character font_name*256
call pad_$load_font(stream_id, font_name, name_length,
& font_id, status) | [ pad_$load_font ] |
| pad_locate | locate the keyboard cursor
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$locate(
ios_$id_t &stream_id,
short *x, *y,
char *byte,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$locate(
in stream_id: ios_$id_t;
out x, y: integer;
out byte: char;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, x, y
character byte*1
call pad_$locate(stream_id, x, y, byte, status) | [ pad_$locate ] |
| pad_make_icon | change a window into an icon
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$make_icon(
ios_$id_t &stream_id,
short &window_no,
char &icon_char,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$make_icon(
in stream_id: ios_$id_t;
in window_no: integer;
in icon_char: char;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
character icon_char*1
call pad_$make_icon(stream_id, window_no, icon_char, status) | [ pad_$make_icon ] |
| pad_make_invisible | make a window invisible
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$make_invisible(
ios_$id_t &stream_id,
short &window_no,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$make_invisible(
in stream_id: ios_$id_t;
in window_no: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
call pad_$make_invisible(stream_id, window_no, status) | [ pad_$make_invisible ] |
| pad_move | move the output cursor
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$move(
ios_$id_t &stream_id,
pad_$rel_abs_t &rel_abs,
short &x, &y,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$move(
in stream_id: ios_$id_t;
in rel_abs: pad_$rel_abs_t;
in x, y: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, rel_abs, x, y
call pad_$move(stream_id, rel_abs, x, y, status) | [ pad_$move ] |
| pad_pop_push_window | pop or push a window
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$pop_push_window(
ios_$id_t &stream_id,
short &window_no,
boolean &pop_push,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$pop_push_window(
in stream_id: ios_$id_t;
in window_no: integer;
in pop_push: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
logical pop_push
call pad_$pop_push_window(stream_id, window_no, pop_push, status) | [ pad_$pop_push_window ] |
| pad_raw | place a pad in raw mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$raw(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$raw(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id
call pad_$raw(stream_id, status) | [ pad_$raw ] |
| pad_select_window | make a window visible and full-size
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$select_window(
ios_$id_t &stream_id,
short &window_no,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$select_window(
in stream_id: ios_$id_t;
in window_no: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
call pad_$select_window(stream_id, window_no, status) | [ pad_$select_window ] |
| pad_set_auto_close | close a window when its pad closes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_auto_close(
ios_$id_t &stream_id,
short &window_no,
boolean &auto_close,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_auto_close(
in stream_id: ios_$id_t;
in window_no: integer;
in auto_close: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
logical auto_close
call pad_$set_auto_close(stream_id, window_no, auto_close, status) | [ pad_$set_auto_close ] |
| pad_set_border | add or remove a window border
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_border(
ios_$id_t &stream_id,
short &window_no,
boolean &border,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_border(
in stream_id: ios_$id_t;
in window_no: integer;
in border: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no
logical border
call pad_$set_border(stream_id, window_no, border, status) | [ pad_$set_border ] |
| pad_set_full_window | establish a window region
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_full_window(
ios_$id_t &stream_id,
short &window_no,
pad_$window_desc_t *window,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_full_window(
in stream_id: ios_$id_t;
in window_no: integer;
in window: pad_$window_desc_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, window(4)
integer*2 top, left, width, height
equivalence (top, window(1)), (left, window(2)),
equivalence (width, window(3)), (height, window(4))
call pad_$set_full_window(stream_id, window_no, window, status) | [ pad_$set_full_window ] |
| pad_set_icon_font | choose a new icon font
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_icon_font(
ios_$id_t &stream_id,
short &window_no,
char *font_name,
short &font_len,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_icon_font(
in stream_id: ios_$id_t;
in window_no: integer;
in font_name: univ name_$long_pname_t;
in font_len: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, font_len
character font_name*1023
call pad_$set_icon_font(stream_id, window_no, font_name,
& font_len, status) | [ pad_$set_icon_font ] |
| pad_set_icon_pos | establish an icon position and icon character
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_icon_pos(
ios_$id_t &stream_id,
short &window_no,
pad_$position_t &icon_pos,
char &icon_char,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_icon_pos(
in stream_id: ios_$id_t;
in window_no: integer;
in icon_pos: pad_$position_t;
in icon_char: char;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, window_no, icon_pos(2), x_coord, y_coord
character icon_char*1
equivalence (x_coord, icon_pos(1)), (y_coord, icon_pos(2))
call pad_$set_icon_pos(stream_id, window_no, icon_pos,
& icon_char, status) | [ pad_$set_icon_pos ] |
| pad_set_scale | set a scale factor for cursor operations
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_scale(
ios_$id_t &stream_id,
short &x_factor,
short &y_factor,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_scale(
in stream_id: ios_$id_t;
in x_factor: integer;
in y_factor: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, x_factor, y_factor
call pad_$set_scale(stream_id, x_factor, y_factor, status) | [ pad_$set_scale ] |
| pad_set_tabs | set tab stops within a pad
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_tabs(
ios_$id_t &stream_id,
short *tab_stop_array,
short &no_of_tabs,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_tabs(
in stream_id: ios_$id_t;
in tab_stop_array: pad_$tabstop_buf_t;
in no_of_tabs: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, tab_stop_array(100), no_of_tabs
call pad_$set_tabs(stream_id, tab_stop_array, no_of_tabs, status) | [ pad_$set_tabs ] |
| pad_set_view | define the pad region under a window
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$set_view(
ios_$id_t &stream_id,
short &window_no,
long &line,
short &x_offset,
short &y_offset,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$set_view(
in stream_id: ios_$id_t;
in window_no: integer;
in line: integer32;
in x_offset: integer;
in y_offset: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status, line
integer*2 stream_id, window_no, x_offset, y_offset
call pad_$set_view(stream_id, window_no, line,
& x_offset, y_offset, status) | [ pad_$set_view ] |
| pad_use_font | use a new loaded font
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pad.h>
void pad_$use_font(
ios_$id_t &stream_id,
short &font_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pad.ins.pas';
procedure pad_$use_font(
in stream_id: ios_$id_t;
in font_id: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pad.ins.ftn'
integer*4 status
integer*2 stream_id, font_id
call pad_$use_font(stream_id, font_id, status) | [ pad_$use_font ] |
| pbufs_create | create a paste buffer
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pbufs.h>
void pbufs_$create(
char *buffer_name,
boolean &buffer_type,
ios_$id_t *stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pbufs.ins.pas';
procedure pbufs_$create(
in buffer_name: univ name_$long_name_t;
in buffer_type: boolean;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pbufs.ins.ftn'
integer*2 stream_id
integer*4 status
logical buffer_type
character buffer_name*255
call pbufs_$create(buffer_name, buffer_type, stream_id, status) | [ pbufs_$create ] |
| pbufs_intro | using paste buffers
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pbufs.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pbufs.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pbufs.ins.ftn' | [ intro ] |
| pbufs_open | open an existing paste buffer
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pbufs.h>
void pbufs_$open(
char *buffer_name,
boolean &buffer_type,
ios_$id_t *stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pbufs.ins.pas';
procedure pbufs_$open(
in buffer_name: univ name_$long_name_t;
in buffer_type: boolean;
out stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pbufs.ins.ftn'
integer*2 stream_id
integer*4 status
logical buffer_type
character buffer_name*255
call pbufs_$open(buffer_name, buffer_type, stream_id, status) | [ pbufs_$open ] |
| pfm_cleanup | establish a clean-up handler
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
status_$t pfm_$cleanup(pfm_$cleanup_rec *cleanup_record)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
function pfm_$cleanup(
out cleanup_record: pfm_$cleanup_rec): status_$t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 status, cleanup_record(16)
status = pfm_$cleanup(cleanup_record) | [ pfm_$cleanup ] |
| pfm_enable | enable asynchronous faults
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$enable(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$enable;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
call pfm_$enable | [ pfm_$enable ] |
| pfm_error_trap | simulate a fault and save a traceback
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$error_trap(status_$t &fault_signal)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$error_trap(in fault_signal: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 fault_signal
call pfm_$error_trap(fault_signal) | [ pfm_$error_trap ] |
| pfm_establish_fault_handler | establish a fault handler
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
pfm_$fh_handle_t pfm_$establish_fault_handler(
int &target_status,
pfm_$fh_opt_set_t &fh_options,
pfm_$fault_func_p_t &function_ptr,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
function pfm_$establish_fault_handler(
in target_status: integer32;
in fh_options: pfm_$fh_opt_set_t;
in function_ptr: pfm_$fault_func_p_t;
out status: status_$t): pfm_$fh_handle_t; | [ pfm_$establish_fault_handler ] |
| pfm_inhibit | inhibit asynchronous faults
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$inhibit(void);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$inhibit;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
call pfm_$inhibit | [ pfm_$inhibit ] |
| pfm_intro | managing faults
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn' | [ intro ] |
| pfm_release_fault_handler | release a fault handler
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$release_fault_handler(
pfm_$fh_handle_t &fh_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$release_fault_handler(
in fh_handle: pfm_$fh_handle_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 fh_handle, status
call pfm_$release_fault_handler(fh_handle, status) | [ pfm_$release_fault_handler ] |
| pfm_reset_cleanup | reset a clean-up handler
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$reset_cleanup(
pfm_$cleanup_rec &cleanup_record,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$reset_cleanup(
in cleanup_record: pfm_$cleanup_rec;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 cleanup_record(16), status
call pfm_$reset_cleanup(cleanup_record, status) | [ pfm_$reset_cleanup ] |
| pfm_rls_cleanup | release clean-up handlers stack.
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$rls_cleanup(
pfm_$cleanup_rec &cleanup_record,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$rls_cleanup(
in cleanup_record: pfm_$cleanup_rec;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 cleanup_record(16), status
call pfm_$rls_cleanup(cleanup_record, status) | [ pfm_$rls_cleanup ] |
| pfm_signal | signal the calling process
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pfm.h>
void pfm_$signal(status_$t &fault_signal)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pfm.ins.pas';
procedure pfm_$signal(in fault_signal: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pfm.ins.ftn'
integer*4 fault_signal
call pfm_$signal(fault_signal) | [ pfm_$signal ] |
| pgm_del_arg | delete a program argument
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$del_arg(short &arg_number)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$del_arg(in arg_number: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*2 arg_number
call pgm_$del_arg(arg_number) | [ pgm_$del_arg ] |
| pgm_exit | exit a program
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$exit(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$exit;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
call pgm_$exit | [ pgm_$exit ] |
| pgm_get_arg | get a program argument
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
short pgm_$get_arg(
short &arg_number,
char *arg_buffer,
status_$t *status,
short &buffer_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
function pgm_$get_arg(
in arg_number: integer;
out arg_buffer: univ pgm_$name;
out status: status_$t;
in buffer_length: integer): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 status
integer*2 arg_length, arg_number, buffer_length
character arg_buffer*128
arg_length = pgm_$get_arg(arg_number, arg_buffer, status, buffer_length) | [ pgm_$get_arg ] |
| pgm_get_args | get the program argument vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$get_args(
short *argument_count,
pgm_$argv_ptr *arg_vector_ptr)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$get_args(
out argument_count: integer;
out arg_vector_ptr: pgm_$argv_ptr);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*2 argument_count, arg_len
integer*4 arg_ptr_vector(128)
character arg_chars*128
integer*4 arg_ptr, arg_vector_ptr
pointer /arg_ptr/ arg_len, arg_chars
pointer /arg_vector_ptr/ arg_ptr_vector
call pgm_$get_args(argument_count, arg_vector_ptr) | [ pgm_$get_args ] |
| pgm_get_ec | get a process eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$get_ec(
pgm_$proc &process_handle,
pgm_$ec_key &ec_key,
ec2_$ptr_t *ec_pointer,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$get_ec(
in process_handle: pgm_$proc;
in ec_key: pgm_$ec_key;
out ec_pointer: ec2_$ptr_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 status, process_handle, ec_value
integer*2 ec_key, event(3)
equivalence (ec_value, event(1))
integer*4 ec_pointer
pointer /ec_pointer/ event
call pgm_$get_ec(process_handle, ec_key, ec_pointer, status) | [ pgm_$get_ec ] |
| pgm_get_puid | get a process UID
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$get_puid(
pgm_$proc &process_handle,
uid_$t *process_uid,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$get_puid(
in process_handle: pgm_$proc;
out process_uid: uid_$t;
out status: status_$t)
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 process_handle, process_uid(2), status
call pgm_$get_puid(process_handle, process_uid, status) | [ pgm_$get_puid ] |
| pgm_intro | the program manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn' | [ intro ] |
| pgm_invoke | invoke a program
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$invoke(
char *path_name,
short &path_length,
short &argument_count,
pgm_$arg_ptr *argument_vector,
short &stream_count,
ios_$id_t *stream_vector,
pgm_$mode &invoke_mode,
pgm_$proc *process_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$invoke(
in path_name: univ name_$pname_t;
in path_length: integer;
in argument_count: integer;
in argument_vector: univ pgm_$argv;
in stream_count: integer;
in stream_vector: univ pgm_$connv;
in invoke_mode: pgm_$mode;
out process_handle: univ pgm_$proc;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 process_handle, status
integer*2 path_length, argument_count, arg_len, stream_count
integer*2 stream_vector(128), invoke_mode
character path_name*1023, arg_chars*128
integer*4 arg_ptr, argument_vector(128)
pointer /arg_ptr/ arg_len, arg_chars
call pgm_$invoke(path_name, path_length, argument_count,
& argument_vector, stream_count,
& stream_vector, invoke_mode,
& process_handle, status) | [ pgm_$invoke ] |
| pgm_make_orphan | orphan a process
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$make_orphan(
pgm_$proc &process_handle,
uid_$t *process_uid,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$make_orphan(
in process_handle: pgm_$proc;
out process_uid: uid_$t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 process_handle, process_uid(2), status
call pgm_$make_orphan(process_handle, process_uid, status) | [ pgm_$make_orphan ] |
| pgm_proc_wait | wait on a process
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$proc_wait(
pgm_$proc &process_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$proc_wait(
in process_handle: pgm_$proc;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*4 process_handle, status
call pgm_$proc_wait(process_handle, status) | [ pgm_$proc_wait ] |
| pgm_set_severity | set the exit severity level
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pgm.h>
void pgm_$set_severity(pgm_$mode &severity_level)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pgm.ins.pas';
procedure pgm_$set_severity(in severity_level: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pgm.ins.ftn'
integer*2 severity_level
call pgm_$set_severity(severity_level) | [ pgm_$set_severity ] |
| pm_get_home_txt | get the home directory
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pm.h>
void pm_$get_home_txt(
short &buffer_length,
char *path_name,
short *path_length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pm.ins.pas';
procedure pm_$get_home_txt(
in buffer_length: integer;
out path_name: univ name_$long_pname_t;
out path_length: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pm.ins.ftn'
integer*2 buffer_length, path_length
character path_name*1023
call pm_$get_home_txt(buffer_length, path_name, path_length) | [ pm_$get_home_txt ] |
| pm_get_sid_txt | get the SID
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pm.h>
void pm_$get_sid_txt(
short &buffer_length,
char *sid,
short *sid_length);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pm.ins.pas';
procedure pm_$get_sid_txt(
in buffer_length: integer;
out sid: univ pm_$sidtext_t;
out sid_length: integer);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pm.ins.ftn'
integer*2 buffer_length, sid_length
character sid*140
call pm_$get_sid_txt(buffer_length, sid, sid_length) | [ pm_$get_sid_txt ] |
| pm_intro | the Domain/OS Process Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/pm.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/pm.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/pm.ins.ftn' | [ intro ] |
| prf_config_file | set print options from a file
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$config_file(
char *name,
short &name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$config_file(
in name: name_$pname_t;
in name_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 name_length
integer*4 status
character name*1024
call prf_$config_file(name, name_length, status) | [ prf_$config_file ] |
| prf_edit_job | edit a print job at the current site
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$edit_job(
long &job_id,
prf_$edit_job_t &edit_op,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$edit_job(
in job_id: integer32;
in edit_op: prf_$edit_job_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*4 job_id, status
integer*2 edit_op
call prf_$edit_job(job_id, edit_op, status) | [ prf_$edit_job ] |
| prf_get_printers | get a list of printers at the current site
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$get_printers(
prf_$name_t *site,
long *entry,
long &max_printers,
long *ret_printers,
prf_$printer_t *printer_list,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$get_printers(
in site: univ prf_$name_t;
var entry: integer32;
in max_printers: integer32;
out ret_printers: integer32;
out printer_list: univ prf_$printer_array_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 n_printers, example
parameter (n_printers = 32, example = 3)
integer*4 entry, max_printers, ret_printers
character printer_list(n_printers)*102
equivalence (printer_name, printer_list(example))
equivalence (printer_name_length, printer_list(example)(33:34))
equivalence (printer_status, printer_list(example)(35:66))
equivalence (printer_status_length, printer_list(example)(67:68))
equivalence (printer_description, printer_list(example)(69:100))
equivalence (printer_description_length, printer_list(example)(101:102))
call prf_$get_printers(site, entry, max_printers,
& ret_printers, printer_list, status) | [ prf_$get_printers ] |
| prf_get_sites | get a list of print sites
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$get_sites(
long *index,
long &max_sites,
long *ret_sites,
prf_$name_t *site_list,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$get_sites(
var index: integer32;
in max_sites: integer32;
out ret_sites: integer32;
out site_list: univ prf_$name_array_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 n_sites, example
parameter (n_sites = 32, example = 3)
integer*4 index, max_sites, ret_sites, status
character site_list(n_sites)*34
integer*2 site_location_length
character site_location*32
equivalence (site_location, site_list(example))
equivalence (site_location_length, site_list(example) (33:34))
call prf_$get_sites(index, max_sites, ret_sites, site_list, status) | [ prf_$get_sites ] |
| prf_init | initialize print request options
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$init(
ios_$id_t &stream_id,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$init(
in stream_id: ios_$id_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id
integer*4 status
call prf_$init(stream_id, status) | [ prf_$init ] |
| prf_inq_option | get a print request option
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$inq_option(
char *option,
short *option_length,
num_var_t *number_value,
char *string_value,
short *string_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$inq_option(
var option: univ string;
var option_length: integer;
out number_value: num_var_t;
out string_value: univ string;
out string_length: integer;
out status: status_$t)
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 opt_len
parameter (opt_len = 120)
integer*2 option_length, string_length
integer*4 number_value, status
character option*(opt_len), string_value*256
call prf_$inq_option(option, option_length, number_value,
& string_value, string_length, status) | [ prf_$inq_option ] |
| prf_intro | the Domain/OS print library
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn' | [ intro ] |
| prf_name_print | spool a file for printing
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$name_print(
char *pathname,
short &pathname_length,
char *queue,
short &queue_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$name_print(
in pathname: univ name_$pname_t;
in pathname_length: integer ;
out queue: name_$pname_t;
out queue_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 pathname_length, queue_length
integer*4 status
character pathname*1024, queue*1024
call prf_$name_print(pathname, pathname_length, queue,
& queue_length, status) | [ prf_$name_print ] |
| prf_queue_file | queue a print request
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$queue_file(
char *pathname,
short &pathname_length,
char *queue,
short &queue_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$queue_pathname(
in pathname: univ name_$pname_t;
in pathname_length: integer;
out queue: name_$pname_t;
out queue_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 pathname_length, queue_length
integer*4 status
character pathname*1024, queue*1024
call prf_$queue_file(pathname, pathname_length, queue,
& queue_length, status) | [ prf_$queue_file ] |
| prf_read_queue | get a list of print jobs in the queue
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$read_queue(
prf_$read_opt_t &printer_flag,
long *index,
long &max_jobs,
long *ret_jobs,
prf_$job_entry_t *job_list,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$read_queue(
in printer_flag: prf_$read_opt_t;
var index: integer32;
in max_jobs: integer32;
out ret_jobs: integer32;
out job_list: univ prf_$job_array_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 n_jobs, example
parameter (n_jobs = 32, example = 3)
integer*4 printer_flag, index, status
integer*4 max_jobs, ret_jobs
integer*2 job_list(39, n_jobs)
integer*4 job_id, job_priority
integer*2 print_user_length, job_name_length, job_status
character print_user*32, job_name*32
equivalence (job_id, job_list(1, example))
equivalence (print_user, job_list(3, example))
equivalence (print_user_length, job_list(19, example))
equivalence (job_name, job_list(20, example))
equivalence (job_name_length, job_list(36, example))
equivalence (job_priority, job_list(37, example))
equivalence (job_status, job_list(39, example))
call prf_$read_queue(printer_flag, index, max_jobs,
& ret_jobs, job_list, status) | [ prf_$read_queue ] |
| prf_set_option | set an option in a print request
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$set_option(
char *option,
short &option_length,
num_var_t &string_value,
char *p_str,
short &string_length,
boolean &string_encoding,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$set_option(
in option: univ string;
in option_length: integer;
in number_value: num_var_t;
in string_value: univ string;
in string_length: integer;
in string_encoding: boolean;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 opt_len
parameter (opt_len = 120)
integer*2 option_length, string_length
integer*4 number_value, status
character option*(opt_len), string_value*256
logical string_encoding
call prf_$set_option(option, option_length, number_value, string_value,
& string_length, string_encoding, status) | [ prf_$set_option ] |
| prf_signal_printer | signal a print job
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$signal_printer(
prf_$pr_sig_t &signal,
prf_$name_t *printer_name,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$signal_printer(
in signal: prf_$pr_sig_t;
in printer_name: univ prf_$name_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*4 status
integer*2 signal, length
character printer_name*34, name*32
equivalence (name, printer_name(1:32))
equivalence (length, printer_name(33:34))
call prf_$signal_printer(signal, printer_name, status) | [ prf_$signal_printer ] |
| prf_stream_print | print from a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/prf.h>
void prf_$stream_print(
ios_$id_t &stream_id,
char *queue,
short &queue_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/prf.ins.pas';
procedure prf_$stream_print(
in stream_id: ios_$id_t;
out queue: name_$pname_t;
out queue_length: integer;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
integer*2 stream_id, queue_length
integer*4 status
character queue*1024
call prf_$stream_print(stream_id, queue, queue_length, status) | [ prf_$stream_print ] |
| proc1_get_cput | get elapsed CPU time
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc1.h>
void proc1_$get_cput(
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc1.ins.pas';
procedure proc1_$get_cput(
out clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc1.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
equivalence (clockh, clock_value(1)), (clockl, clock_value(2))
call proc1_$get_cput(clock_value) | [ proc1_$get_cput ] |
| proc1_intro | the Level 1 Process Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc1.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc1.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc1.ins.ftn' | [ intro ] |
| proc2_get_info | get level 2 process information
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc2.h>
void proc2_$get_info(
uid_$t &process_uid,
proc2_$info_t *process_info,
pinteger &buffer_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc2.ins.pas';
procedure proc2_$get_info(
in process_uid: uid_$t;
out process_info: univ proc2_$info_t;
in buffer_length: pinteger;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc2.ins.ftn'
integer*4 process_uid(2), status
integer*2 buffer_length, process_info(18)
integer*4 stack_uid(2), stack_base, upc, usp, usb, cpu_total_low
integer*2 state, usr, cpu_total(3), cpu_total_high, priority
equivalence (stack_uid, process_info(1))
equivalence (stack_base, process_info(5))
equivalence (state, process_info(7))
equivalence (usr, process_info(8))
equivalence (upc, process_info(9))
equivalence (usp, process_info(11))
equivalence (usb, process_info(13))
equivalence (cpu_total, process_info(15))
equivalence (priority, process_info(18))
equivalence (cpu_total_high, cpu_total(1))
equivalence (cpu_total_low, cpu_total(2))
call proc2_$get_info(process_uid, process_info, buffer_length, status) | [ proc2_$get_info ] |
| proc2_intro | the Level 2 Process Manager
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc2.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc2.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc2.ins.ftn' | [ intro ] |
| proc2_list | list level 2 process UIDs
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc2.h>
void proc2_$list(
uid_$t *uid_list,
pinteger &max_num_uids,
pinteger *num_uids)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc2.ins.pas';
procedure proc2_$list(
out uid_list: univ proc2_$uid_list_t;
in max_num_uids: pinteger;
out num_uids: pinteger);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc2.ins.ftn'
integer*4 uid_list(48)
integer*2 max_num_uids, num_uids
call proc2_$list(uid_list, max_num_uids, num_uids) | [ proc2_$list ] |
| proc2_who_am_i | get the UID of the calling process
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/proc2.h>
void proc2_$who_am_i(
uid_$t *my_uid)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/proc2.ins.pas';
procedure proc2_$who_am_i(
out my_uid: uid_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/proc2.ins.ftn'
integer*4 my_uid(2)
call proc2_$who_am_i(my_uid) | [ proc2_$who_am_i ] |
| rws_alloc | allocate storage
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/rws.h>
void rws_$alloc(
long &storage_size,
void **storage_ptr)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/rws.ins.pas';
procedure rws_$alloc(
in storage_size: integer32;
out storage_ptr: univ_ptr);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/rws.ins.ftn'
integer*4 nwords
parameter (nwords = 5000)
integer*4 storage_size, storage_ptr
integer*2 dummy(nwords)
pointer /storage_ptr/ dummy
call rws_$alloc(storage_size, storage_ptr) | [ rws_$alloc ] |
| rws_alloc_heap_pool | allocate heap storage
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/rws.h>
void *rws_$alloc_heap_pool(
rws_$pool_t &alloc_pool,
long &storage_size)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/rws.ins.pas';
function rws_$alloc_heap_pool(
in alloc_pool: rws_$pool_t;
in storage_size: rws_$word_aligned_long): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/rws.ins.ftn'
integer*4 nwords
parameter (nwords = 5000)
integer*4 storage_size, storage_ptr
integer*2 alloc_pool, dummy(nwords)
pointer /storage_ptr/ dummy
storage_ptr = rws_$alloc_heap_pool(alloc_pool, storage_size) | [ rws_$alloc_heap_pool ] |
| rws_alloc_rw_pool | allocate read/write storage from a pool
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/rws.h>
void *rws_$alloc_rw_pool(
rws_$pool_t &alloc_pool,
long &storage_size)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/rws.ins.pas';
function rws_$alloc_rw_pool(
in alloc_pool: rws_$pool_t;
in storage_size: rws_$word_aligned_long): univ_ptr;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/rws.ins.ftn'
integer*4 nwords
parameter (nwords = 5000)
integer*4 storage_size, storage_ptr
integer*2 alloc_pool, dummy(nwords)
pointer /storage_ptr/ dummy
storage_ptr = rws_$alloc_rw_pool(alloc_pool, storage_size) | [ rws_$alloc_rw_pool ] |
| rws_intro | dynamic storage allocation
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/rws.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/rws.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/rws.ins.ftn' | [ intro ] |
| rws_release_heap_pool | release heap storage
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/rws.h>
void rws_$release_heap_pool(
void *&storage_ptr,
rws_$pool_t &alloc_pool,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/rws.ins.pas';
procedure rws_$release_heap_pool(
in storage_ptr: univ_ptr;
in alloc_pool: rws_$pool_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/rws.ins.ftn'
integer*4 nwords
parameter (nwords = 5000)
integer*4 storage_ptr, status
integer*2 alloc_pool, dummy(nwords)
pointer /storage_ptr/ dummy
call rws_$release_heap_pool(storage_ptr, alloc_pool, status) | [ rws_$release_heap_pool ] |
| sio_control | set serial line options
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/sio.h>
void sio_$control(
stream_$id_t &stream_id,
sio_$opt_t &sio_option,
sio_$value_t &option_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/sio.ins.pas';
procedure sio_$control(
in stream_id: stream_$id_t;
in sio_option: sio_$opt_t;
in option_value: univ sio_$value_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/sio.ins.ftn'
integer*2 nchar
parameter (nchar = 256)
integer*4 status, option_value
integer*2 stream_id, sio_option, i2_value
logical l_value
character c_value*(nchar)
equivalence (i2_value, option_value)
equivalence (l_value, option_value)
equivalence (c_value, option_value)
call sio_$control(stream_id, sio_option, option_value, status) | [ sio_$control ] |
| sio_inquire | get serial line options
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/sio.h>
void sio_$inquire(
stream_$id_t &stream_id,
sio_$opt_t &sio_option,
sio_$value_t *option_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/sio.ins.pas';
procedure sio_$inquire(
in stream_id: stream_$id_t;
in sio_option: sio_$opt_t;
out option_value: univ sio_$value_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/sio.ins.ftn'
integer*2 nchar
parameter (nchar = 256)
integer*4 status, option_value
integer*2 stream_id, sio_option, i2_value
logical l_value
character c_value*(nchar)
equivalence (i2_value, option_value)
equivalence (l_value, option_value)
equivalence (c_value, option_value)
call sio_$inquire(stream_id, sio_option, option_value, status) | [ sio_$inquire ] |
| sio_intro | controlling serial I/O lines
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/sio.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/sio.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/sio.ins.ftn' | [ intro ] |
| status_intro | status reporting types and constants
SYNOPSIS (C)
#include <apollo/base.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn' | [ intro ] |
| task_blast | kill a task without cleanup
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$blast(
task_$handle_t task_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$blast(
in task_handle: task_$handle_t;
out status: status_$t); | [ task_$blast ] |
| task_create | create a task
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
task_$handle_t task_$create(
void (*routine_pointer)(),
char *arg_pointer,
long arg_length,
long stack_size,
long task_priority,
task_$lifetime_t life_time,
task_$option_set_t task_options,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
function task_$create(
in routine_pointer: task_$routine_p;
in arg_pointer: univ_ptr;
in arg_length: integer32;
in stack_size: integer32;
in task_priority: integer32;
in life_time: task_$lifetime_t;
in task_options: task_$option_set_t;
out status: status_$t): task_$handle_t; | [ task_$create ] |
| task_exit | exit a task
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$exit();
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$exit; | [ task_$exit ] |
| task_get_ec | get a completion eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$get_ec(
task_$handle_t task_handle,
ec2_$ptr_t *eventcount_pointer,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$get_ec(
in task_handle: task_$handle_t;
out eventcount_pointer: ec2_$ptr_t;
out status: status_$t); | [ task_$get_ec ] |
| task_get_handle | return the task handle
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
task_$handle_t task_$get_handle();
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
function task_$get_handle: task_$handle_t; | [ task_$get_handle ] |
| task_get_info | get information about a task
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$get_info(
task_$handle_t task_handle,
task_$info_pt info_pointer,
task_$handle_t *next_handle,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$get_info(
in task_handle: task_$handle_t;
in info_pointer: task_$info_pt;
out next_handle: task_$handle_t;
out status: status_$t); | [ task_$get_info ] |
| task_intro | the Domain/OS task library
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
SYNOPSIS (Pascal)
%include "/sys/ins/base.ins.pas"
%include "/sys/ins/task.ins.pas" | [ intro ] |
| task_release | release a task and report
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$release(
task_$handle_t task_handle,
status_$t *completion_status,
long *output_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$release(
in task_handle: task_$handle_t;
out completion_status: status_$t;
out output_value: integer32;
out status: status_$t); | [ task_$release ] |
| task_set_name | name a task
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$set_name(
task_$handle_t task_handle,
task_$name_pt name_pointer,
long name_length,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$set_name(
in task_handle: task_$handle_t;
in name_pointer: task_$name_pt;
in name_length: integer32;
out status: status_$t); | [ task_$set_name ] |
| task_set_result | change the completion status and output value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$set_result(
status_$t completion_status,
long output_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$set_result(
in completion_status: status_$t;
in output_value: integer32;
out status: status_$t); | [ task_$set_result ] |
| task_signal | signal a task
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$signal(
task_$handle_t task_handle,
status_$t fault_status,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$signal(
in task_handle: task_$handle_t;
in fault_status: status_$t;
out status: status_$t); | [ task_$signal ] |
| task_tasking_enabled | determine whether tasking is enabled
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
boolean task_$tasking_enabled(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
function task_$tasking_enabled: boolean; | [ task_$tasking_enabled ] |
| task_yield | yield the processor
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/task.h>
void task_$yield(void);
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/task.ins.pas';
procedure task_$yield; | [ task_$yield ] |
| time_clock | get the system clock value
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/time.h>
void time_$clock(
time_$clock_t *clock_value)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/time.ins.pas';
procedure time_$clock(
out clock_value: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/time.ins.ftn'
integer*2 clock_value(3), clockh
integer*4 clockl
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call time_$clock(clock_value) | [ time_$clock ] |
| time_get_ec | get a pointer to the time eventcount
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/time.h>
void time_$get_ec(
time_$key_t &time_key,
ec2_$ptr_t *eventcount_pointer,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/time.ins.pas';
procedure time_$get_ec(
in time_key: time_$key_t;
out eventcount_pointer: ec2_$ptr_t;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/time.ins.ftn'
integer*4 status, ec_value
integer*2 time_key, event(3)
equivalence (ec_value, event(1))
integer*4 eventcount_pointer
pointer /eventcount_pointer/ event
call time_$get_ec(time_key, eventcount_pointer, status) | [ time_$get_ec ] |
| time_intro | the Domain/OS time service
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/time.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/time.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/time.ins.ftn' | [ intro ] |
| time_wait | wait for an interval
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/time.h>
void time_$wait(
time_$rel_abs_t &rel_abs,
time_$clock_t &clock_value,
status_$t *status)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/time.ins.pas';
procedure time_$wait(
var rel_abs: time_$rel_abs_t ;
in clock_value: time_$clock_t ;
out status: status_$t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/time.ins.ftn'
integer*2 clock_value(3), clockh, rel_abs
integer*4 clockl, status
equivalence (clockl, clock_value(2)), (clockh, clock_value(1))
call time_$wait(rel_abs, clock_value, status) | [ time_$wait ] |
| tone_intro | make a noise
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tone.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tone.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tone.ins.ftn' | [ intro ] |
| tone_time | make a noise of a specified duration
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tone.h>
void tone_$time(time_$clock_t &time)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tone.ins.pas';
procedure tone_$time(in time: time_$clock_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tone.ins.ftn'
integer*4 clockl
integer*2 clockh, time(3)
equivalence (clockl, time(2)), (clockh, time(1))
call tone_$time(time) | [ tone_$time ] |
| tpad_inq_dtype | return the last locator used
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
tpad_$dev_type_t tpad_$inq_dtype(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
function tpad_$inq_dtype : tpad_$dev_type_t;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn'
integer*2 device
device = tpad_$inq_dtype | [ tpad_$inq_dtype ] |
| tpad_inquire | get information about the current locator response
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
void tpad_$inquire(
tpad_$mode_t *mode,
short *x_scale,
short *y_scale,
short *hysteresis,
smd_$pos_t *origin)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
procedure tpad_$inquire(
out mode: tpad_$mode_t;
out x_scale: integer;
out y_scale: integer;
out hysteresis: integer;
out origin: smd_$pos_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn'
integer*2 mode, x_scale, y_scale, hysteresis
integer*2 line, column, origin(2)
equivalence (line, origin(1)), (column, origin(2))
call tpad_$inquire(mode, x_scale, y_scale, hysteresis, origin) | [ tpad_$inquire ] |
| tpad_intro | locator (touchpad) manager calls
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn' | [ intro ] |
| tpad_re_range | re-establishes the touchpad raw data range
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
void tpad_$re_range(void)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
procedure tpad_$re_range;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn'
call tpad_$re_range | [ tpad_$re_range ] |
| tpad_set_cursor | re-establish the locator origin in relative mode
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
void tpad_$set_cursor(
smd_$pos_t &origin)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
procedure tpad_$set_cursor(
in origin: smd_$pos_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn'
integer*2 line, column, origin(2)
equivalence (line, origin(1)), (column, origin(2))
call tpad_$set_cursor(origin) | [ tpad_$set_cursor ] |
| tpad_set_mode | set pointing device response characteristics
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/tpad.h>
void tpad_$set_mode(
tpad_$mode_t &mode,
short &x_scale,
short &y_scale,
short &hysteresis,
smd_$pos_t &origin)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/tpad.ins.pas';
procedure tpad_$set_mode(
in mode: tpad_$mode_t;
in x_scale: integer;
in y_scale: integer;
in hysteresis: integer;
in origin: smd_$pos_t);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/tpad.ins.ftn'
integer*2 mode, x_scale, y_scale, hysteresis
integer*2 line, column, origin(2)
equivalence (line, origin(1)), (column, origin(2))
call tpad_$set_mode(mode, x_scale, y_scale, hysteresis, origin) | [ tpad_$set_mode ] |
| vec_add_constant | add a scalar to a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$add_constant(
float *start_vec,
long int &length,
float &constant,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$add_constant(
in start_vec: univ vec_$real_vector;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 256)
real start_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$add_constant(start_vec, length, constant, result_vec) | [ vec_$add_constant ] |
| vec_add_constant_i | add a scalar to a vector in a single-precision
matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$add_constant_i(
float *start_vec,
long int &inc1,
long int &length,
float &constant,
float *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$add_constant_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$add_constant_i(start_vec, inc1, length,
& constant, result_vec, inc2) | [ vec_$add_constant_i ] |
| vec_add_vector | add two single-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$add_vector(
float *start_vec,
float *add_vec,
long int &length,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$add_vector(
in start_vec: univ vec_$real_vector;
in add_vec: univ vec_$real_vector;
in length: integer32;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$add_vector(start_vec, add_vec, length, result_vec) | [ vec_$add_vector ] |
| vec_add_vector_i | add vectors in two single-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$add_vector_i(
float *start_vec,
long int &inc1,
float *add_vec,
long int &inc2,
long int &length,
float *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$add_vector_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in add_vec: univ vec_$real_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$real_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$add_vector_i(start_vec, inc1, add_vec, inc2,
& length, result_vec, inc3) | [ vec_$add_vector_i ] |
| vec_copy | copy a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$copy(
float *start_vec,
float *result_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$copy(
in start_vec: univ vec_$real_vector;
out result_vec: univ vec_$real_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$copy(start_vec, result_vec, length) | [ vec_$copy ] |
| vec_copy_i | copy a vector from one single-precision matrix to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$copy_i(
float *start_vec,
long int &inc1,
float *result_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$copy_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
out result_vec: univ vec_$real_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2
call vec_$copy_i(start_vec, inc1, result_vec, inc2, length) | [ vec_$copy_i ] |
| vec_dadd_constant | add a scalar to a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dadd_constant(
double *start_vec,
long int &length,
double &constant,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dadd_constant(
in start_vec: univ vec_$double_vector;
in length: integer32;
in constant: double;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 256)
double precision start_vec(nvec)
double precision result_vec(nvec)
double precision constant
integer*4 length
call vec_$dadd_constant(start_vec, length, constant, result_vec) | [ vec_$dadd_constant ] |
| vec_dadd_constant_i | add a scalar to a vector in a double-precision
matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dadd_constant_i(
float *start_vec,
long int &inc1,
long int &length,
float &constant,
float *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dadd_constant_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$dadd_constant_i(start_vec, inc1, length,
& constant, result_vec, inc2) | [ vec_$dadd_constant_i ] |
| vec_dadd_vector | add two double-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dadd_vector(
double *start_vec,
double *add_vec,
long int &length,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dadd_vector(
in start_vec: univ vec_$double_vector;
in add_vec: univ vec_$double_vector;
in length: integer32;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double-precision start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$dadd_vector(start_vec, add_vec, length, result_vec) | [ vec_$dadd_vector ] |
| vec_dadd_vector_i | add vectors in two double-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dadd_vector_i(
double *start_vec,
long int &inc1,
double *add_vec,
long int &inc2,
long int &length,
double *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dadd_vector_i(
in start_vec: univ vec_$double_vector;
in inc1: integer32;
in add_vec: univ vec_$double_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$double_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$dadd_vector_i(start_vec, inc1, add_vec, inc2,
& length, result_vec, inc3) | [ vec_$dadd_vector_i ] |
| vec_dcopy | copy a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dcopy(
double *start_vec,
double *result_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dcopy(
in start_vec: univ vec_$double_vector;
out result_vec: univ vec_$double_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision start_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$dcopy(start_vec, result_vec, length) | [ vec_$dcopy ] |
| vec_dcopy_i | copy a vector from one double-precision matrix to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dcopy_i(
double *start_vec,
long int &inc1,
double *result_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dcopy_i(
in start_vec: univ vec_$double_vector;
in inc1: integer32;
out result_vec: univ vec_$double_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision start_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2
call vec_$dcopy_i(start_vec, inc1, result_vec, inc2, length) | [ vec_$dcopy_i ] |
| vec_ddot | return the dot product of two double-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
double vec_$ddot(
double *vector1,
double *vector2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$ddot(
in vector1: univ vec_$double_vector;
in vector2: univ vec_$double_vector;
in length: integer32): double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double-precision vector1(nvec), vector2(nvec), result
integer*4 length
result = vec_$ddot(vector1, vector2, length) | [ vec_$ddot ] |
| vec_ddot_i | return the dot product of two vectors in double-precision
matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
double vec_$ddot_i(
double *vector1,
long int &inc1,
double *vector2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$ddot_i(
in vector1: univ vec_$double_vector;
in inc1: integer32;
in vector2: univ vec_$double_vector;
in inc2: integer32;
in length: integer32): double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector1(nvec), vector2(nvec), result
integer*4 length, inc1, inc2
result = vec_$ddot_i(vector1, inc1, vector2, inc2, length) | [ vec_$ddot_i ] |
| vec_dinit | initialize a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dinit(
double *vector,
long int &length,
double &constant)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dinit(
var vector: univ vec_$double_vector;
in length: integer32;
in constant: double);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector(nvec), constant
integer*4 length
call vec_$dinit(vector, length, constant) | [ vec_$dinit ] |
| vec_dmat_mult | multiply two 4x4 double-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmat_mult(
double *matrix1,
double *matrix2,
double *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmat_mult(
in matrix1: univ vec_$double_matrix;
in matrix2: univ vec_$double_matrix;
out out_matrix: univ vec_$double_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
double precision matrix1(4, 4), matrix2(4, 4), out_matrix(4, 4)
call vec_$dmat_mult(matrix1, matrix2, out_matrix) | [ vec_$dmat_mult ] |
| vec_dmat_multn | multiply two double-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmat_multn(
double *matrix1,
double *matrix2,
long int &m,
long int &n,
long int &s,
double *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmat_multn(
in matrix1: univ vec_$double_matrix;
in matrix2: univ vec_$double_matrix;
in m: integer32;
in n: integer32;
in s: integer32;
out out_matrix: univ vec_$double_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n, s
parameter (m = 3, n = 4, s = 5)
double precision matrix1(m, n), matrix2(n, s), out_matrix(m, s)
call vec_$dmat_multn(matrix1, matrix2, m, n, s, out_matrix) | [ vec_$dmat_multn ] |
| vec_dmax | find the maximum absolute value in a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmax(
double *vector,
long int &length,
double *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmax(
in vector: univ vec_$double_vector;
in length: integer32;
out result: double;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector(nvec), result
integer*4 length, location
call vec_$dmax(vector, length, result, location) | [ vec_$dmax ] |
| vec_dmax_i | find the maximum absolute value in a vector from a double-
precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmax_i(
double *vector,
long int &inc,
long int &length,
double *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmax_i(
in vector: univ vec_$double_vector;
in inc: integer32;
in length: integer32;
out result: double;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector(nvec), result
integer*4 length, inc, location
call vec_$dmax_i(vector, inc, length, result, location) | [ vec_$dmax_i ] |
| vec_dmult_add | scale and add one double-precision vector to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmult_add(
double *add_vec,
double *mult_vec,
long int &length,
double &constant,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmult_add(
in add_vec: univ vec_$double_vector;
in mult_vec: univ vec_$double_vector;
in length: integer32;
in constant: double;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$dmult_add(add_vec, mult_vec, length,
& constant, result_vec) | [ vec_$dmult_add ] |
| vec_dmult_add_i | scale and add double-precision vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmult_add_i(
double *add_vec,
long int &inc1,
double *mult_vec,
long int &inc2,
long int &length,
double &constant,
double *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmult_add_i(
in add_vec: univ vec_$double_vector;
in inc1: integer32;
in mult_vec: univ vec_$double_vector;
in inc2: integer32;
in length: integer32;
in constant: double;
out result_vec: univ vec_$double_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2, inc3
call vec_$dmult_add_i(add_vec, inc1, mult_vec, inc2, length,
& constant, result_vec, inc3) | [ vec_$dmult_add_i ] |
| vec_dmult_constant | multiply a double-precision vector by a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmult_constant(
double *mult_vec,
long int &length,
double &constant,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmult_constant(
in mult_vec: univ vec_$double_vector;
in length: integer32;
in constant: double;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$dmult_constant(mult_vec, length, constant, result_vec) | [ vec_$dmult_constant ] |
| vec_dmult_constant_i | multiply a vector in a double-precision matrix by
a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dmult_constant_i(
double *mult_vec,
long int &inc1,
long int &length,
double &constant,
double *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dmult_constant_i(
in mult_vec: univ vec_$double_vector;
in inc1: integer32;
in length: integer32;
in constant: double;
out result_vec: univ vec_$double_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$dmult_constant_i(mult_vec, inc1, length, constant,
& result_vec, inc2) | [ vec_$dmult_constant_i ] |
| vec_dot | return the dot product of two single-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
float vec_$dot(
float *vector1,
float *vector2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$dot(
in vector1: univ vec_$real_vector;
in vector2: univ vec_$real_vector;
in length: integer32): real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector1(nvec), vector2(nvec), result
integer*4 length
result = vec_$dot(vector1, vector2, length) | [ vec_$dot ] |
| vec_dot_i | return the dot product of two vectors in single-precision
matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
float vec_$dot_i(
float *vector1,
long int &inc1,
float *vector2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$dot_i(
in vector1: univ vec_$real_vector;
in inc1: integer32;
in vector2: univ vec_$real_vector;
in inc2: integer32;
in length: integer32): real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector1(nvec), vector2(nvec), result
integer*4 length, inc1, inc2
result = vec_$dot_i(vector1, inc1, vector2, inc2, length) | [ vec_$dot_i ] |
| vec_dp_sp | copy a double-precision vector to a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dp_sp(
double *dp_vec,
float *sp_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dp_sp(
in dp_vec: univ vec_$double_vector;
in sp_vec: univ vec_$real_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real sp_vec(nvec)
double precision dp_vec(nvec)
integer*4 length
call vec_$dp_sp(dp_vec, sp_vec, length) | [ vec_$dp_sp ] |
| vec_dp_sp_i | copy a vector from a double-precision matrix into a
single-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dp_sp_i(
double *dp_vec,
long int &inc1,
float *sp_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dp_sp_i(
in dp_vec: univ vec_$double_vector;
in inc1: integer32;
in sp_vec: univ vec_$real_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real sp_vec(nvec)
double precision dp_vec(nvec)
integer*4 length, inc1, inc2
call vec_$dp_sp_i(dp_vec, inc1, sp_vec, inc2, length) | [ vec_$dp_sp_i ] |
| vec_dpostmult | multiply a double-precision vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dpostmult(
double *matrix,
double *start_vec,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dpostmult(
in matrix: univ vec_$double_matrix;
in start_vec: univ vec_$double_vector;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
double precision matrix(4, 4), start_vec(4), result_vec(4)
call vec_$dpostmult(matrix, start_vec, result_vec) | [ vec_$dpostmult ] |
| vec_dpostmultn | multiply a double-precision vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dpostmultn(
double *matrix,
double *start_vec,
long int &m,
long int &n,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dpostmultn(
in matrix: univ vec_$double_matrix;
in start_vec: univ vec_$double_vector;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
double precision matrix(m, n), start_vec(n), result_vec(m)
call vec_$dpostmultn(matrix, start_vec, m, n, result_vec) | [ vec_$dpostmultn ] |
| vec_dpremult | multiply a double-precision vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dpremult(
double *start_vec,
double *matrix,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dpremult(
in start_vec: univ vec_$double_vector;
in matrix: univ vec_$double_matrix;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
double precision start_vec(4), matrix(4,4), result_vec(4)
call vec_$dpremult(start_vec, matrix, result_vec) | [ vec_$dpremult ] |
| vec_dpremultn | multiply a double-precision vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dpremultn(
double *start_vec,
double *matrix,
long int &m,
long int &n,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dpremultn(
in start_vec: univ vec_$double_vector;
in matrix: univ vec_$double_matrix;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
double precision start_vec(m), matrix(m, n), result_vec(n)
call vec_$dpremultn(start_vec, matrix, m, n, result_vec) | [ vec_$dpremultn ] |
| vec_dsub | subtract double-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dsub(
double *start_vec,
double *sub_vec,
long int &length,
double *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dsub(
in start_vec: univ vec_$double_vector;
in sub_vec: univ vec_$double_vector;
in length: integer32;
out result_vec: univ vec_$double_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$dsub(start_vec, sub_vec, length, result_vec) | [ vec_$dsub ] |
| vec_dsub_i | subtract double-precision vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dsub_i(
double *start_vec,
long int &inc1,
double *sub_vec,
long int &inc2,
long int &length,
double *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dsub_i(
in start_vec: univ vec_$double_vector;
in inc1: integer32;
in sub_vec: univ vec_$double_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$double_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$dsub_i(start_vec, inc1, sub_vec, inc2,
& length, result_vec, inc3) | [ vec_$dsub_i ] |
| vec_dsum | sum the elements of a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
double vec_$dsum(
double *vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$dsum(
in vec: univ vec_$double_vector;
in length: integer32): double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vec(nvec), sum
integer*4 length
sum = vec_$dsum(vec, length) | [ vec_$dsum ] |
| vec_dsum_i | sum the elements of a vector in a double-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
double vec_$dsum_i(
double *vec,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$dsum_i(
in vec: univ vec_$double_vector;
in inc: integer32;
in length: integer32): double;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vec(nvec), sum
integer*4 length, inc
sum = vec_$sum_i(vec, inc, length) | [ vec_$dsum_i ] |
| vec_dswap | swap two double-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dswap(
double *vec1,
double *vec2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dswap(
var vec1: univ vec_$double_vector;
var vec2: univ vec_$double_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vec1(nvec), vec2(nvec)
integer*4 length
call vec_$dswap(vec1, vec2, length) | [ vec_$dswap ] |
| vec_dswap_i | swap two vectors in a double-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dswap_i(
double *vec1,
long int &inc1,
double *vec2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dswap_i(
var vec1: univ vec_$double_vector;
in inc1: integer32;
var vec1: univ vec_$double_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vec1(nvec), vec2(nvec)
integer*4 length, inc1, inc2
call vec_$dswap_i(vec1, inc1, vec2, inc2, length) | [ vec_$dswap_i ] |
| vec_dzero | zero a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dzero(
double *vector,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dzero(
var vector: univ vec_$double_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector(nvec)
integer*4 length
call vec_$dzero(vector, length) | [ vec_$dzero ] |
| vec_dzero_i | zero a vector in a double-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$dzero_i(
double *vector,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$dzero_i(
var vector: univ vec_$double_vector;
in inc: integer32;
in length: integer32)
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision vector(nvec)
integer*4 length, inc
call vec_$dzero_i(vector, inc, length) | [ vec_$dzero_i ] |
| vec_iadd_constant | add a scalar constant to a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_constant(
long *start_vec,
long int &length,
long &constant,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_constant(
in start_vec: univ vec_$integer32_vector;
in length: integer32;
in constant: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 256)
integer*4 start_vec(nvec), result_vec(nvec)
integer*4 constant
integer*4 length
call vec_$iadd_constant(start_vec, length, constant, result_vec) | [ vec_$iadd_constant ] |
| vec_iadd_constant16 | add a scalar constant to a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_constant16(
short *start_vec,
long int &length,
short &constant,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_constant16(
in start_vec: univ vec_$integer16_vector;
in length: integer32;
in constant: integer16;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 256)
integer*4 start_vec(nvec), result_vec(nvec)
integer*4 constant
integer*4 length
call vec_$iadd_constant16(start_vec, length, constant, result_vec) | [ vec_$iadd_constant16 ] |
| vec_iadd_constant16_i | add a scalar to a vector in a 16-bit integer
matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_constant16_i(
float *start_vec,
long int &inc1,
long int &length,
float &constant,
float *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_constant16_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$iadd_constant16_i(start_vec, inc1, length,
& constant, result_vec, inc2) | [ vec_$iadd_constant16_i ] |
| vec_iadd_constant_i | add a scalar to a vector in a 32-bit integer
matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_constant_i(
float *start_vec,
long int &inc1,
long int &length,
float &constant,
float *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_constant_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$iadd_constant_i(start_vec, inc1, length,
& constant, result_vec, inc2) | [ vec_$iadd_constant_i ] |
| vec_iadd_vector | add two 32-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_vector(
long *start_vec,
long *add_vec,
long int &length,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_vector(
in start_vec: univ vec_$integer32_vector;
in add_vec: univ vec_$integer32_vector;
in length: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$iadd_vector(start_vec, add_vec, length, result_vec) | [ vec_$iadd_vector ] |
| vec_iadd_vector16 | add two 16-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_vector16(
short *start_vec,
short *add_vec,
long int &length,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_vector16(
in start_vec: univ vec_$integer16_vector;
in add_vec: univ vec_$integer16_vector;
in length: integer32;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$iadd_vector16(start_vec, add_vec, length, result_vec) | [ vec_$iadd_vector16 ] |
| vec_iadd_vector16_i | add vectors in two 16-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_vector16_i(
short *start_vec,
long int &inc1,
short *add_vec,
long int &inc2,
long int &length,
short *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_vector16_i(
in start_vec: univ vec_$integer16_vector;
in inc1: integer32;
in add_vec: univ vec_$integer16_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$integer16_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$iadd_vector16_i(start_vec, inc1, add_vec, inc2,
& length, result_vec, inc3) | [ vec_$iadd_vector16_i ] |
| vec_iadd_vector_i | add vectors in two 32-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iadd_vector_i(
long *start_vec,
long int &inc1,
long *add_vec,
long int &inc2,
long int &length,
long *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iadd_vector_i(
in start_vec: univ vec_$integer32_vector;
in inc1: integer32;
in add_vec: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$integer32_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), add_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$iadd_vector_i(start_vec, inc1, add_vec, inc2,
& length, result_vec, inc3) | [ vec_$iadd_vector_i ] |
| vec_icopy | copy a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$icopy(
long *start_vec,
long *result_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$icopy(
in start_vec: univ vec_$integer32_vector;
out result_vec: univ vec_$integer32_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$icopy(start_vec, result_vec, length) | [ vec_$icopy ] |
| vec_icopy16 | copy a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$icopy16(
short *start_vec,
short *result_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$icopy16(
in start_vec: univ vec_$integer16_vector;
out result_vec: univ vec_$integer16_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$icopy16(start_vec, result_vec, length) | [ vec_$icopy16 ] |
| vec_icopy16_i | copy a vector from one 16-bit integer matrix to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$icopy16_i(
short *start_vec,
long int &inc1,
short *result_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$icopy16_i(
in start_vec: univ vec_$integer16_vector;
in inc1: integer32;
out result_vec: univ vec_$integer16_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2
call vec_$icopy16_i(start_vec, inc1, result_vec, inc2, length) | [ vec_$icopy16_i ] |
| vec_icopy_i | copy a vector from one 32-bit integer matrix to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$icopy_i(
long *start_vec,
long int &inc1,
long *result_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$icopy_i(
in start_vec: univ vec_$integer32_vector;
in inc1: integer32;
out result_vec: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2
call vec_$icopy_i(start_vec, inc1, result_vec, inc2, length) | [ vec_$icopy_i ] |
| vec_idot | return the dot product of two 32-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
long vec_$idot(
long *vector1,
long *vector2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$idot(
in vector1: univ vec_$integer32_vector;
in vector2: univ vec_$integer32_vector;
in length: integer32): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector1(nvec), vector2(nvec), result
integer*4 length
result = vec_$idot(vector1, vector2, length) | [ vec_$idot ] |
| vec_idot16 | return the dot product of two 16-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
short vec_$idot16(
short *vector1,
short *vector2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$idot16(
in vector1: univ vec_$integer16_vector;
in vector2: univ vec_$integer16_vector;
in length: integer32): integer16;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector1(nvec), vector2(nvec), result
integer*4 length
result = vec_$idot16(vector1, vector2, length) | [ vec_$idot16 ] |
| vec_idot16_i | return the dot product of two vectors in 16-bit integer
matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
short vec_$idot16_i(
short *vector1,
long int &inc1,
short *vector2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$idot16_i(
in vector1: univ vec_$integer16_vector;
in inc1: integer32;
in vector2: univ vec_$integer16_vector;
in inc2: integer32;
in length: integer32): integer16;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector1(nvec), vector2(nvec), result
integer*4 length, inc1, inc2
result = vec_$idot16_i(vector1, inc1, vector2, inc2, length) | [ vec_$idot16_i ] |
| vec_idot_i | return the dot product of two vectors in 32-bit integer
matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
long vec_$idot_i(
long *vector1,
long int &inc1,
long *vector2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$idot_i(
in vector1: univ vec_$integer32_vector;
in inc1: integer32;
in vector2: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector1(nvec), vector2(nvec), result
integer*4 length, inc1, inc2
result = vec_$idot_i(vector1, inc1, vector2, inc2, length) | [ vec_$idot_i ] |
| vec_iinit | initialize a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iinit(
long *vector,
long int &length,
long &constant)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iinit(
var vector: univ vec_$integer32_vector;
in length: integer32;
in constant: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector(nvec), constant
integer*4 length
call vec_$iinit(vector, length, constant) | [ vec_$iinit ] |
| vec_iinit16 | initialize a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iinit16(
short *vector,
long int &length,
short &constant)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iinit16(
var vector: univ vec_$integer16_vector;
in length: integer32;
in constant: integer16);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector(nvec), constant
integer*4 length
call vec_$iinit16(vector, length, constant) | [ vec_$iinit16 ] |
| vec_imat_mult | multiply two 4x4 32-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imat_mult(
long *matrix1,
long *matrix2,
long *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imat_mult(
in matrix1: univ vec_$integer32_matrix;
in matrix2: univ vec_$integer32_matrix;
out out_matrix: univ vec_$integer32_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 matrix1(4, 4), matrix2(4, 4), out_matrix(4, 4)
call vec_$imat_mult(matrix1, matrix2, out_matrix) | [ vec_$imat_mult ] |
| vec_imat_mult16 | multiply two 4x4 16-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imat_mult16(
short *matrix1,
short *matrix2,
short *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imat_mult16(
in matrix1: univ vec_$integer16_matrix;
in matrix2: univ vec_$integer16_matrix;
out out_matrix: univ vec_$integer16_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*2 matrix1(4, 4), matrix2(4, 4), out_matrix(4, 4)
call vec_$imat_mult16(matrix1, matrix2, out_matrix) | [ vec_$imat_mult16 ] |
| vec_imat_multn | multiply two 32-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imat_multn(
long *matrix1,
long *matrix2,
long int &m,
long int &n,
long int &s,
long *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imat_multn(
in matrix1: univ vec_$integer32_matrix;
in matrix2: univ vec_$integer32_matrix;
in m: integer32;
in n: integer32;
in s: integer32;
out out_matrix: univ vec_$integer32_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n, s
parameter (m = 3, n = 4, s = 5)
integer*4 matrix1(m, n), matrix2(n, s), out_matrix(m, s)
call vec_$imat_multn(matrix1, matrix2, m, n, s, out_matrix) | [ vec_$imat_multn ] |
| vec_imat_multn16 | multiply two 16-bit integer matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imat_multn16(
short *matrix1,
short *matrix2,
long int &m,
long int &n,
long int &s,
short *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imat_multn16(
in matrix1: univ vec_$integer16_matrix;
in matrix2: univ vec_$integer16_matrix;
in m: integer32;
in n: integer32;
in s: integer32;
out out_matrix: univ vec_$integer16_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*2 m, n, s
parameter (m = 3, n = 4, s = 5)
integer*4 matrix1(m, n), matrix2(n, s), out_matrix(m, s)
call vec_$imat_multn16(matrix1, matrix2, m, n, s, out_matrix) | [ vec_$imat_multn16 ] |
| vec_imax | find the maximum absolute value in a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imax(
long *vector,
long int &length,
long *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imax(
in vector: univ vec_$integer32_vector;
in length: integer32;
out result: integer32;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector(nvec), result
integer*4 length, location
call vec_$imax(vector, length, result, location) | [ vec_$imax ] |
| vec_imax16 | find the maximum absolute value in a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imax16(
short *vector,
long int &length,
short *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imax16(
in vector: univ vec_$integer16_vector;
in length: integer32;
out result: integer16;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector(nvec), result
integer*4 length, location
call vec_$imax16(vector, length, result, location) | [ vec_$imax16 ] |
| vec_imax16_i | find the maximum absolute value in a vector from a 16-bit
integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imax16_i(
short *vector,
long int &inc,
long int &length,
short *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imax16_i(
in vector: univ vec_$integer16_vector;
in inc: integer32;
in length: integer32;
out result: integer16;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector(nvec), result
integer*4 length, inc, location
call vec_$imax16_i(vector, inc, length, result, location) | [ vec_$imax16_i ] |
| vec_imax_i | find the maximum absolute value in a vector from a 32-bit
integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imax_i(
long *vector,
long int &inc,
long int &length,
long *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imax_i(
in vector: univ vec_$integer32_vector;
in inc: integer32;
in length: integer32;
out result: integer32;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector(nvec), result
integer*4 length, inc, location
call vec_$imax_i(vector, inc, length, result, location) | [ vec_$imax_i ] |
| vec_imult_add | scale and add one 32-bit integer vector to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_add(
long *add_vec,
long *mult_vec,
long int &length,
long &constant,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_add(
in add_vec: univ vec_$integer32_vector;
in mult_vec: univ vec_$integer32_vector;
in length: integer32;
in constant: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$imult_add(add_vec, mult_vec, length,
& constant, result_vec) | [ vec_$imult_add ] |
| vec_imult_add16 | scale and add one 16-bit integer vector to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_add16(
short *add_vec,
short *mult_vec,
long int &length,
short &constant,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_add16(
in add_vec: univ vec_$integer16_vector;
in mult_vec: univ vec_$integer16_vector;
in length: integer32;
in constant: integer16;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$imult_add16(add_vec, mult_vec, length,
& constant, result_vec) | [ vec_$imult_add16 ] |
| vec_imult_add16_i | scale and add 16-bit vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_add16_i(
short *add_vec,
long int &inc1,
short *mult_vec,
long int &inc2,
long int &length,
short &constant,
short *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_add16_i(
in add_vec: univ vec_$integer16_vector;
in inc1: integer32;
in mult_vec: univ vec_$integer16_vector;
in inc2: integer32;
in length: integer32;
in constant: integer16;
out result_vec: univ vec_$integer16_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2, inc3
call vec_$imult_add16_i(add_vec, inc1, mult_vec, inc2, length,
& constant, result_vec, inc3) | [ vec_$imult_add16_i ] |
| vec_imult_add_i | scale and add 32-bit vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_add_i(
long *add_vec,
long int &inc1,
long *mult_vec,
long int &inc2,
long int &length,
long &constant,
long *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_add_i(
in add_vec: univ vec_$integer32_vector;
in inc1: integer32;
in mult_vec: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32;
in constant: integer32;
out result_vec: univ vec_$integer32_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2, inc3
call vec_$imult_add_i(add_vec, inc1, mult_vec, inc2, length,
& constant, result_vec, inc3) | [ vec_$imult_add_i ] |
| vec_imult_constant | multiply a 32-bit integer vector by a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_constant(
long *mult_vec,
long int &length,
long &constant,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_constant(
in start_vec: univ vec_$integer32_vector;
in length: integer32;
in constant: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$imult_constant(mult_vec, length, constant, result_vec) | [ vec_$imult_constant ] |
| vec_imult_constant16 | multiply a 16-bit integer vector by a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_constant16(
short *mult_vec,
long int &length,
short &constant,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_constant16(
in mult_vec: univ vec_$integer16_vector;
in length: integer32;
in constant: integer16;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$imult_constant16(mult_vec, length, constant, result_vec) | [ vec_$imult_constant16 ] |
| vec_imult_constant16_i | multiply a vector in a 16-bit integer matrix by
a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_constant16_i(
short *mult_vec,
long int &inc1,
long int &length,
short &constant,
short *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_constant16_i(
in mult_vec: univ vec_$integer16_vector;
in inc1: integer32;
in length: integer32;
in constant: integer16;
out result_vec: univ vec_$integer16_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$imult_constant16_i(mult_vec, inc1, length, constant,
& result_vec, inc2) | [ vec_$imult_constant16_i ] |
| vec_imult_constant_i | multiply a vector in a 32-bit integer matrix by a
scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$imult_constant_i(
long *mult_vec,
long int &inc1,
long int &length,
long &constant,
long *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$imult_constant_i(
in mult_vec: univ vec_$integer32_vector;
in inc1: integer32;
in length: integer32;
in constant: integer32;
out result_vec: univ vec_$integer32_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$imult_constant_i(mult_vec, inc1, length, constant,
& result_vec, inc2) | [ vec_$imult_constant_i ] |
| vec_init | initialize a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$init(
float *vector,
long int &length,
float &constant)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$init(
var vector: univ vec_$real_vector;
in length: integer32;
in constant: real);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector(nvec), constant
integer*4 length
call vec_$init(vector, length, constant) | [ vec_$init ] |
| vec_intro | the Vector Library
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn' | [ intro ] |
| vec_ipostmult | multiply a 32-bit integer vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipostmult(
long *matrix,
long *start_vec,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipostmult(
in matrix: univ vec_$integer32_matrix;
in start_vec: univ vec_$integer32_vector;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 matrix(4, 4), start_vec(4), result_vec(4)
call vec_$ipostmult(matrix, start_vec, result_vec) | [ vec_$ipostmult ] |
| vec_ipostmult16 | multiply a 16-bit integer vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipostmult16(
short *matrix,
short *start_vec,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipostmult16(
in matrix: univ vec_$integer16_matrix;
in start_vec: univ vec_$integer16_vector;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*2 matrix(4, 4), start_vec(4), result_vec(4)
call vec_$ipostmult16(matrix, start_vec, result_vec) | [ vec_$ipostmult16 ] |
| vec_ipostmultn | multiply a 32-bit integer vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipostmultn(
long *matrix,
long *start_vec,
long int &m,
long int &n,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipostmultn(
in matrix: univ vec_$integer32_matrix;
in start_vec: univ vec_$integer32_vector;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
integer*4 matrix(m, n), start_vec(n), result_vec(m)
call vec_$ipostmultn(matrix, start_vec, m, n, result_vec) | [ vec_$ipostmultn ] |
| vec_ipostmultn16 | multiply a 16-bit integer vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipostmultn16(
short *matrix,
short *start_vec,
long int &m,
long int &n,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipostmultn16(
in matrix: univ vec_$integer16_matrix;
in start_vec: univ vec_$integer16_vector;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
integer*2 matrix(m, n), start_vec(n), result_vec(m)
call vec_$ipostmultn16(matrix, start_vec, m, n, result_vec) | [ vec_$ipostmultn16 ] |
| vec_ipremult | multiply a 32-bit vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipremult(
long *start_vec,
long *matrix,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipremult(
in start_vec: univ vec_$integer32_vector;
in matrix: univ vec_$integer32_matrix;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 start_vec(4), matrix(4,4), result_vec(4)
call vec_$ipremult(start_vec, matrix, result_vec) | [ vec_$ipremult ] |
| vec_ipremult16 | multiply a 16-bit vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipremult16(
short *start_vec,
short *matrix,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipremult16(
in start_vec: univ vec_$integer16_vector;
in matrix: univ vec_$integer16_matrix;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*2 start_vec(4), matrix(4,4), result_vec(4)
call vec_$ipremult16(start_vec, matrix, result_vec) | [ vec_$ipremult16 ] |
| vec_ipremultn | multiply a 32-bit integer vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipremultn(
long *start_vec,
long *matrix,
long int &m,
long int &n,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipremultn(
in start_vec: univ vec_$integer32_vector;
in matrix: univ vec_$integer32_matrix;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
integer*4 start_vec(m), matrix(m, n), result_vec(n)
call vec_$ipremultn(start_vec, matrix, m, n, result_vec) | [ vec_$ipremultn ] |
| vec_ipremultn16 | multiply a 16-bit integer vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$ipremultn16(
short *start_vec,
short *matrix,
long int &m,
long int &n,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$ipremultn16(
in start_vec: univ vec_$integer16_vector;
in matrix: univ vec_$integer16_matrix;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
integer*2 start_vec(m), matrix(m, n), result_vec(n)
call vec_$ipremultn16(start_vec, matrix, m, n, result_vec) | [ vec_$ipremultn16 ] |
| vec_isub | subtract 32-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$isub(
long *start_vec,
long *sub_vec,
long int &length,
long *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$isub(
in start_vec: univ vec_$integer32_vector;
in sub_vec: univ vec_$integer32_vector;
in length: integer32;
out result_vec: univ vec_$integer32_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$isub(start_vec, sub_vec, length, result_vec) | [ vec_$isub ] |
| vec_isub16 | subtract 16-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$isub16(
short *start_vec,
short *sub_vec,
long int &length,
short *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$isub16(
in start_vec: univ vec_$integer16_vector;
in sub_vec: univ vec_$integer16_vector;
in length: integer32;
out result_vec: univ vec_$integer16_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$isub16(start_vec, sub_vec, length, result_vec) | [ vec_$isub16 ] |
| vec_isub16_i | subtract 16-bit integer vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$isub16_i(start_vec, inc1, sub_vec, inc2,
& length, result_vec, inc3) | [ vec_$isub16_i ] |
| vec_isub_i | subtract 32-bit integer vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$isub_i(
long *start_vec,
long int &inc1,
long *sub_vec,
long int &inc2,
long int &length,
long *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$isub_i(
in start_vec: univ vec_$integer32_vector;
in inc1: integer32;
in sub_vec: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$integer32_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$isub_i(start_vec, inc1, sub_vec, inc2,
& length, result_vec, inc3) | [ vec_$isub_i ] |
| vec_isum | sum the elements of a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
long vec_$isum(
long *vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$isum(
in vec: univ vec_$integer32_vector;
in length: integer32): integer32
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vec(nvec), sum
integer*4 length
sum = vec_$isum(vec, length) | [ vec_$isum ] |
| vec_isum16 | sum the elements of a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
short vec_$isum16(
short *vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$isum16(
in vec: univ vec_$integer16_vector;
in length: integer32): integer16;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vec(nvec), sum
integer*4 length
sum = vec_$isum16(vec, length) | [ vec_$isum16 ] |
| vec_isum16_i | sum the elements of a vector in a 16-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
short vec_$isum16_i(
short *vec,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$isum16_i(
in vec: univ vec_$integer16_vector;
in inc: integer32;
in length: integer32): integer16;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vec(nvec), sum
integer*4 length, inc
sum = vec_$isum16_i(vec, inc, length) | [ vec_$isum16_i ] |
| vec_isum_i | sum the elements of a vector in a 32-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
long vec_$isum_i(
long *vec,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$isum_i(
in vec: univ vec_$integer32_vector;
in inc: integer32;
in length: integer32): integer32;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vec(nvec), sum
integer*4 length, inc
sum = vec_$isum_i(vec, inc, length) | [ vec_$isum_i ] |
| vec_iswap | swap two 32-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iswap(
long *vec1,
long *vec2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iswap(
var vec1: univ vec_$integer32_vector;
var vec2: univ vec_$integer32_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vec1(nvec), vec2(nvec)
integer*4 length
call vec_$iswap(vec1, vec2, length) | [ vec_$iswap ] |
| vec_iswap16 | swap two 16-bit integer vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iswap16(
short *vec1,
short *vec2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iswap16(
var vec1: univ vec_$integer16_vector;
var vec2: univ vec_$integer16_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vec1(nvec), vec2(nvec)
integer*4 length
call vec_$iswap16(vec1, vec2, length) | [ vec_$iswap16 ] |
| vec_iswap16_i | swap two vectors in a 16-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iswap16_i(
short *vec1,
long int &inc1,
short *vec2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iswap16_i(
var vec1: univ vec_$integer16_vector;
in inc1: integer32;
var vec1: univ vec_$integer16_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vec1(nvec), vec2(nvec)
integer*4 length, inc1, inc2
call vec_$iswap16_i(vec1, inc1, vec2, inc2, length) | [ vec_$iswap16_i ] |
| vec_iswap_i | swap two vectors in a 32-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$iswap_i(
long *vec1,
long int &inc1,
long *vec2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$iswap_i(
var vec1: univ vec_$integer32_vector;
in inc1: integer32;
var vec2: univ vec_$integer32_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vec1(nvec), vec2(nvec)
integer*4 length, inc1, inc2
call vec_$iswap_i(vec1, inc1, vec2, inc2, length) | [ vec_$iswap_i ] |
| vec_izero | zero a 32-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$izero(
long *vector,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$izero(
var vector: univ vec_$integer32_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector(nvec)
integer*4 length
call vec_$izero(vector, length) | [ vec_$izero ] |
| vec_izero16 | zero a 16-bit integer vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$izero16(
short *vector,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$izero16(
var vector: univ vec_$integer16_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector(nvec)
integer*4 length
call vec_$izero16(vector, length) | [ vec_$izero16 ] |
| vec_izero16_i | zero a vector in a 16-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$izero16_i(
short *vector,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$izero16_i(
var vector: univ vec_$integer16_vector;
in inc: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*2 vector(nvec)
integer*4 length, inc
call vec_$izero16_i(vector, inc, length) | [ vec_$izero16_i ] |
| vec_izero_i | zero a vector in a 32-bit integer matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$izero_i(
long *vector,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$izero_i(
var vector: univ vec_$integer32_vector;
in inc: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
integer*4 vector(nvec)
integer*4 length, inc
call vec_$izero_i(vector, inc, length) | [ vec_$izero_i ] |
| vec_mat_mult | multiply two 4x4 single-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mat_mult(
float *matrix1,
float *matrix2,
float *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mat_mult(
in matrix1: univ vec_$real_matrix;
in matrix2: univ vec_$real_matrix;
out out_matrix: univ vec_$real_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
real matrix1(4, 4), matrix2(4, 4), out_matrix(4, 4)
call vec_$mat_mult(matrix1, matrix2, out_matrix) | [ vec_$mat_mult ] |
| vec_mat_multn | multiply two single-precision matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mat_multn(
float *matrix1,
float *matrix2,
long int &m,
long int &n,
long int &s,
float *out_matrix)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mat_multn(
in matrix1: univ vec_$real_matrix;
in matrix2: univ vec_$real_matrix;
in m: integer32;
in n: integer32;
in s: integer32;
out out_matrix: univ vec_$real_matrix);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n, s
parameter (m = 3, n = 4, s = 5)
real matrix1(m, n), matrix2(n, s), out_matrix(m, s)
call vec_$mat_multn(matrix1, matrix2, m, n, s, out_matrix) | [ vec_$mat_multn ] |
| vec_max | find the maximum absolute value in a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$max(
float *vector,
long int &length,
float *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$max(
in vector: univ vec_$real_vector;
in length: integer32;
out result: real;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector(nvec), result
integer*4 length, location
call vec_$max(vector, length, result, location) | [ vec_$max ] |
| vec_max_i | find the maximum absolute value in a vector from a single-
precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$max_i(
float *vector,
long int &inc,
long int &length,
float *result,
long int *location)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$max_i(
in vector: univ vec_$real_vector;
in inc: integer32;
in length: integer32;
out result: real;
out location: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector(nvec), result
integer*4 length, inc, location
call vec_$max_i(vector, inc, length, result, location) | [ vec_$max_i ] |
| vec_mult_add | scale and add one single-precision vector to another
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mult_add(
float *add_vec,
float *mult_vec,
long int &length,
float &constant,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mult_add(
in add_vec: univ vec_$real_vector;
in mult_vec: univ vec_$real_vector;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$mult_add(add_vec, mult_vec, length,
& constant, result_vec) | [ vec_$mult_add ] |
| vec_mult_add_i | scale and add single-precision vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mult_add_i(
float *add_vec,
long int &inc1,
float *mult_vec,
long int &inc2,
long int &length,
float &constant,
float *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mult_add_i(
in add_vec: univ vec_$real_vector;
in inc1: integer32;
in mult_vec: univ vec_$real_vector;
in inc2: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real add_vec(nvec), mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2, inc3
call vec_$mult_add_i(add_vec, inc1, mult_vec, inc2, length,
& constant, result_vec, inc3) | [ vec_$mult_add_i ] |
| vec_mult_constant | multiply a single-precision vector by a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mult_constant(
float *mult_vec,
long int &length,
float &constant,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mult_constant(
in mult_vec: univ vec_$real_vector;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real mult_vec(nvec), result_vec(nvec), constant
integer*4 length
call vec_$mult_constant(mult_vec, length, constant, result_vec) | [ vec_$mult_constant ] |
| vec_mult_constant_i | multiply a vector in a single-precision matrix by
a scalar
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$mult_constant_i(
float *mult_vec,
long int &inc1,
long int &length,
float &constant,
float *result_vec,
long int &inc2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$mult_constant_i(
in mult_vec: univ vec_$real_vector;
in inc1: integer32;
in length: integer32;
in constant: real;
out result_vec: univ vec_$real_vector;
in inc2: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real mult_vec(nvec), result_vec(nvec), constant
integer*4 length, inc1, inc2
call vec_$mult_constant_i(mult_vec, inc1, length, constant,
& result_vec, inc2) | [ vec_$mult_constant_i ] |
| vec_postmult | multiply a single-precision vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$postmult(
float *matrix,
float *start_vec,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$postmult(
in matrix: univ vec_$real_matrix;
in start_vec: univ vec_$real_vector;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
real matrix(4, 4), start_vec(4), result_vec(4)
call vec_$postmult(matrix, start_vec, result_vec) | [ vec_$postmult ] |
| vec_postmultn | multiply a single-precision vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$postmultn(
float *matrix,
float *start_vec,
long int &m,
long int &n,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$postmultn(
in matrix: univ vec_$real_matrix;
in start_vec: univ vec_$real_vector;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
real matrix(m, n), start_vec(n), result_vec(m)
call vec_$postmultn(matrix, start_vec, m, n, result_vec) | [ vec_$postmultn ] |
| vec_premult | multiply a single-precision vector by a 4x4 matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$premult(
float *start_vec,
float *matrix,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$premult(
in start_vec: univ vec_$real_vector;
in matrix: univ vec_$real_matrix;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
real start_vec(4), matrix(4,4), result_vec(4)
call vec_$premult(start_vec, matrix, result_vec) | [ vec_$premult ] |
| vec_premultn | multiply a single-precision vector by a matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$premultn(
float *start_vec,
float *matrix,
long int &m,
long int &n,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$premultn(
in start_vec: univ vec_$real_vector;
in matrix: univ vec_$real_matrix;
in m: integer32;
in n: integer32;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
integer*4 m, n
parameter (m = 3, n = 4)
real start_vec(m), matrix(m, n), result_vec(n)
call vec_$premultn(start_vec, matrix, m, n, result_vec) | [ vec_$premultn ] |
| vec_sp_dp | copy a single-precision vector to a double-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$sp_dp(
float *sp_vec,
double *dp_vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$sp_dp(
in sp_vec: univ vec_$real_vector;
in dp_vec: univ vec_$double_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision dp_vec(nvec)
real sp_vec(nvec)
integer*4 length
call vec_$sp_dp(sp_vec, dp_vec, length) | [ vec_$sp_dp ] |
| vec_sp_dp_i | copy a single-precision vector to a double-precision vec-
tor in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$sp_dp_i(
float *sp_vec,
long int &inc1,
double *dp_vec,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$sp_dp_i(
in sp_vec: univ vec_$real_vector;
in inc1: integer32;
in dp_vec: univ vec_$double_vector;
in inc2: integer32;
in length: integer32) ;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
double precision dp_vec(nvec)
real sp_vec(nvec)
integer*4 length, inc1, inc2
call vec_$sp_dp_i(sp_vec, inc1, dp_vec, inc2, length) | [ vec_$sp_dp_i ] |
| vec_sub | subtract single-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$sub(
float *start_vec,
float *sub_vec,
long int &length,
float *result_vec)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$sub(
in start_vec: univ vec_$real_vector;
in sub_vec: univ vec_$real_vector;
in length: integer32;
out result_vec: univ vec_$real_vector);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length
call vec_$sub(start_vec, sub_vec, length, result_vec) | [ vec_$sub ] |
| vec_sub_i | subtract single-precision vectors in matrixes
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$sub_i(
float *start_vec,
long int &inc1,
float *sub_vec,
long int &inc2,
long int &length,
float *result_vec,
long int &inc3)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$sub_i(
in start_vec: univ vec_$real_vector;
in inc1: integer32;
in sub_vec: univ vec_$real_vector;
in inc2: integer32;
in length: integer32;
out result_vec: univ vec_$real_vector;
in inc3: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real start_vec(nvec), sub_vec(nvec), result_vec(nvec)
integer*4 length, inc1, inc2, inc3
call vec_$sub_i(start_vec, inc1, sub_vec, inc2,
& length, result_vec, inc3) | [ vec_$sub_i ] |
| vec_sum | sum the elements of a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
float vec_$sum(
float *vec,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$sum(
in vec: univ vec_$real_vector;
in length: integer32): real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vec(nvec), sum
integer*4 length
sum = vec_$sum(vec, length) | [ vec_$sum ] |
| vec_sum_i | sum the elements of a vector in a single-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
float vec_$sum_i(
float *vec,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
function vec_$sum_i(
in vec: univ vec_$real_vector;
in inc: integer32;
in length: integer32): real;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vec(nvec), sum
integer*4 length, inc
sum = vec_$sum_i(vec, inc, length) | [ vec_$sum_i ] |
| vec_swap | swap two single-precision vectors
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$swap(
float *vec1,
float *vec2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$swap(
var vec1: univ vec_$real_vector;
var vec2: univ vec_$real_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vec1(nvec), vec2(nvec)
integer*4 length
call vec_$swap(vec1, vec2, length) | [ vec_$swap ] |
| vec_swap_i | swap two vectors in a single-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$swap_i(
float *vec1,
long int &inc1,
float *vec2,
long int &inc2,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$swap_i(
var vec1: univ vec_$real_vector;
in inc1: integer32;
var vec2: univ vec_$real_vector;
in inc2: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vec1(nvec), vec2(nvec)
integer*4 length, inc1, inc2
call vec_$swap_i(vec1, inc1, vec2, inc2, length) | [ vec_$swap_i ] |
| vec_zero | zero a single-precision vector
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$zero(
float *vector,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$zero(
var vector: univ vec_$real_vector;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector(nvec)
integer*4 length
call vec_$zero(vector, length) | [ vec_$zero ] |
| vec_zero_i | zero a vector in a single-precision matrix
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vec.h>
void vec_$zero_i(
float *vector,
long int &inc,
long int &length)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vec.ins.pas';
procedure vec_$zero_i(
var vector: univ vec_$real_vector;
in inc: integer32;
in length: integer32);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vec.ins.ftn'
parameter (nvec = 10)
real vector(nvec)
integer*4 length, inc
call vec_$zero_i(vector, inc, length) | [ vec_$zero_i ] |
| vfmt_decode10 | formatted read from a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
int vfmt_$decode10(
char *control_string,
char *source_string,
int &source_length,
int *decode_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8, *a9, *a10)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
function vfmt_$decode10(
in control_string: univ vfmt_$string_t;
in source_string: univ vfmt_$string_t;
in source_length: integer;
out decode_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5, a6, a7, a8, a9, a10:
univ vfmt_$generic_unsigned_arg): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 return_value, source_length, decode_count
character control_string*(nchar), source_string*200
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
last = vfmt_$decode10(control_string, source_string, source_length,
& decode_count, status,
& a1, a2, a3, a4, a5,
& a6, a7, a8, a9, a10) | [ vfmt_$decode10 ] |
| vfmt_decode2 | formatted read from a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
int vfmt_$decode2(
char *control_string,
char *source_string,
int &source_length,
int *decode_count,
status_$t *status,
void *a1, *a2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
function vfmt_$decode2(
in control_string: univ vfmt_$string_t;
in source_string: univ vfmt_$string_t;
in source_length: integer;
out decode_count: integer;
out status: status_$t;
var a1, a2: univ vfmt_$generic_unsigned_arg): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 return_value, source_length, decode_count
character control_string*(nchar), source_string*200
integer*4 a1, a2
last = vfmt_$decode2(control_string, source_string, source_length,
& decode_count, status, a1, a2) | [ vfmt_$decode2 ] |
| vfmt_decode5 | formatted read from a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
int vfmt_$decode(
char *control_string,
char *source_string,
int &source_length,
int *decode_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
function vfmt_$decode5(
in control_string: univ vfmt_$string_t;
in source_string: univ vfmt_$string_t;
in source_length: integer;
out decode_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5:
univ vfmt_$generic_unsigned_arg): integer;
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 return_value, source_length, decode_count
character control_string*(nchar), source_string*200
integer*4 a1, a2, a3, a4, a5
last = vfmt_$decode5(control_string, source_string, source_length,
& decode_count, status,
& a1, a2, a3, a4, a5) | [ vfmt_$decode5 ] |
| vfmt_encode | formatted write to a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$encode(
char *control_string,
char *string_buffer,
int &buffer_size,
int *string_length,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$encode(
in control_string: univ vfmt_$string_t ;
out string_buffer: univ vfmt_$string_t;
in buffer_size: integer;
out string_length: integer;
in a1, a2, a3, a4, a5,
a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15,
a16, a17, a18, a19, a20: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 buffer_size, string_length
character control_string*(nchar), string_buffer*200
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11
integer*4 a12, a13, a14, a15, a16, a17, a18, a19, a20
call vfmt_$encode(control_string, string_buffer, buffer_size, string_length,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
& a12, a13, a14, a15, a16, a17, a18, a19, a20) | [ vfmt_$encode ] |
| vfmt_encode10 | formatted write to a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$encode10(
char *control_string,
char *string_buffer,
int &buffer_size,
int *string_length,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$encode10(
in control_string: univ vfmt_$string_t ;
out string_buffer: univ vfmt_$string_t;
in buffer_size: integer;
out string_length: integer;
in a1, a2, a3, a4, a5,
a6, a7, a8, a9, a10: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 buffer_size, string_length
character control_string*(nchar), string_buffer*200
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call vfmt_$encode10(control_string, string_buffer,
& buffer_size, string_length,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) | [ vfmt_$encode10 ] |
| vfmt_encode2 | formatted write to a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$encode2(
char *control_string,
char *string_buffer,
int &buffer_size,
int *string_length,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$encode2(
in control_string: univ vfmt_$string_t ;
out string_buffer: univ vfmt_$string_t;
in buffer_size: integer;
out string_length: integer;
in a1, a2: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 buffer_size, string_length
character control_string*(nchar), string_buffer*200
integer*4 a1, a2
call vfmt_$encode2(control_string, string_buffer,
& buffer_size, string_length,
& a1, a2) | [ vfmt_$encode2 ] |
| vfmt_encode5 | formatted write to a string
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$encode5(
char *control_string,
char *string_buffer,
int &buffer_size,
int *string_length,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$encode5(
in control_string: univ vfmt_$string_t ;
out string_buffer: univ vfmt_$string_t;
in buffer_size: integer;
out string_length: integer;
in a1, a2, a3, a4, a5: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 buffer_size, string_length
character control_string*(nchar), string_buffer*200
integer*4 a1, a2, a3, a4, a5
call vfmt_$encode5(control_string, string_buffer,
& buffer_size, string_length,
& a1, a2, a3, a4, a5) | [ vfmt_$encode5 ] |
| vfmt_intro | variable formatting package
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn' | [ intro ] |
| vfmt_read10 | formatted read from standard input
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$read10(
char *control_string,
int *field_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8, *a9, *a10)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$read10(
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5, a6, a7, a8, a9, a10:
univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 field_count
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call vfmt_$read10(control_string, field_count, status,
& a1, a2, a3, a4, a5,
& a6, a7, a8, a9, a10) | [ vfmt_$read10 ] |
| vfmt_read2 | formatted read from standard input
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$read2(
char *control_string,
short *field_count,
status_$t *status,
void *a1, *a2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$read2(
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2: univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 field_count
character control_string*(nchar)
integer*4 a1, a2
call vfmt_$read2(control_string, field_count, status, a1, a2) | [ vfmt_$read2 ] |
| vfmt_read5 | formatted read from standard input
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$read5(
char *control_string,
int *field_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$read5(
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5: univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 field_count
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5
call vfmt_$read5(control_string, field_count, status,
& a1, a2, a3, a4, a5) | [ vfmt_$read5 ] |
| vfmt_rs10 | formatted read from a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$rs10(
int &stream_id,
char *control_string,
int *field_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8, *a9, *a10)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$rs10(
in stream_id: univ integer;
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5,
a6, a7, a8, a9, a10: univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 stream_id, field_count
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call vfmt_$rs10(stream_id, control_string, field_count, status,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) | [ vfmt_$rs10 ] |
| vfmt_rs2 | formatted read from a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$rs2(
int &stream_id,
char *control_string,
int *field_count,
status_$t *status,
void *a1, *a2)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$rs2(
in stream_id: univ integer;
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2: univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 stream_id, field_count
character control_string*(nchar)
integer*4 a1, a2
call vfmt_$rs2(stream_id, control_string, field_count, status,
& a1, a2) | [ vfmt_$rs2 ] |
| vfmt_rs5 | formatted read from a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$rs5(
int &stream_id,
char *control_string,
int *field_count,
status_$t *status,
void *a1, *a2, *a3, *a4, *a5)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$rs5(
in stream_id: univ integer;
in control_string: univ vfmt_$string_t;
out field_count: integer;
out status: status_$t;
var a1, a2, a3, a4, a5: univ vfmt_$generic_unsigned_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*4 status
integer*2 stream_id, field_count
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5
call vfmt_$rs5(stream_id, control_string, field_count, status,
& a1, a2, a3, a4, a5) | [ vfmt_$rs5 ] |
| vfmt_write | formatted write to standard output
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$write(
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$write(
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20:
univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11
integer*4 a12, a13, a14, a15, a16, a17, a18, a19, a20
call vfmt_$write10(control_string,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
& a12, a13, a14, a15, a16, a17, a18, a19, a20) | [ vfmt_$write ] |
| vfmt_write10 | formatted write to standard output
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$write10(
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$write10(
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5, a6, a7, a8, a9, a10:
univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call vfmt_$write10(control_string,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) | [ vfmt_$write10 ] |
| vfmt_write2 | formatted write to standard output
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$write2(
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$write2(
in control_string: univ vfmt_$string_t;
in a1, a2: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
character control_string*(nchar)
integer*4 a1, a2
call vfmt_$write2(control_string, a1, a2) | [ vfmt_$write2 ] |
| vfmt_write5 | formatted write to standard output
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$write5(
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$write5(
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5
call vfmt_$write5(control_string, a1, a2, a3, a4, a5) | [ vfmt_$write5 ] |
| vfmt_ws | formatted write to a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$ws(
ios_$id_t &stream_id,
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$ws(
in stream_id: ios_$id_t;
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20:
univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 stream_id
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11
integer*4 a12, a13, a14, a15, a16, a17, a18, a19, a20
call vfmt_$ws(stream_id, control_string,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
& a12, a13, a14, a15, a16, a17, a18, a19, a20) | [ vfmt_$ws ] |
| vfmt_ws10 | formatted write to a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$ws10(
ios_$id_t &stream_id,
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$ws10(
in stream_id: ios_$id_t;
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5, a6, a7, a8, a9, a10:
univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 stream_id
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
call vfmt_$ws10(stream_id, control_string,
& a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) | [ vfmt_$ws10 ] |
| vfmt_ws2 | formatted write to a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$ws2(
ios_$id_t &stream_id,
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$ws2(
in stream_id: ios_$id_t;
in control_string: univ vfmt_$string_t;
in a1, a2: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 stream_id
character control_string*(nchar)
integer*4 a1, a2
call vfmt_$ws2(stream_id, control_string, a1, a2) | [ vfmt_$ws2 ] |
| vfmt_ws5 | formatted write to a stream
SYNOPSIS (C)
#include <apollo/base.h>
#include <apollo/vfmt.h>
void vfmt_$ws5(
ios_$id_t &stream_id,
char *control_string,
...)
SYNOPSIS (Pascal)
%include '/sys/ins/base.ins.pas';
%include '/sys/ins/vfmt.ins.pas';
procedure vfmt_$ws5(
in stream_id: ios_$id_t;
in control_string: univ vfmt_$string_t;
in a1, a2, a3, a4, a5: univ vfmt_$generic_signed_arg);
SYNOPSIS (FORTRAN)
%include '/sys/ins/base.ins.ftn'
%include '/sys/ins/vfmt.ins.ftn'
integer*2 nchar
parameter (nchar = 128)
integer*2 stream_id
character control_string*(nchar)
integer*4 a1, a2, a3, a4, a5
call vfmt_$ws5(stream_id, control_string, a1, a2, a3, a4, a5) | [ vfmt_$ws5 ] |