Introduction to AIM Baseline Routines

The routine dictionary pages describe the functions and calling sequences of routines contained in the AIM Base Package. These routines may be called by application software written by a system customizer. The routines used by the database manager are detailed in Database Management Library Programs.

Documentation Conventions

The dictionary page for each routine contains the following sections, as applicable:

The format of a V+  instruction for the routine is shown.

NOTE: The variable names used for the routine parameters are for explanation purposes only. Your application program can use any variable names you want when calling the routine.

NOTE: Some calling sequences will not fit on a single line and are shown on two lines. However, all calling sequences must be entered on a single line in V+programs.

Function

This is a brief statement of the function of the routine.

Usage Considerations

This section is used to point out any special considerations associated with use of the routine.

Input Parameters

Each of the input parameters in the calling sequence is described in detail. For parameters that have a restriction on their acceptable values, the restriction is specified.

Each of the output parameters in the calling sequence is described in detail.

Global Variables

Global variables accessed by the routine are described.

Details

A complete description of the routine and its use is given.

Related Routines

This section provides links to other AIM routines which are related to the function of the current routine.

ai.add.opt.name ($name)

ai.attach.dlun (lun, $dev)

ai.attach.dlun2 (lun, $dev, stt)

ai.cpy.rn.ctl (ti, rn.index, ai.index)

ai.db.define (type, $px, $icon, icon, $file, run, $type,$undef, $bname, halt)

ai.db.shared (type, $file, irwmode, n.recs, db, $cmd)

ai.db.to.gtype (db, type)

ai.db.to.type (db, type)

ai.dev.define (device, $name, incpu, robot, halt)

ai.find.device (device, ti, task, robot, status)

ai.find.task.i (incpu, task, ti, status)

ai.get.rn.ctl (ti, index, value)

ai.hlp.open (mode, $file, $topic, $window, status)

ai.key.add ($key[],$str,data)

ai.key.find ($key[], $str, lower, upper, data, index)

ai.key.find.num ($key[], value, lower, upper, $str, index)

ai.key.get ($key[], index, $str, data)

ai.key.info ($key[], num, last)

ai.key.new ($key[])

ai.key.sort ($key[])

ai.key.sort.num ($key[])

ai.load.icon ($file, halt)

ai.load.init ($file, optional, okay, halt)

ai.load.opt (mode, $file, $routine, optional, okay, halt)

ai.log.get (msg[], $msg, status)

ai.mul.add (type, $file, order, optional, okay, halt)

ai.set.ctl (index, value)

ai.set.rn.ctl (ti, index, value)

ai.task.define (opcpu, task, $name, $device, sched, ti, halt)

ai.task.info (ti, info[], status)

ai.task.prior (s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11 ,s12, s13, s14, s15, p[])

ai.task.start (ti, task.num, $routine, prior[], halt, $cmd)

ai.task.teach (ti, $rtn, db, record, field, index, $args, $reply status)

ai.type.to.db (type, db, task)

call (args[], error)

case (args[], error)

close_log (args[], error)

cu.cs.define ()

cu.cv.define ()

cu.def.link ()

cu.define.dbs (halt)

cu.error.notify (ti, level, error.number, error.qualifier, $message)

cu.event.filter($cmd)

cu.pg.keypress(arg, mode, db.p, lun, luns[], $cmd)

cu.initialize ()

cu.initialize2 (halt)

cu.module.init (halt)

cu.mu.reacte (error.number, error.qualifier, $cmd)

cu.reacte (error.number, error.qualifier, error.type)

cu.sched.start (error)

cu.sched.stop ()

cu.set.mode (ti, mode)

cu.se.message.html

cu.shutdown ()

cu.sig.define ()

cu.ss.analysis (event, idx1, idx2, idxt, bin, ptr, value)

cu.startup ($cmd)

cu.task.init (task, gad, robot, device)

dv.cli.abort (dv.id, msg.id, status)

dv.cli.connect (ti, dv.id, status)

dv.cli.init (reply.num,task)

dv.cli.reply (dv.id, msg.id, $reply, status)

dv.cli.send (dv.id, func, qual, $data, msg.id, status)

dv.srv.connect (req.num, status)

dv.srv.disable (status)

dv.srv.enable (status)

dv.srv.recv ($msg, func, qual, $data, status)

dv.srv.reply ($msg, $data, status)

else (args[], error)

end (args[], error)

er.error (error, vcode, index, color, $err)

ex.control (ti, display, function, arg1, arg2, $str, status)

ex.mu.status (arg, mode, db.p, lun, luns[], $cmd)

ex.panel.sig (signal, function, arg, halt)

ex.stat.assign (ti, func, qual, index, filter, status)

exit_loop (args[], error)

for (args[], error)

if (args[], error)

io (args[], error)

io.close.done (stream, status)

io.get.esc.seq($cmd, cmd, $ecmd)

io.open.done (stream, status, lun)

io.post.cmd (task, $cmd)

io.pul.dwn.evt (menu, $list, $entry, key, int1, int2, int3, acc, norun, index)

io.pul.dwn.sfg (menu, index, flags)

io.pul.dwn.spw (menu, $list, $entry, key, $name, $file, idbty, irec, iacc, inorun, index)

io.read.done (stream, status, count, $data[])

io.working (mode, mess)

io.write.done (stream, status)

io_close (args[], error)

io_list (args[], error)

io_open (args[], error)

io_read (args[], error)

io_write (args[], error)

ld.asn.mod ($name, status)

ld.asn.seq ($name, status)

ld.asn.seqn (seqnum, status)

ld.dea.mod (status)

ld.dea.seq (status)

ld.def.grp (n.group, d.db.1, d.db.2, d.db.3, d.db.4)

ld.def.type (d.db, n.db)

ld.find.grp ($name, m.idx, $db.name[ ], d.db[ ], db[ ], status)

ld.get.mod.name (mod, $modname)

ld.get.mod.seq ($modname, $seqname)

ld.get.modid (cpu, task, mod)

ld.get.seqinfo (modid, seqnum, $seq, seqdb, status)

ld.load ($name, d.db, load, related, status)

ld.load.mod ($name, mod, status)

ld.lookup ($modname, $seqname, mod, seqnum, seqdb, status)

ld.lookup.type ($modname, type, $name, db, $path, $file, status)

ld.mod.member (db, mod)

ld.test ($name, d.db, db)

ld.unload.mod (opmod, status)

lk.define (lnk.ty, lnk.n.f, lnk.l.f, lnk.f.i, srch.ty, srch.f, req, ebit)

lk.link.1.field (db, key.fld, index, status)

lk.link.1.rec (db, status)

lk.link.mod ($modname, mes, warning, error, abort)

load (args[], error)

message (args[], error)

mu.get.vname (m.db, $name)

mu.menu ($page, $file, db.p, $cmd)

mu.graph.coord(st[], x, y, px, py)

mu.graph.setup(df[], $title, $xlabel, $ylabel, $usr.rtn

mu.graph.redraw($name)

mu.graph.refresh($name)

mu.popup.error ($err, sev, $cmd)

mu.set.goto (func, mode, $page, $file, type, rec, acc, norun, $cmd)

mu.set.rtrv (type, rec, field, index, $cmd)

next_loop (args[],error)

pause_task (args[],error)

pe.attach (status)

pe.disp.msg (code)

pr.prep.app (max.index, db[], show.mes, error, abort)

repeat (args[], error)

resume_task (args[], error)

return (args[], error)

rn.check (response, error)

rn.check.pause (resp, type, error)

rn.cli.connect (ti, tmo, optional, dv.id, error)

rn.cli.reply (dv.id, msg.id, mode, $reply, error)

rn.cli.send (dv.id, func, qual, $data, mode, msg.id, $reply, error)

rn.error (error, response, code, $suffix, database, record, field, index)

rn.error.resp (proc, retry, skip, retry.stmt, skip.stmt, skip.seq, abort)

rn.exp.eval (args[], arg1, argn, value, error)

rn.get.a.num (db, field, first, count, index, number[], error)

rn.get.a.nums (db, field, first, count, index, number[ ], error)

rn.get.a.str (db, field, first, count, index, $string[ ], error)

rn.get.num (db, field, index, number, error)

rn.get.str (db, field, index, $string, error)

rn.get.trans (db, field, index, trans, error)

rn.get.va.name (arg, arg.index, optional, $value, error)

rn.get.va.num (arg, optional, value, error)

rn.get.va.str (arg, arg.index, optional, $value, error)

rn.message (code, $suffix, database, record, field, index)

rn.open.p.rec (db, record, error)

rn.open.rec (db, record, error)

rn.put.trans (db, field, index, trans, error)

rn.put.va.num (arg, optional, value, error)

rn.put.va.str (arg, optional, $value, error)

rn.resp.rest (resp[])

rn.resp.save (resp[])

rn.sched

rn.sched.init

rn.sched.start (error)

rn.send.menu ($cmd, status)

rn.seq.exec (seqnum, cycles, dflags, ctl[], error)

rn.signal.out (signal, pulse, error)

rn.signal.test (signal, error, value)

rn.signal.wait (signal, error)

rn.srv.reply ($msg, $data, error)

rn.status.num (idx1, num1, idx2, num2, idx3, num3, idx4, num4)

rn.status.str (index, $msg)

rn.wait.idle (error)

rn.wait.time (time, error)

rn.walk.train (db, field, index, status, error)

select_task (args[], error)

select_var_rec (args[], error)

send_data_to (args[], error)

send_label_to (args[], error)

set (args[], error)

set_response (args[], error)

setup_log (args[], error)

start_task (args[], error)

stop_task (args[], error)

unload (args[], error)

va.del.value (arg, mod, status)

user.graph.rtn(mode, df[], st[], $df[], data[,], $cmd)

va.find.rec (db.p, $varname, $seqname, cur.rec, rec, status)

va.get.info (db, rec, flags, read_write, string, poll, status)

va.get.num (arg, mod, value, status)

va.get.rec (arg, db, rec)

va.get.str (arg, mod, $value, status)

va.get.value (arg, mod, value, $value, status)

va.num.find ($instr, ftype, mod, $seqname, value, db, rec, status)

va.put.num (arg, mod, value, status)

va.put.str (arg, mod, $value, status)

value (args[], error)

wait (args[], error)

wait_for (args[], error)

wait_until (args[], error)

while (args[], error)