blob: fca806e8a5833bfed95f32d0db57c3ac2a5811d5 (
plain) (
tree)
|
|
###############################################################################
# #
# Lout @CPSetup package for formatting C and C++ programs (Version 1.1) #
# #
# Version 1.0 by Jeffrey H. Kingston, March 1994. #
# Version 1.1 by Jeffrey H. Kingston, November 1998 (name change only) #
# #
# This package uses a filtered body parameter to convert C and C++ source #
# code into Lout source. The filter program is c2lout which is distributed #
# with Basser Lout Version 3. The list of keywords and tokens is from #
# Stroustrup, 2nd Edition. See "User's Guide to the Lout Document #
# Formatting System" for user information. #
# #
###############################################################################
export @CP
def @CPSetup
named style { fixed } # print style
named fixedfont { Courier } # font family if fixed
named fixedstrings { Base } # string face if fixed
named fixedidentifiers { Base } # identifier face if fixed
named fixedcomments { Base } # comment face if fixed
named fixedkeywords { Base } # keyword face if fixed
named fixednumbers { Base } # number face if fixed
named fixedoperators { Base } # operator face if fixed
named fixedsize { -1.0p } # font size if fixed
named fixedline { 1.0vx } # line-space if fixed
named fixedtabin { 8 } # tab interval if fixed
named fixedtabout { 8s } # tab width if fixed
named varyingfont { } # font family if varying
named varyingstrings { Slope } # string face if varying
named varyingidentifiers { Slope } # identifier face if varying
named varyingcomments { Base } # comment face if varying
named varyingkeywords { Bold } # keyword face if varying
named varyingnumbers { Base } # number face if varying
named varyingoperators { Base } # operator face if varying
named varyingsize { 1.0f } # font size if varying
named varyingline { 1.0vx } # line-space if varying
named varyingtabin { 8 } # tab interval if varying
named varyingtabout { 3f } # tab width if varying
named symbolfont { } # font family if symbol
named symbolstrings { Slope } # string face if symbol
named symbolidentifiers { Slope } # identifier face if symbol
named symbolcomments { Base } # comment face if symbol
named symbolkeywords { Bold } # keyword face if symbol
named symbolnumbers { Base } # number face if symbol
named symboloperators { Base } # operator face if symbol
named symbolsize { 1.0f } # font size if symbol
named symbolline { 1.0vx } # line-space if symbol
named symboltabin { 8 } # tab interval if symbol
named symboltabout { 3f } # tab width if symbol
@Begin
export
"$$" "$>" "`" @L @S @C
"0" "1" "2" "3" "4" "5" "6" "7" "8" "9"
"!" "%" "^" "&" "*" "(" ")" "-" "+" "=" "${" "$}" "|" "~"
"[" "]" ";" "'" ":" "<" ">" "?" "," "." "/"
"->" "++" "--" ".*" "->*" "<<" ">>" "<=" ">=" "==" "!=" "&&"
"||" "*=" "/=" "%=" "+=" "-=" "<<=" ">>=" "&=" "^=" "|=" "::"
asm continue float new signed try
auto default for operator sizeof typedef
break delete friend private static union
case do goto protected struct unsigned
catch double if public switch virtual
char else inline register template void
class enum int return this volatile
const extern long short throw while
@EvaluateCp
def @CP
named style { style } # style
named font { dft } # font family
named strings { dft } # string font
named identifiers { dft } # ident. font
named comments { dft } # comment font
named keywords { dft } # keyword font
named numbers { dft } # number font
named operators { dft } # operator font
named size { dft } # font size
named line { dft } # line-space
named tabin { dft } # tab interval
named tabout { dft } # tab width
body @Body # filtered, see below
@Begin
def @Test # returns x unless x is dft
left x
named iffixed {}
named ifvarying {}
named ifsymbol {}
{
x @Case {
dft @Yield {
style @Case {
fixed @Yield { iffixed }
varying @Yield { ifvarying }
symbol @Yield { ifsymbol }
}
}
else @Yield x
}
}
def @InitTab
{
tabin @Test
iffixed { fixedtabin }
ifvarying { varyingtabin }
ifsymbol { symboltabin }
}
def @InitTabWidth
{
tabout @Test
iffixed { fixedtabout }
ifvarying { varyingtabout }
ifsymbol { symboltabout }
}
def @Filter
{
c2lout -r -i{@FilterIn} -o{@FilterOut} -e{@FilterErr}
-t{@InitTab} -T{@InitTabWidth}
}
def @InitFontFamily
{
font @Test
iffixed { fixedfont }
ifvarying { varyingfont }
ifsymbol { symbolfont }
}
def @InitSize
{
size @Test
iffixed { fixedsize }
ifvarying { varyingsize }
ifsymbol { symbolsize }
}
def @InitLine
{
line @Test
iffixed { fixedline }
ifvarying { varyingline }
ifsymbol { symbolline }
}
def @S # for formatting C strings
right x
{
"\"" &
strings @Test
iffixed { fixedstrings }
ifvarying { varyingstrings }
ifsymbol { symbolstrings }
@Font x
& "\""
}
def "`"
{
style @Case {
symbol @Yield { "`" }
else @Yield { "'" }
}
}
def @L # for formatting C character literals
right x
{
` &
strings @Test
iffixed { fixedstrings }
ifvarying { varyingstrings }
ifsymbol { symbolstrings }
@Font x
& '
}
def @Ident # for formatting C identifiers
{
identifiers @Test
iffixed { fixedidentifiers }
ifvarying { varyingidentifiers }
ifsymbol { symbolidentifiers }
}
def @C # for formatting C comments
right x
{
comments @Test
iffixed { fixedcomments }
ifvarying { varyingcomments }
ifsymbol { symbolcomments }
@Font x
}
def @K # for formatting C keywords
right x
{
keywords @Test
iffixed { fixedkeywords }
ifvarying { varyingkeywords }
ifsymbol { symbolkeywords }
@Font x
}
def @N # for formatting C numbers
right x
{
numbers @Test
iffixed { fixednumbers }
ifvarying { varyingnumbers }
ifsymbol { symbolnumbers }
@Font x
}
def @O # for formatting C operators
right x
{
operators @Test
iffixed { fixedoperators }
ifvarying { varyingoperators }
ifsymbol { symboloperators }
@Font x
}
def @A # get characters from the Adobe Symbol font
left sym
right x
{
style @Case {
symbol @Yield { { Symbol Base } @Font @Char sym }
else @Yield { x }
}
}
macro "$>" { {} & }
def "$$" { "#" }
def "0" { @N "0" }
def "1" { @N "1" }
def "2" { @N "2" }
def "3" { @N "3" }
def "4" { @N "4" }
def "5" { @N "5" }
def "6" { @N "6" }
def "7" { @N "7" }
def "8" { @N "8" }
def "9" { @N "9" }
def "!" { @O "!" }
def "%" { @O "%" }
def "^" { @O "^" }
def "&" { @O "&" }
def "*" { asteriskmath @A @O "*" }
def "(" { @O "(" }
def ")" { @O ")" }
def "-" { minus @A @O "-" }
def "+" { plus @A @O "+" }
def "=" { equal @A @O "=" }
def "${" { @O "{" }
def "$}" { @O "}" }
def "|" { @O "|" }
def "~" { @O "~" }
def "[" { @O "[" }
def "]" { @O "]" }
def ";" { @O ";" }
def "'" { @O "'" }
def ":" { @O ":" }
def "<" { less @A @O "<" }
def ">" { greater @A @O ">" }
def "?" { @O "?" }
def "," { @O "," }
def "." { @O "." }
def "/" { @O "/" }
def "->" { arrowright @A @O "->" }
def "++" { { + }{ + } }
def "--" { { - }{ - } }
def ".*" { { . }{ * } }
def "->*" { { ->}{ * } }
def "<<" { { < }{ < } }
def ">>" { { > }{ > } }
def "<=" { lessequal @A @O "<=" }
def ">=" { greaterequal @A @O ">=" }
def "==" { { = }{ = } }
def "!=" { notequal @A @O "!=" }
def "&&" { { & }{ & } }
def "||" { { | }{ | } }
def "*=" { { * }{ = } }
def "/=" { { / }{ = } }
def "%=" { { % }{ = } }
def "+=" { { + }{ = } }
def "-=" { { - }{ = } }
def "<<=" { { <<}{ = } }
def ">>=" { { >>}{ = } }
def "&=" { { & }{ = } }
def "^=" { { ^ }{ = } }
def "|=" { { | }{ = } }
def "::" { { : }{ : } }
def asm { @K "asm" }
def auto { @K "auto" }
def break { @K "break" }
def case { @K "case" }
def catch { @K "catch" }
def char { @K "char" }
def class { @K "class" }
def const { @K "const" }
def continue { @K "continue" }
def default { @K "default" }
def delete { @K "delete" }
def do { @K "do" }
def double { @K "double" }
def else { @K "else" }
def enum { @K "enum" }
def extern { @K "extern" }
def float { @K "float" }
def for { @K "for" }
def friend { @K "friend" }
def goto { @K "goto" }
def if { @K "if" }
def inline { @K "inline" }
def int { @K "int" }
def long { @K "long" }
def new { @K "new" }
def operator { @K "operator" }
def private { @K "private" }
def protected { @K "protected" }
def public { @K "public" }
def register { @K "register" }
def return { @K "return" }
def short { @K "short" }
def signed { @K "signed" }
def sizeof { @K "sizeof" }
def static { @K "static" }
def struct { @K "struct" }
def switch { @K "switch" }
def template { @K "template" }
def this { @K "this" }
def throw { @K "throw" }
def try { @K "try" }
def typedef { @K "typedef" }
def union { @K "union" }
def unsigned { @K "unsigned" }
def virtual { @K "virtual" }
def void { @K "void" }
def volatile { @K "volatile" }
def while { @K "while" }
def @EvaluateCp right x
{
{ @InitFontFamily Base } @Font
{ @Ident @InitSize } @Font
{ @InitLine lines } @Break x
}
{ @InitFontFamily Base } @Font { @Ident @InitSize } @Font
{ @InitLine lines } @Break @Body
@End @CP
@End @CPSetup
|
