Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
transpec(file format)					 transpec(file format)

Name
       transpec	- translation specification for	instant

Synopsis
       file.ts

Description
       The  transpec  file is used by the instant program to translate an SGML
       document	instance to a format suitable for  a  formatting  application.
       The convention is to name the file with the suffix .ts.

       A  transpec  file  is  composed	of  a number of	individual translation
       specs.  Each translation	spec (transpec)	is made	 up  of	 a  number  of
       fields, one per line.  Translation specs	are separated by a line	with a
       leading	dash.  Text after the dash is ignored.	Fields are composed of
       two parts, a name and a value, separated	by a colon.   The  colon  must
       immediately  follow  the	name, and any amount of	whitespace (blanks and
       tabs) may be present between the	colon and value.  Values should	not be
       quoted, and you should be careful of trailing spaces.  (Trailing	 space
       will be considered part of the value.)  Quotes, if they appear, will be
       considered  part	 of  the  value	 of the	fields.	 Lines that begin with
       whitespace (blanks and tabs) are	a continuation of the  previous	 line;
       the  leading  space is ignored.	These characteristics are very similar
       to those	of e-mail headers.  Lines beginning with a # (number sign) are
       comments	and blank lines	are ignored.

Field Descriptions
       Some fields are for identifying criteria	that determines	if a  particu-
       lar  spec  matches an element in	the instance.  Others specify what ac-
       tion is to take place when a match happens, such	as sending text	to the
       output stream.

   Criteria fields
       Criteria	fields restrict	the conditions under which a  single  transla-
       tion spec will apply.  If each field specified in a particular transpec
       matches	an  element under consideration	in the document	instance, then
       that translation	spec is	said to	match.	The  appropriate  actions,  as
       specified in that spec, are then	taken.	The program, instant, searches
       the  list  of transpecs in the order given in the file.	Therefore, the
       more restrictive	specs (those with more criteria) should	appear	before
       less restrictive	ones.

       For  quick  reference, this is a	brief summary of the possible criteria
       fields for translation. A complete discussion of	each follows.

       Field Label   Field Value	Description
       GI	     gi	...		name of	this GI
       AttValue	     attname reg-expr	current	element	has attribute with value
       Content	     reg-expr		is reg-expr in char content>
       Context	     context		element	context, up the	tree
       NthChild	     number		current	element	is Nth child of	its parent
       PAttSet	     attname (val)	parent has this	attribute set (optional	to value val)
       Relation	     relationship gi	gi has relationship to current element
       VarREValue    var REvalue	variable is set	to regular expression value
       VarValue	     var value		variable is set	to value

       GI: gi [...]
	      gi is the	name of	the generic identifier,	or  element  name,  to
	      consider.	 More than one GI may appear in	this field.

       AttValue: attname regular-expression
	      This  is	an  attribute name-value pair, where attname is	an at-
	      tribute if the GI.  The regular-expression is of	the  form  ac-
	      cepted  by the unix program egrep.  This pair is compared	to the
	      corresponding attribute name-value pairs of the GI under consid-
	      eration.	To simply test if an attribute us set, use .  (a  dot)
	      for  regular-expression.	 There	may  be	more than one of these
	      lines for	each transpec.

       Content:	regular-expression
	      This specifies that the  character  content  of  GI  contains  a
	      string matching the regular-expression.

       Context:	context
	      This  specifies  the  context in which to	apply this translation
	      spec.  It	is either a list of generic identifiers	or  a  regular
	      expression  describing a list of generic identifiers, looking up
	      the hierarchy.  The first	is the parent of the GI.

       NthChild: number
	      This specifies that the GI is the	numberth child element of  its
	      parent.	Children  are numbered starting	with 1.	 Negative num-
	      bers may be used to indicate order counting backwards.  For  ex-
	      ample, -1	denotes	the last child.

       PAttSet:	attname
	      This  specifies that the parent has this attribute, attname, set
	      to any value (not	IMPLIED).  A value to match may	optionally  be
	      specified	after attname.

       Relation: relationship gi
	      This  specifies that the current element has the relationship to
	      the named	gi.  The acceptable relationships are: ancestor	 (any-
	      where  up	 the  tree), child (immediate child), descendant (any-
	      where down  the  tree),  parent  (immediate  ancestor),  sibling
	      (share  same parent element), sibling+ (any later	sibling), sib-
	      ling+1 (the immediately following	sibling), sibling-  (any  ear-
	      lier sibling), sibling-1 (the immediately	following sibling).

       VarREValue: varname REvalue
	      This  specifies  that  the global	variable varname has the value
	      REvalue, where REvalue is	a regular expression (see the VarValue
	      statement).

       VarValue: varname value
	      This specifies that the global variable varname  has  the	 (lit-
	      eral) value value	(see the VarREValue statement).

       There are two special GIs.  If specified, _Start	and _End are processed
       as  if they were	GIs in the instance at the start and end of the	trans-
       lation, respectively.  Their criteria are never	checked.   Only	 their
       actions are performed.

   Action fields
       For  quick  reference, this is a	brief summary of the action fields for
       translation. They are only performed if all the criteria	are satisfied.
       A complete discussion of	each follows.

       Field Label   Field Value   Description
       Action	     spec-id	   use transpec	whose spec ID is `spec-id'
       EndText	     text	   text	for end	of element
       Increment     name	   increment variable `name'
       Ignore	     key	   flag	for ignoring element's children	and/or data
       Message	     text	   text	to send	to stderr
       Quit	     text	   print text and quit program
       Replace	     text	   replace this	subtree	with text
       Set	     name value	   set variable	name to	value
       SpecID	     spec-id	   unique Spec ID (int)	of this	spec
       StartText     text	   text	for start of element

       Action: spec-id
	      Use the actions of the spec identified by	the SpecID with	match-
	      ing identifier spec-id.

       EndText:	text
	      This specifies text to be	output when the	end tag	is processed.

       Ignore: key
	      This specifies that the data or children for this	element	are to
	      be ignored.  Set key to all to  ignore  the  element  (data  and
	      child  elements),	to data	to ignore the immediate	character data
	      content (child elements are still	descended into), and to	 chil-
	      dren to process the immediate character data content but not de-
	      scended  into  child  elements.  Other actions specified in this
	      transpec are still performed, however.

       Increment: name
	      This is used to increment	a variable whose value	is  a  number.
	      If  the  variable	is not a number, no action will	be taken.  The
	      variable must have been previously defined.  This	action is done
	      immediately before EndText.  There may be	more than one of these
	      lines for	each transpec.

       Message:	text
	      This specifies a string to be printed to the standard error when
	      the matching element is processed.  It is	intended for informing
	      the user of the progress of the translation.  It	is  also  used
	      for  validation  of instances (see the -v	flag of	instant(1)); a
	      spec would be written to recognize a construct that is  not  al-
	      lowed.   This  action is done immediately	after StartText.  Mes-
	      sages are	also useful for	debugging spec files; one is  able  to
	      easily  tell  when a matching spec is processed, without looking
	      at the actual output of the translation.	 Note  that  the  spec
	      writer  is  responsible for putting newlines (\n)	in the message
	      text.

       Replace:	text
	      This specifies text to replace the current subtree  with.	  This
	      is equivalent to StartText and Ignore.

       Quit: text
	      This  specifies  text  to	be printed to the standard error.  The
	      program then terminates with exit	status 1.   This  is  intended
	      for  bailing  out	 when  an  undesirable instance	is encountered
	      (such as when it is known	that the  formatting  application  can
	      never handle a class of components, like tables).

       Set: name value
	      This  is	used to	set a variable whose name is name and value is
	      value.  Names that would be valid	for GIs	in  the	 document  in-
	      stance  are  valid for variable names.  value is the rest	of the
	      line and may be any string.   This action	 is  done  immediately
	      before  EndText.	 There may be more than	one of these lines for
	      each transpec.  See the discussion on variables below.

       SpecID: spec-id
	      This names the spec with the number spec-id. Other specs may re-
	      fer to this one by this number by	an Action field	or an  _action
	      special variable.	 This is used for cases	where several specs to
	      perform the exact	same action.

       StartText: text
	      This  specifies  text  to	 be  output  when  the	start  tag  is
	      processed.

   Other Fields
       These fields may	appear anywhere.  The action occurs when the  transla-
       tion spec file is read, before any elements are translated.  Theses are
       independent of any element processing.

       Var: name value
	      This  is	used to	define a variable whose	name is	name and value
	      is value.	 It is similar to Set, but it may  occur  anywhere  in
	      the file and takes effect	when the spec file is read.

   Text	Strings
       The  text  referred  to in the StartText, EndText, Replace, and Message
       actions is more than simple character strings.  Special sequences allow
       more complex output.

       One type	of special sequence is for C-style  string  processing.	  Most
       special characters are escaped with a \ (backslash). Like in C or shell
       programs,  to  print  a	\ (backslash), you must	escape it with another
       backslash. These	special	character strings are:

       \n (backslash-n)
	      This specifies that a newline character is to be printed to  the
	      output stream.

       \r (backslash-r)
	      This specifies that a carriage return character is to be printed
	      to the output stream.

       \t (backslash-t)
	      This specifies that a tab	character is to	be printed to the out-
	      put stream.

       \s (backslash-s)
	      This  specifies  that  a	space  is  to be printed to the	output
	      stream.  This is useful for the end of a transpec	line, where it
	      can be difficult to tell if a blank is present at	the end.

       \007 (backslash-007)
	      This specifies that the character	whose octal value is 007 is to
	      be printed to the	output stream.	This works for any octal char-
	      acter value.

       ^ (caret)
	      This specifies the that position in the string will  be  at  the
	      start of a line in the output stream.

       If  the first token of the text string is #include, then	the second to-
       ken is taken to be a file name and that file is included.  If the  file
       is  not	found, the library directory, as mentioned above, is searched.
       If the text string starts with a	! (exclamation point), the rest	of the
       line is taken to	be a command and the output of	that  command  is  in-
       serted.

       An  element's attributes	may also be used in the	text of	output fields.
       To use an attribute value, precede its name with	a ${ (dollar sign-left
       curly bracket) and follow it with a }  (right  curly  bracket).	 (This
       style  is followed by the Bourne	shell.)	 For example, ${TYPE}.	If the
       attribute is not	set (not IMPLIED), nothing will	be printed to the out-
       put stream.  To specify a value to use if the  attribute	 is  not  set,
       place the value after the attribute name, separated by a	space.	To re-
       turn  the attribute value in lower-case,	add a colon followed by	lower-
       case l (${TYPE:l}.

Variables
       Variables in instant are	similar	to those in many other string-oriented
       programming languages, such as sh and awk.  They	are set	by: Var:  name
       value  and Set: name value.  Values may be set and reset	to any string.
       In a Var	line, if the value begins with a !, then the rest of the  line
       is executed as a	command, and its output	is taken as the	value.

       A  reference  to	 the  value of a variable follows the same syntax as a
       reference to the	value of an attribute:	${name}.  If that variable has
       not been	defined, a null	value will be returned.	 A default  value  can
       be  returned  instead  of  null	for an undefined variable by using the
       form:  ${name default}.

       Variables may be	used as	attributes are,	that is	in  any	 of  the  text
       strings	mentioned above.  In fact, if an attribute name	is referred to
       and it is not set for a given element, instant  looks  for  a  variable
       with  the same name.  This way global defaults can be set.  If you want
       to be sure that you are accessing a local variable value,  not  an  at-
       tribute value, you can use lower	or mixed case names.  Attribute	names,
       as passed by sgmls, are in upper	case.

       Any  number  of Var actions may appear in the spec file.	 These set the
       values of the variables before any translation takes  place.   The  Set
       actions within transpecs	are performed when that	spec is	processed when
       an element matches the given criteria.

   Preset Variables
       Several	variables  are	preset	by  instant upon start of the program.
       Their values may	be overridden in transpec  files  or  on  the  command
       line.

       date   This  is	the date and time that the program started. The	format
	      is: Tue 10 Aug 1993, 16:52.

       host   This is the name of the host where the program is	 run.	It  is
	      what is returned by the gethostname library call.

       transpec
	      This is the translation spec filename.

       user   This is the login	name of	the user running the program.

   Special Variables
       There  is  a  collection	of special variables called special variables.
       These are identified by starting	the names with a _ (underscore).  This
       is a summary of the special variables.  A complete discussion  of  each
       special	variable  follows.   spec-id refers to a number	specified in a
       SpecID field.  When used	in a special variable, it means	to perform the
       action in that translation spec.

       Note that when a	spec-id	is given in a special variable,	the default is
       to perform the translation spec named by	the spec-id  ignoring  of  any
       criteria	statements found there.	 For most special variables that use a
       spec-id,	postpending a "t" to the spec-id (with no spaces between them,
       eg,  "${_followrel  child  TITLE	15t}"),	will cause the criteria	state-
       ments in	the named translation spec  to	evaluate  successfully	before
       that translation	spec will be processed.

       Variable	Usage			     Description
       _action spec-id			     do	spec with id spec-id
       _allatts				     print all attribute/value pairs
       _attval att [value] spec-id	     use spec-id if attribute matches
       _chasetogi gi spec-id		     follow IDREFs until gi found
       _eachatt	att spec-id [spec-id]	     do	spec-id	for each word of attribute value
       _eachcon	spec-id	[spec-id]	     do	spec-id	for each word of content
       _env env-variable		     return value of env variable
       _filename			     filename of notation
       _find rel gi spec-id		     find gi based on relationship
       _followlink [attname] spec-id	     follow IDREFs [attname] and use spec-id
       _followrel rel gi spec-id [spec-id]   do	spec-id	on rel if it matches
       _gi [M|L|U]			     return GI name; M,	L, U case
       _id id [spec-id]			     find element with ID and use spec-id
       _include	filename		     insert file here
       _infile [line]			     instance filename [and line number]
       _insertnode S|E spec-id		     do	spec-id	when element is	traversed
       _isset var [value] spec-id	     do	spec-id	if variable matches
       _location			     print location of current element
       _namelist spec-id [spec-id]	     content is	namelist, do spec-id for each
       _nchild [gi]			     number of child elements [named attname]
       _osftable format	[flag]		     print table format	specification
       _path				     print path	to current element
       _pattr attname			     value of parent's attribute
       _pfind args ...			     same as _find, but	start at parent
       _relation rel gi	spec-id	[spec-id]    do	spec-id	if relation matches
       _set var	value			     set variable to value
       _!command			     command to	run

       _action spec-id
	      Use the actions of the spec identified by	the SpecID with	match-
	      ing  identifier  spec-id.	  This behaves similarly to the	Action
	      action, but is in	addition to the	present	translation spec.

       _allatts
	      Print all	attribute name-value pairs of the current  element  to
	      the  output  stream.   The  name	and value are separated	by a =
	      (equals sign), and the value is surrounded by quotes.  This  can
	      be useful	for creating a normalized version of the instance.

       _attval attname [value] spec-id
	      If  the  current element has an attribute	named attname, option-
	      ally whose value matches value, use the actions of the  transpec
	      identified by spec-id.

       _chasetogi gi spec-id
	      Follow IDREF attributes until if finds an	element	whose GI is gi
	      or  which	 has  a	child element with that	GI.  It	will apply the
	      transpec spec-id to that element.	 By default,  instant  assumes
	      the  attributes  named  LINKEND, LINKENDS, and IDREF are of type
	      IDREF or IDREFS.	(This corresponds with the OSF DTDs.)  You can
	      change this by setting the variable link_atts to	a  space-sepa-
	      rated list of attribute names.

       _eachatt	att spec-id [spec-id2]
	      The  transpec  named  by	spec-id	 is invoked once per each word
	      found in the value of the	 attribute  att.   Inside  the	target
	      transpec,	 the  current word being processed is available	in the
	      variable named each_A (${each_A}).  If spec-id2 is specified, it
	      will use spec-id for the first word in the attribute  and	 spec-
	      id2 for the others.

       _eachcon	spec-id	[spec-id2]
	      The  transpec  named  by	spec-id	 is invoked once per each word
	      found in the content of the current element.  Inside the	target
	      transpec,	 the  current word being processed is available	in the
	      variable named each_C (${each_C}).  If spec-id2 is specified, it
	      will use spec-id for the first word in the content and  spec-id2
	      for the others.

       _env env-variable
	      Print  the value of the environment variable env-variable	to the
	      output stream.

       _filename
	      Print the	filename of the	notation associated with this element,
	      if any.  This is used to get the filename	of an  external	 nota-
	      tion  entity  reference.	 For example, to print the filename in
	      the latex	 macro	from  the  epsf	 macro	package,  use  \\epsf-
	      boxi{${_filename}}.

       _find [top] relationship	args ... spec-id
	      Descend  the  document hierarchy finding elements	that match one
	      of several criteria.  When one is	found, the action specified by
	      spec-id is performed.  If	top is specified, the search starts at
	      the top of the document hierarchy, rather	than  at  the  current
	      element.	 The  possible values for relationship are gi, gi-par-
	      ent, parent, and attr, and take different	 arguments.   Explana-
	      tions may	be best	done by	example: _find gi CHAPTER 123 means to
	      find elements whose GI is	CHAPTER, and perform action 123; _find
	      gi-parent	 TITLE	CHAPTER	124 means to find elements whose GI is
	      TITLE and	whose parent is	CHAPTER, and perform action 124; _find
	      parent BODY 125 means to find  elements  whose  parent's	GI  is
	      BODY,  and perform action	125; _find attr	TYPE UGLY 125 means to
	      find elements whose attribute named TYPE is  set	to  UGLY,  and
	      perform action 126.

       _followlink [attname] spec-id
	      When  processing	an  element, instant will follow the IDREF at-
	      tributes until an	element	with no	IDREF attributes is found.  It
	      will then	apply the transpec specified by	spec-id	to  that  ele-
	      ment.   If  specified, it	will follow the	link pointed to	by at-
	      tname.  By default, instant assumes the attributes named LINKEND
	      and LINKENDS are if type IDREF or	IDREFS.	 You can  change  this
	      by  setting  the variable	link_atts to a space-separated list of
	      attribute	names.

       _followrel relationship gi spec-id [spec-id2]
	      If the gi	has the	specified relationship to the current element,
	      perform the action specified by spec-id on the related  element.
	      If  the  relationship  to	 gi  does  not	exist, and spec-id2 is
	      present, perform spec-id2	on the current element.	 See the  dis-
	      cussion  of the criteria field Relation for acceptable relation-
	      ship names.

       _gi [M|L|U]
	      Print the	name of	the current GI to the output stream.  If spec-
	      ified, M,	L, or U	will ensure the	GI name	is printed  in	mixed,
	      lower, or	upper case, respectively.

       _id id [spec-id]
	      Find  the	 element with id and use spec-id, if set.  If not set,
	      use the spec for that element's context.

       _include	filename
	      Insert the file filename into the	output stream.

       _infile [line]
	      Print the	name of	the sgml instance file to the  output  stream.
	      If  line is specified, also print	the line number.  This depends
	      on sgmls being called with the -l	option.

       _insertnode S|E spec-id
	      Do spec-id when the current element  is  traversed  at  a	 later
	      pass.  This can be considered inserting a	node, without content,
	      into the hierarchy.  This	is only	useful if done to elements be-
	      fore they	are processed.	Typically _chasetogi or	_followlink is
	      specified	 early	in  an instance's processing, so that when the
	      elements found by	one of these actions are  processed  in	 their
	      turn,  the  added	 actions  are performed.  _insertnode would be
	      specified	as the action of a spec-id pointed to in a  _chasetogi
	      or _followlink usage.

       _location
	      The  location  of	 the  current element is printed to the	output
	      stream in	several	ways: the path to the element (see  _path),  a
	      position	hint,  which is	the nearest title, the line number, if
	      the ESIS (output from sgmls) contains line numbers, and  the  ID
	      of  the  element,	if it has one.	This is	especially useful when
	      using the	Message	action to validate an instance.

       _namelist spec-id [spec-id2]
	      This assumes that	the  content  of  the  current	element	 is  a
	      namelist	(a  list of element IDs), and applies the action based
	      on spec-id for each element pointed to.  If spec-id2  is	speci-
	      fied,  it	 will use spec-id for the first	ID in the namelist and
	      spec-id2 for the others.

       _nchild [gi]
	      Print the	number of child	elements of the	element	to the	output
	      stream.	If  gi is specified, print the number of child element
	      with that	name.

       _osftable tex|tbl|check [flag]
	      Print table markup into the output stream.  The  format  depends
	      on  whether  tex	or  tbl	 is specified.	The flag may be	one of
	      cellstart, cellend, rowstart, rowend, top, or bottom.  The value
	      determines what markup or	text will be generated.	 If  cellstart
	      is  specified, the correct markup	for the	beginning of a cell is
	      output.  If top, bottom, or rowend are  specified,  the  correct
	      markup for the end of the	appropriate position is	printed	to the
	      output  stream.  If check	is specified, the attributes and child
	      elements are checked for errors and consistency.

       _path  Print the	path to	current	GI to the output stream.   A  path  is
	      each  element,  going down the tree from the topmost element.  A
	      number in	parentheses after each element name shows which	 child
	      element  the  next one is	in the order of	children for that ele-
	      ment.  Ordering starts at	0.  For	example:  OSF-BOOK(3)  BODY(0)
	      CHAPTER(4)  SECTION.   This  says	the path is <OSF-BOOK>'s third
	      child, <BODY>'s zeroth, and <CHAPTER>'s fourth, which  is	 named
	      <SECTION>.

       _pattr name
	      Print  the value of parent's attribute whose name	is name	to the
	      output stream.

       _pfind rel gi spec-id
	      This is exactly the same as _find	except that the	search	starts
	      at the current element's parent.

       _relation relationship gi spec-id [spec-id2]
	      If the gi	has the	specified relationship to the current element,
	      perform  the action specified by spec-id on the current element.
	      If the relationship test fails and spec-id2 is  specified,  per-
	      form  that action.  See the discussion of	the criteria field Re-
	      lation for acceptable relationship names.

       _set varname value
	      Set the value of the variable varname to value.

       _isset varname [value] spec-id
	      If the value of the variable varname is set to value, then  per-
	      form  action referred to by spec-id.  If value is	not specified,
	      action will be performed if varname is set to any	value.

       _! command
	      Run the command command, directing its standard output into  the
	      output stream.

   Immediate Variables
       Immediate  variables  are  like special variables, except that they are
       expanded	when the transpec is originally	processed  (special  variables
       are  processed  later,  near when the final output is being generated).
       The  general  syntax  of	 immediate  variables  is   ${+immediate_vari-
       able ...}.

       There is	currently only one immediate variable defined:

       +content
	      This  special  variable  is  replaced by the data	content	of the
	      current element.

Examples
       The following will output the given string for elements	whose  generic
       identifier  is P	(for paragraph).  At the start of processing this ele-
       ment, the program ensures that the output starts	on  a  new  line,  the
       troff macro <.P>	is output, then	a newline.  At the end of this element
       processing, the program ensures that the	output starts on a new line.
       GI:	       P
       StartText:      ^.P^
       EndText:	       ^
       -

       The  following  will output the given string for	elements whose generic
       identifier is CMD-ARGUMENT and which have an attribute PRESENCE set  to
       the value OPTIONAL.
       GI:	       CMD-ARGUMENT
       AttValue:       PRESENCE	OPTIONAL
       StartText:      $\\[
       EndText:	       $\\]
       -

       The  following prints the section number, title,	and page number	of the
       target of a cross reference.  Assume the	cross reference	 points	 to  a
       section element,	which contains a title element.	 The criteria for this
       spec  to	 match	is that	the attribute OSFROLE is set to	the value get-
       full.  The action is to replace the content of the <XREF> element  with
       the  given string.  When	processing the string, instant will follow the
       IDREF attributes	of <XREF> until	an element with	no IDREF attributes is
       found. It will then apply the transpec numbered	87  to	that  element,
       which  will  print  the	name  of  the GI in mixed case into the	output
       stream.	It will	then print the LaTeX reference	instruction  with  the
       value  of  the LINKEND attribute	as an argument.	 (This will become the
       section number after processing by LaTeX.)  It will then	follow	IDREFs
       until  if  finds	an element whose GI is TITLE or	which has a child ele-
       ment with that GI.  It will apply the transpec numbered 1 to that  ele-
       ment,  which  copies  the  title	into the output	stream where the cross
       reference occurs.  Finally, it will print the word page followed	by the
       LaTeX instruction to obtain the page number of a	reference.
       GI:	       XREF
       AttValue:       OSFROLE getfull
       Replace:	       ${_followlink 87} \\ref{${LINKEND}},\s
		       {\\bf ${_chasetogi TITLE	1}}, page \\pageref{${LINKEND}}
       -
       # Print GI name,	in mixed case
       GI:	       _pr_gi_name
       SpecID:	       87
       Ignore:	       1
       EndText:	       ${_gi M}
       -
       GI:	       _pass-text
       SpecID:	       1
       -

Related	Information
       instant(1), sgmls(1), egrep(1).

							 transpec(file format)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=transpec&sektion=5&manpath=FreeBSD+Ports+15.0>

home | help