Changeset 06b176d for doc


Ignore:
Timestamp:
Feb 8, 2018, 4:52:51 PM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
41fcd94
Parents:
169d944
Message:

more work on with statement

File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/papers/general/Paper.tex

    r169d944 r06b176d  
    22
    33\usepackage{fullpage}
     4\usepackage{epic,eepic}
    45\usepackage{xspace,calc,comment}
    56\usepackage{upquote}                                                                    % switch curled `'" to straight
    … …  
    3637%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    3738
    38 \newcommand{\Textbf}[1]{{\color{red}\textbf{#1}}}
     39\newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
    3940\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
    4041%\newcommand{\TODO}[1]{} % TODO elided
    … …  
    10791080\end{C++}
    10801081Nesting of member routines in a \lstinline[language=C++]@class@ allows eliding \lstinline[language=C++]@this->@ because of lexical scoping.
     1082However, for other aggregate parameters, qualification is necessary:
     1083\begin{cfa}
     1084struct T { double m, n; };
     1085int C::mem( T & t ) {                                           $\C{// multiple aggregate parameters}$
     1086        c; i; d;                                                                $\C{\color{red}// this-\textgreater.c, this-\textgreater.i, this-\textgreater.d}$
     1087        `t.`m; `t.`n;                                                   $\C{// must qualify}$
     1088}
     1089\end{cfa}
    10811090
    10821091% In object-oriented programming, there is an implicit first parameter, often names @self@ or @this@, which is elided.
    … …  
    10881097% \TODO{Fill out section. Be sure to mention arbitrary expressions in with-blocks, recent change driven by Thierry to prioritize field name over parameters.}
    10891098
    1090 \CFA provides a @with@ clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
     1099To simplify the programmer experience, \CFA provides a @with@ clause/statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate qualification to fields by opening a scope containing the field identifiers.
    10911100Hence, the qualified fields become variables with the side-effect that it is easier to optimizing field references in a block.
    10921101\begin{cfa}
    … …  
    11011110}
    11021111\end{cfa}
    1103 The generality over the object-oriented approach is that multiple aggregate parameters can be opened, not just \lstinline[language=C++]@this@:
    1104 \begin{cfa}
    1105 struct T { double m, n; };
     1112with the generality of opening multiple aggregate-parameters:
     1113\begin{cfa}
    11061114int mem( S & s, T & t ) `with( s, t )` {        $\C{// multiple aggregate parameters}$
    11071115        c; i; d;                                                                $\C{\color{red}// s.c, s.i, s.d}$
    … …  
    11091117}
    11101118\end{cfa}
    1111 The equivalent object-oriented approach is:
    1112 \begin{cfa}
    1113 int S::mem( T & t ) {                                           $\C{// multiple aggregate parameters}$
    1114         c; i; d;                                                                $\C{\color{red}// this-\textgreater.c, this-\textgreater.i, this-\textgreater.d}$
    1115         `t.`m; `t.`n;                                                   $\C{// must qualify}$
    1116 }
     1119
     1120In detail, the @with@ clause/statement has the form:
     1121\begin{cfa}
     1122$\emph{with-statement}$:
     1123        'with' '(' $\emph{expression-list}$ ')' $\emph{compound-statement}$
     1124\end{cfa}
     1125and may appear as the body of a routine or nested within a routine body.
     1126Each expression in the expression-list provides a type and object.
     1127The type must be an aggregate type.
     1128(Enumerations are already opened.)
     1129The object is the implicit qualifier for the open structure-fields.
     1130
     1131All expressions in the expression list are open in ``parallel'' within the compound statement.
     1132This semantic is different from Pascal, which nests the openings.
     1133The difference between parallel and nesting occurs for fields with the same name but different type:
     1134\begin{cfa}
     1135struct S { int i; int j; double m; } s, w;
     1136struct T { int i; int k; int m } t, w;
     1137with( s, t ) {
     1138        j + k;                                                                  $\C{// unambiguous, s.j + t.m}$
     1139        m = 5.0;                                                                $\C{// unambiguous, t.m = 5.0}$
     1140        m = 1;                                                                  $\C{// unambiguous, s.m = 1}$
     1141        int a = s.i + m;                                                $\C{// unambiguous, a = s.i + t.i}$
     1142        int b = s.i + t.i;                                              $\C{// unambiguous, qualification}$
     1143        sout | (double)m | endl;                                $\C{// unambiguous, cast}$
     1144        i;                                                                              $\C{// ambiguous}$
     1145}
     1146\end{cfa}
     1147\CFA's ability to overload variables means usages of field with the same names can be automatically disambiguated, eliminating most qualification.
     1148Qualification or a cast is used to disambiguate.
     1149A cast may be necessary to disambiguate between the overload variables in a @with@ expression:
     1150\begin{cfa}
     1151with( w ) { ... }                                                       $\C{// ambiguous, same name and no context}$
     1152with( (S)w ) { ... }                                            $\C{// unambiguous}$
    11171153\end{cfa}
    11181154
    … …  
    11491185\end{cfa}
    11501186
    1151 When opening multiple structures, fields with the same name and type are ambiguous and must be fully qualified.
    1152 For fields with the same name but different type, context/cast can be used to disambiguate.
    1153 \begin{cfa}
    1154 struct S { int i; int j; double m; } a, c;
    1155 struct T { int i; int k; int m } b, c;
    1156 `with( a, b )` {
    1157         j + k;                                                                  $\C{// unambiguous, unique names define unique types}$
    1158         i;                                                                              $\C{// ambiguous, same name and type}$
    1159         a.i + b.i;                                                              $\C{// unambiguous, qualification defines unique names}$
    1160         m;                                                                              $\C{// ambiguous, same name and no context to define unique type}$
    1161         m = 5.0;                                                                $\C{// unambiguous, same name and context defines unique type}$
    1162         m = 1;                                                                  $\C{// unambiguous, same name and context defines unique type}$
    1163 }
    1164 `with( c )` { ... }                                                     $\C{// ambiguous, same name and no context}$
    1165 `with( (S)c )` { ... }                                          $\C{// unambiguous, same name and cast defines unique type}$
    1166 \end{cfa}
    1167 
    1168 The components in the "with" clause
    1169 
    1170   with( a, b, c ) { ... }
    1171 
    1172 serve 2 purposes: each component provides a type and object. The type must be a
    1173 structure type. Enumerations are already opened, and I think a union is opened
    1174 to some extent, too. (Or is that just unnamed unions?) The object is the target
    1175 that the naked structure-fields apply to. The components are open in "parallel"
    1176 at the scope of the "with" clause/statement, so opening "a" does not affect
    1177 opening "b", etc. This semantic is different from Pascal, which nests the
    1178 openings.
    1179 
    1180 Having said the above, it seems reasonable to allow a "with" component to be an
    1181 expression. The type is the static expression-type and the object is the result
    1182 of the expression. Again, the type must be an aggregate. Expressions require
    1183 parenthesis around the components.
    1184 
    1185   with( a, b, c ) { ... }
    1186 
    1187 Does this now make sense?
    1188 
    1189 Having written more CFA code, it is becoming clear to me that I *really* want
    1190 the "with" to be implemented because I hate having to type all those object
    1191 names for fields. It's a great way to drive people away from the language.
    1192 
    11931187
    11941188\subsection{Exception Handling ???}
    … …  
    12041198
    12051199\subsection{Alternative Declaration Syntax}
     1200
     1201\newcommand{\R}[1]{\Textbf{#1}}
     1202\newcommand{\B}[1]{{\Textbf[blue]{#1}}}
     1203\newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
     1204
     1205C declaration syntax is notoriously confusing and error prone.
     1206For example, many C programmers are confused by a declaration as simple as:
     1207\begin{flushleft}
     1208\lstDeleteShortInline@%
     1209\begin{tabular}{@{}ll@{}}
     1210\begin{cfa}
     1211int * x[5]
     1212\end{cfa}
     1213&
     1214\raisebox{-0.75\totalheight}{\input{Cdecl}}
     1215\end{tabular}
     1216\lstMakeShortInline@%
     1217\end{flushleft}
     1218Is this an array of 5 pointers to integers or a pointer to an array of 5 integers?
     1219The fact this declaration is unclear to many C programmers means there are productivity and safety issues even for basic programs.
     1220Another example of confusion results from the fact that a routine name and its parameters are embedded within the return type, mimicking the way the return value is used at the routine's call site.
     1221For example, a routine returning a pointer to an array of integers is defined and used in the following way:
     1222\begin{cfa}
     1223int `(*`f`())[`5`]` {...};                              $\C{// definition}$
     1224 ... `(*`f`())[`3`]` += 1;                              $\C{// usage}$
     1225\end{cfa}
     1226Essentially, the return type is wrapped around the routine name in successive layers (like an onion).
     1227While attempting to make the two contexts consistent is a laudable goal, it has not worked out in practice.
     1228
     1229\CFA provides its own type, variable and routine declarations, using a different syntax.
     1230The new declarations place qualifiers to the left of the base type, while C declarations place qualifiers to the right of the base type.
     1231In the following example, \R{red} is the base type and \B{blue} is qualifiers.
     1232The \CFA declarations move the qualifiers to the left of the base type, \ie move the blue to the left of the red, while the qualifiers have the same meaning but are ordered left to right to specify a variable's type.
     1233\begin{quote}
     1234\lstDeleteShortInline@%
     1235\lstset{moredelim=**[is][\color{blue}]{+}{+}}
     1236\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1237\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1238\begin{cfa}
     1239+[5] *+ `int` x1;
     1240+* [5]+ `int` x2;
     1241+[* [5] int]+ f`( int p )`;
     1242\end{cfa}
     1243&
     1244\begin{cfa}
     1245`int` +*+ x1 +[5]+;
     1246`int` +(*+x2+)[5]+;
     1247+int (*+f`( int p )`+)[5]+;
     1248\end{cfa}
     1249\end{tabular}
     1250\lstMakeShortInline@%
     1251\end{quote}
     1252The only exception is bit field specification, which always appear to the right of the base type.
     1253% Specifically, the character ©*© is used to indicate a pointer, square brackets ©[©\,©]© are used to represent an array or function return value, and parentheses ©()© are used to indicate a routine parameter.
     1254However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
     1255For instance, variables ©x© and ©y© of type pointer to integer are defined in \CFA as follows:
     1256\begin{quote}
     1257\lstDeleteShortInline@%
     1258\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1259\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1260\begin{cfa}
     1261`*` int x, y;
     1262\end{cfa}
     1263&
     1264\begin{cfa}
     1265int `*`x, `*`y;
     1266\end{cfa}
     1267\end{tabular}
     1268\lstMakeShortInline@%
     1269\end{quote}
     1270The downside of this semantics is the need to separate regular and pointer declarations:
     1271\begin{quote}
     1272\lstDeleteShortInline@%
     1273\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1274\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1275\begin{cfa}
     1276`*` int x;
     1277int y;
     1278\end{cfa}
     1279&
     1280\begin{cfa}
     1281int `*`x, y;
     1282
     1283\end{cfa}
     1284\end{tabular}
     1285\lstMakeShortInline@%
     1286\end{quote}
     1287which is prescribing a safety benefit.
     1288Other examples are:
     1289\begin{quote}
     1290\lstDeleteShortInline@%
     1291\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1292\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
     1293\begin{cfa}
     1294[ 5 ] int z;
     1295[ 5 ] * char w;
     1296* [ 5 ] double v;
     1297struct s {
     1298        int f0:3;
     1299        * int f1;
     1300        [ 5 ] * int f2;
     1301};
     1302\end{cfa}
     1303&
     1304\begin{cfa}
     1305int z[ 5 ];
     1306char * w[ 5 ];
     1307double (* v)[ 5 ];
     1308struct s {
     1309        int f0:3;
     1310        int * f1;
     1311        int * f2[ 5 ]
     1312};
     1313\end{cfa}
     1314&
     1315\begin{cfa}
     1316// array of 5 integers
     1317// array of 5 pointers to char
     1318// pointer to array of 5 doubles
     1319
     1320// common bit field syntax
     1321
     1322
     1323
     1324\end{cfa}
     1325\end{tabular}
     1326\lstMakeShortInline@%
     1327\end{quote}
     1328
     1329All type qualifiers, \eg ©const©, ©volatile©, etc., are used in the normal way with the new declarations and also appear left to right, \eg:
     1330\begin{quote}
     1331\lstDeleteShortInline@%
     1332\begin{tabular}{@{}l@{\hspace{1em}}l@{\hspace{1em}}l@{}}
     1333\multicolumn{1}{c@{\hspace{1em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{1em}}}{\textbf{C}} \\
     1334\begin{cfa}
     1335const * const int x;
     1336const * [ 5 ] const int y;
     1337\end{cfa}
     1338&
     1339\begin{cfa}
     1340int const * const x;
     1341const int (* const y)[ 5 ]
     1342\end{cfa}
     1343&
     1344\begin{cfa}
     1345// const pointer to const integer
     1346// const pointer to array of 5 const integers
     1347\end{cfa}
     1348\end{tabular}
     1349\lstMakeShortInline@%
     1350\end{quote}
     1351All declaration qualifiers, \eg ©extern©, ©static©, etc., are used in the normal way with the new declarations but can only appear at the start of a \CFA routine declaration,\footnote{\label{StorageClassSpecifier}
     1352The placement of a storage-class specifier other than at the beginning of the declaration specifiers in a declaration is an obsolescent feature.~\cite[\S~6.11.5(1)]{C11}} \eg:
     1353\begin{quote}
     1354\lstDeleteShortInline@%
     1355\begin{tabular}{@{}l@{\hspace{3em}}l@{\hspace{2em}}l@{}}
     1356\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c@{\hspace{2em}}}{\textbf{C}} \\
     1357\begin{cfa}
     1358extern [ 5 ] int x;
     1359static * const int y;
     1360\end{cfa}
     1361&
     1362\begin{cfa}
     1363int extern x[ 5 ];
     1364const int static * y;
     1365\end{cfa}
     1366&
     1367\begin{cfa}
     1368// externally visible array of 5 integers
     1369// internally visible pointer to constant int
     1370\end{cfa}
     1371\end{tabular}
     1372\lstMakeShortInline@%
     1373\end{quote}
     1374
     1375The new declaration syntax can be used in other contexts where types are required, \eg casts and the pseudo-routine ©sizeof©:
     1376\begin{quote}
     1377\lstDeleteShortInline@%
     1378\begin{tabular}{@{}l@{\hspace{3em}}l@{}}
     1379\multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
     1380\begin{cfa}
     1381y = (`* int`)x;
     1382i = sizeof(`[ 5 ] * int`);
     1383\end{cfa}
     1384&
     1385\begin{cfa}
     1386y = (`int *`)x;
     1387i = sizeof(`int * [ 5 ]`);
     1388\end{cfa}
     1389\end{tabular}
     1390\lstMakeShortInline@%
     1391\end{quote}
     1392
     1393Finally, new \CFA declarations may appear together with C declarations in the same program block, but cannot be mixed within a specific declaration.
     1394Therefore, a programmer has the option of either continuing to use traditional C declarations or take advantage of the new style.
     1395Clearly, both styles need to be supported for some time due to existing C-style header-files, particularly for UNIX systems.
    12061396
    12071397
Note: See TracChangeset for help on using the changeset viewer.