@sap/cds-compiler 5.3.2 → 5.4.2

package/lib/language/antlrParser.js

@@ -275,15 +275,19 @@ function parseWithNewParser( source, filename, options, messageFunctions, rule )
       // TODO: what should we do in case of errors?
       $ctx.stop = this.lb();
       parseListener.exitEveryRule( $ctx );
-      CdlParser.prototype.exit_.apply( this, args );
+      return CdlParser.prototype.exit_.apply( this, args );
     };
     parser.c = function c( ...args ) { // consume
-      CdlParser.prototype.c.apply( this, args );
-      parseListener.visitTerminal( { symbol: this.lb() } );
+      const symbol = this.la();
+      const result = CdlParser.prototype.c.apply( this, args );
+      if (result)
+        parseListener.visitTerminal( { symbol } );
+      return result;
     };
     parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
+      const symbol = this.la();
       CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
-      parseListener.visitErrorNode( { symbol: this.lb() } );
+      parseListener.visitErrorNode( { symbol } );
     };
   }
   const result = {};

package/lib/language/genericAntlrParser.js

@@ -17,7 +17,7 @@ const {
   specialFunctions,
   quotedLiteralPatterns,
 } = require('../compiler/builtins');
-const { functionsWithoutParens } = require('../base/builtins');
+const { functionsWithoutParentheses } = require('../parsers/identifiers');
 const { Location } = require('../base/location');
 const { pathName } = require('../compiler/utils');
 const { XsnArtifact, XsnName, XsnSource } = require('../compiler/xsn-model');
@@ -728,7 +728,7 @@ function docComment( node ) {
  */
 function classifyImplicitName( category, ref ) {
   if (!ref || ref.path) {
-    const tokenIndex = ref?.path[ref.path.length - 1]?.location.tokenIndex;
+    const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
     const implicit = (tokenIndex === undefined) ? this._input.LT(-1) : this._input.get(tokenIndex);
     if (implicit.isIdentifier) {
       const previous = implicit.isIdentifier;
@@ -847,7 +847,7 @@ function valuePathAst( ref ) {
     const { args, id, location } = path[0];
     if (args
       ? path[0].$syntax === ':'
-      : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
+      : path[0].$delimited || !functionsWithoutParentheses.includes( id.toUpperCase() ))
       return ref;
 
     const implicit = this.previousTokenAtLocation( location );

package/lib/model/csnUtils.js

@@ -227,7 +227,12 @@ function getUtils( model, universalReady ) {
    * @returns {boolean}
    */
   function isStructured( obj ) {
-    return !!(obj.elements || (obj.type && getFinalTypeInfo(obj.type)?.elements));
+    if (obj.elements)
+      return true;
+    if (!obj.type)
+      return false;
+    const typeInfo = getFinalTypeInfo(obj.type);
+    return !!(typeInfo?.elements); // TODO? `|| typeInfo?.type === 'cds.Map');`
   }
 
   // Return true if 'node' is a managed association element

package/lib/optionProcessor.js

@@ -603,6 +603,7 @@ optionProcessor.command('forEffective')
 optionProcessor.command('forSeal')
   .option('-h, --help')
   .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
+  .option('--derive-analytical-annotations <val>', { valid: ['true', 'false'] })
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc forSeal [options] <files...>
@@ -614,6 +615,9 @@ optionProcessor.command('forSeal')
        --remap-odata-annotations <val>   Remap OData annotations to ABAP annotations:
                                           true: (default)   remap annotations
                                           false:            leave them as is
+       --derive-analytical-annotations <val>    Set analytics annotations
+                                          true:             set the annotations
+                                          false: (default)  don't set them
 `);
 
 module.exports = {

package/lib/parsers/AstBuildingParser.js

@@ -4,7 +4,7 @@ const BaseParser = require( '../gen/BaseParser' );
 
 const { Location } = require( '../base/location' );
 const { dictAdd, dictAddArray } = require('../base/dictionaries');
-const { functionsWithoutParens } = require('../base/builtins');
+const { functionsWithoutParentheses } = require('./identifiers');
 
 const { pathName } = require('../compiler/utils');
 const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtins');
@@ -70,8 +70,8 @@ class AstBuildingParser extends BaseParser {
     return this.$messageFunctions.info( id, location?.location || location, args, text );
   }
 
-  expectingArray() {
-    const expecting = this._expecting();
+  expectingArray( token ) {
+    const expecting = this._expecting( token );
     let array = Object.keys( expecting );
     // compatibility: replace true+false by Boolean
     if (expecting.true && expecting.false)
@@ -81,7 +81,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   reportUnexpectedToken_( token ) {
-    const expecting = this.expectingArray();
+    const expecting = this.expectingArray( token );
     const err = this.error( 'syntax-unexpected-token', token,
                             { offending: antlrName( token ), expecting } );
     // No 'unwanted' variant, no 'syntax-missing-token'
@@ -94,25 +94,53 @@ class AstBuildingParser extends BaseParser {
     err.expectedTokens = this.expectingArray();
   }
 
-  setPrecInCallingRule() {
-    const caller = this.stack.at( -1 );
-    if (this.inSameRule_( caller.ruleState, caller.followState ))
-      caller.prec = this.prec_;
+  reportInternalError_( token ) {
+    this.error( null, token, { offending: antlrName( token ) },
+                'Mismatched $(OFFENDING); skipped one token' );
+    // TMP: should not happen anymore → remove method in redepage
+    throw new Error( 'Repeated error reporting with same token' );
   }
 
-  tableAlias() {
+  tableWithoutAs() {
+    // TODO TOOL: if the tool properly creates `default: this.giR()`, this
+    // condition method is most likely not necessary
     const { keyword } = this.la();
-    if (keyword && this.keywords[keyword])
-      return false;
-    if (this.lb().type !== ')')
-      return true;
-    // after ')' we need to check the expression category = must not already be a
-    // table, like a simplified version of `<prec=-2, postfix=once>` which we
-    // cannot do additionally
-    if (this.prec_ != null && this.prec_ <= -2)
-      return false;
-    this.prec_ = -2;
-    return true;
+    // TODO: if necessary, we could allow some keywords, and just make sure that
+    // all JOIN variants are still possible
+    return !keyword || this.keywords[keyword] == null;
+  }
+
+  /**
+   * Handle allowed mixes of expression categories.
+   *
+   * - <prepare=queryOnLeft>: define a new parentheses context if not direct
+   *   recursive call, it can finally turn to be both a query or expr/table
+   * - <prepare=queryOnLeft, arg=‹SomeVal›>: make the current parentheses
+   *   context to be not a query anymore
+   * - <cond=queryOnLeft> tests whether the expression on the left is a query
+   * - <cond=queryOnLeft, arg=‹SomeVal›>: tests whether the expression on the
+   *   left is a query, then make the current context to be not a query anymore
+   * - <cond=queryOnLeft, arg=tableWithoutAs>: …after having checked
+   *   whether the next token is no (reserved or unreserved) keyword
+   */
+  queryOnLeft( test, arg ) {
+    if (arg === 'tableWithoutAs') {
+      if (!this.tableWithoutAs())
+        return false;
+    }
+    else if (!arg && !test) {
+      // provide new dynamic parentheses context, except with direct
+      // recursive call:
+      if (this.inSameRule_( this.s, this.stack.at( -1 ).followState ))
+        return true;
+      this.dynamic_.parenthesesCtx = [ null ];
+      this._tracePush( 'Parentheses()' );
+    }
+    const { parenthesesCtx } = this.dynamic_;
+    const noQuery = parenthesesCtx?.[0];
+    if (arg && parenthesesCtx)
+      parenthesesCtx[0] = arg;
+    return !noQuery;
   }
 
   prepareSpecialFunction() {
@@ -133,7 +161,7 @@ class AstBuildingParser extends BaseParser {
   lGenericIntroOrExpr( tryGenericIntro = true ) {
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
-    const text = keyword?.toUpperCase() ?? type;
+    const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
     const generic = this.dynamic_.generic?.[text];
     if (tryGenericIntro) {
       if (this.dynamic_.generic?.IN === 'separator')
@@ -142,7 +170,7 @@ class AstBuildingParser extends BaseParser {
         return (generic === 'intro') ? 'GenericIntro' : 'Id';
       const next = this.tokens[this.tokenIdx + 1];
       if (next.type !== ',' && next.type !== ')' &&
-          this.dynamic_.generic[next.keyword?.toUpperCase()] !== 'separator')
+          this.dynamic_.generic[next.keyword?.toUpperCase?.()] !== 'separator')
         return 'GenericIntro';
     }
     return (generic === 'expr') ? 'GenericExpr' : 'Id';
@@ -155,7 +183,7 @@ class AstBuildingParser extends BaseParser {
   lGenericSeparator() {
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
-    const text = keyword?.toUpperCase() ?? type;
+    const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
     const generic = this.dynamic_.generic?.[text];
     return (generic === 'separator') ? 'GenericSeparator' : ',';
   }
@@ -166,25 +194,32 @@ class AstBuildingParser extends BaseParser {
     return realTokens?.map( s => s.toLowerCase() ) ?? [];
   }
 
-  isDotForPath() {
+  inSelectItem( _test, arg ) {  // only as action
+    this.dynamic_.inSelectItem = arg;
+  }
+
+  /**
+   * `virtual` and `key` cannot be used inside expand/inline
+   * (also inside sub queries in those, which will be rejected later anyway)
+   */
+  modifierRestriction() {
+    return this.dynamic_.inSelectItem !== 'nested';
+  }
+
+  isDotForPath() {              // see also inSelectItem
     if (this.dynamic_.inSelectItem == null)
       return true;
-    // false for outer select item, true for inner; TODO: it would be best to set
-    // this.dynamic_.inSelectItem to null in filters
+    // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
+    // (as <prepare>)
     const next = this.tokens[this.tokenIdx + 1].type;
     return next !== '*' && next !== '{';
   }
 
-  // <prec=10, postfix=once> + test that the next token is not `null`
-  // TODO TOOL: allow to provide argument with condition: <cond=isNegatedRelation, arg=10>
-  isNegatedRelation() {
-    const parentPrec = this.stack.at( -1 ).prec;
-    if (parentPrec != null && parentPrec >= 10 ||
-        this.prec_ != null && this.prec_ <= 10 ||
-        this.tokens[this.tokenIdx + 1].keyword === 'null')
-      return false;
-    this.prec_ = 10;
-    return true;
+  // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
+  // completion for `… default 3 not ~;` → currently just `null` but hey
+  isNegatedRelation( _test, prec ) {
+    return this.tokens[this.tokenIdx + 1].keyword !== 'null' &&
+      this.precNone_( _test, prec );
   }
 
   isNamedArg() {
@@ -223,76 +258,53 @@ class AstBuildingParser extends BaseParser {
 
   /**
    * Prepare element restrictions and check validility of final anno assignments.
-   * TODO TOOL: `arg` for actions/conditions
    *
-   * Called in rule `elementDef` at the following places:
-   * - <prepare> after `:` (before calling `typeExpression`):
-   *   disallow `= calcExpr` and final annotation assignments
-   *   without further <prepare=calcOrDefaultRestriction>
-   * - <prepare> in empty alternative to type expression:
-   *   allow `= calcExpr` and final annotation assignments
-   * - <cond> before final annotation assignments: allowed?
+   * Called as <prepare=…>:
    *
-   * Called in rule `returnsSpec`:
-   * - <prepare> after `returns`: disallow `default`.
-   */
-  elementRestriction( test ) {
-    if (!test) {                // after `:` for typeExpression, or without type
-      const withoutType = this.lb().type !== ':';
-      const afterReturns = this.lb().keyword === 'returns';
-      this.dynamic_.elementCtx = [ withoutType, withoutType, afterReturns ];
-    }
-    // or before final annotation assignments
-    return this.dynamic_.elementCtx?.[1];
-  }
-
-  /**
-   * Prepare `= calcExpr` restriction and check whether it can be used.
+   * - <…, arg=default> in `returnsSpec`: after `returns`
+   *   disallow `default` in `typeExpression`
+   * - <…,arg=elem> in `elementDef` (before calling `typeExpression`):
+   *   allow `default`/`= calcExpr` with final annotation assignments,
+   *   delay final doc comment
+   * - <…, arg=calc> in `typeExpression` (with associations, etc)
+   *   now disallow `= calcExpr` (with annotation assignments) in `elementDef`,
+   *   do not delay final doc comments anymore
+   * - <…, arg=anno> in `typeExpression` after enums:
+   *   now disallow annotation assignments after `= calcExpr`,
+   *   ignore doc comment after having called `typeExpression`
    *
-   * Called at the following places:
-   * - <prepare> before (optionally) calling rule `nullabilityAndDefault`,
-   *   except for managed associations/compositions:
-   *   allow `= calcExpr`, allow final annotation assignments if not after `}`
-   *   (TODO: should we allow `String @anno:{ … } not null @MoreAnnos`?)
-   * - <cond> before `default`: disallow calc expr (+ restrict default expr),
-   *   allowed? (not for `returns`)
-   * - <cond> before `=` for calc expressions: allowed?
+   * Called as <cond=…>:
    *
-   * To have any effect, <prepare=elementRestriction> must have been called.
+   * - <…, arg=default> in `nullabilityAndDefault`:
+   *   is `default` allowed?  If used, disallow calc (with anno assignments)
+   * - <…, arg=calc> in `elementDef`:
+   *   is `= calcExpr` allowed?  If so, check for final doc
+   * - <…, arg=anno> in `elementDef`:
+   *   are annotation assignments after `= calcExpr` allowed?
    */
-  calcOrDefaultRestriction( test, arg ) {
+  elementRestriction( test, arg ) {
     const { elementCtx } = this.dynamic_;
-    if (!test) {                                 // at beginning of rule `nullabilityAndDefault`
-      if (!elementCtx)
-        return true;
-      elementCtx[0] = !arg;  // using `= expr` is ok (except for assoc)
-      elementCtx[1] = this.lb().type !== '}'; // allow final annos not after block
+    if (test) {
+      if (!elementCtx || elementCtx[0] === arg)
+        return !elementCtx;
+      if (arg === 'default') {
+        elementCtx[0] = 'calc';
+        this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
+      }
     }
-    else if (this.l() === '=') { // <cond> before `= calcExpression`
-      return elementCtx?.[0];
+    else if (arg === 'elem' || arg === 'default') {
+      this.dynamic_.elementCtx = [ arg ];
     }
-    else {                      // <cond> before `default`
-      if (elementCtx)
-        elementCtx[0] = false;
-      this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
+    else if (elementCtx) {
+      elementCtx[0] = arg;
     }
-    return !elementCtx?.[2];    // default allowed?
+    return true;
   }
 
   inExpandInline() {            // not as <cond>
     this.dynamic_.inSelectItem = 'nested';
   }
 
-  /**
-   * `virtual` and `key` cannot be used inside expand/inline
-   * (also inside sub queries in those, which will be rejected later anyway)
-   */
-  notInExpandInline( test ) {
-    if (!test)
-      this.dynamic_.inSelectItem = true;
-    return this.dynamic_.inSelectItem !== 'nested';
-  }
-
   /**
    * `;` between statements is optional only after a `}` (ex braces of structure
    * values for annotations).
@@ -314,20 +326,24 @@ class AstBuildingParser extends BaseParser {
   }
 
   /**
-   * `...` can appear in the top-level array value only and not after `...`
-   * without `up to`.
+   * - `{}` can only appears inside array-valued annotations
+   * - `...` can appear in the top-level array value only and not after `...`
+   *   without `up to`.
    */
-  ellipsisRestriction( test ) {
+  arrayAnno( test, arg ) {
     if (!test) {
       this.dynamic_.arrayAnno = [ !this.dynamic_.arrayAnno ];
     }
-    else {                      // on '...'
+    else if (arg === 'ellipsis') { // on '...'
       const { arrayAnno } = this.dynamic_;
       if (!arrayAnno[0])
         return false;
       if (this.tokens[this.tokenIdx + 1]?.type === ',')
         arrayAnno[0] = false;
     }
+    else {                      // orNotEmpty
+      return this.dynamic_.arrayAnno || this.lb().type !== '{';
+    }
     return true;
   }
 
@@ -352,9 +368,9 @@ class AstBuildingParser extends BaseParser {
     this.error( msgId, location, textArgs );
   }
 
-  warnIfColonFollows( anno ) {
+  warnIfColonFollows( name ) {
     if (this.l() === ':') {
-      this.warning( 'syntax-missing-parens', anno.name,
+      this.warning( 'syntax-missing-parens', name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
                     // eslint-disable-next-line @stylistic/js/max-len
                     'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
@@ -370,7 +386,8 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
-  // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
+  // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths,
+  // inside `.*` and `.{`
   reportUnexpectedSpace( prefix = this.lb(),
                          location = this.la().location,
                          isError = false ) {
@@ -469,9 +486,11 @@ class AstBuildingParser extends BaseParser {
     }
     if (!prefix) {                // set deprecated $annotations for cds-lsp
       const { line, col } = name.location;
+      // prefer value end-location if it exists
+      const endLoc = val.location || val.name.location;
       const location = {
         __proto__: Location.prototype,
-        ...val.location,
+        ...endLoc,
         line,
         col,
       };
@@ -542,7 +561,7 @@ class AstBuildingParser extends BaseParser {
 
   classifyImplicitName( category, ref ) {
     if (!ref || ref.path) {
-      const tokenIndex = ref?.path[ref.path.length - 1]?.location.tokenIndex;
+      const tokenIndex = ref?.path.at(-1)?.location.tokenIndex;
       const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
       const { parsedAs } = token;
       if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword') {
@@ -580,7 +599,8 @@ class AstBuildingParser extends BaseParser {
     let val;
 
     if (text.startsWith( '`' )) {
-      val = parseMultiLineStringLiteral.call( this, token ); // TODO: remove `call()` syntax
+      val = token.keyword !== 0 && // 0 -> unterminated literal
+        parseMultiLineStringLiteral.call( this, token ); // TODO: remove `call()` syntax
     }
     else {
       pos = text.search( '\'' ) + 1; // pos of char after quote
@@ -717,8 +737,20 @@ class AstBuildingParser extends BaseParser {
    *  - misplaced doc comments would lead to a parse error (incompatible),
    *  - would influence the prediction and error recovery,
    *  - is only slightly "more declarative" in the grammar.
+   *
+   * With argument `delayed`, potentially delay the doc processing.
+   * See also `elementRestriction`.
    */
-  docComment( art ) {
+  docComment( art, delayed = undefined ) {
+    if (delayed !== this.dynamic_?.[0]) {
+      if (delayed === 'type')
+        return;
+    }
+    else if (delayed === 'elem') {
+      this.dynamic_[0] = 'type';
+      return;
+    }
+
     const { line: prevLine, col: prevCol } = this.lb()?.location ?? { line: 0, col: 0 };
     const { line: currLine, col: currCol } = this.la().location;
     let token;
@@ -726,6 +758,7 @@ class AstBuildingParser extends BaseParser {
       token = this.docComments[this.docCommentIndex];
       if (!token)
         return;                 // no further doc comment
+      // TODO: we could use location.tokenIndex
       const { line, col } = token.location;
       if (art && (line > currLine || line === currLine && col > currCol))
         return;               // next doc comment after current token
@@ -750,6 +783,21 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
+  checkWith( keyword ) {
+    if (this.lb() !== keyword)
+      return;
+    const tok = this.la();
+    if (this.docCommentIndex < tok.location.tokenIndex &&
+        this.docCommentIndex > this.lb().location.tokenIndex)
+      return;
+    const expecting = this.expectingArray(); // TODO: filter
+    const msg = this.warning( 'syntax-unexpected-semicolon', tok,
+                              { offending: antlrName( tok ), expecting, keyword: 'with' },
+                              // eslint-disable-next-line @stylistic/js/max-len
+                              'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
+    msg.expectedTokens = expecting;
+  }
+
   setNullability( art, val, location = this.lb().location ) {
     const notNull = { val, location };
     if (art.notNull) {
@@ -843,7 +891,20 @@ class AstBuildingParser extends BaseParser {
     }
   }
 
+  // TODO: remove the check from the parser; move it to shared.js
+  checkTypeArgs( art ) {
+    const args = art.$typeArgs;
+    // One or two arguments are interpreted as either length or precision/scale.
+    if (args.length > 2) {
+      const loc = args[2].location;
+      this.error( 'syntax-unexpected-argument', loc, {}, 'Too many type arguments' );
+      art.$typeArgs.length = 0;
+    }
+  }
+
   locationOfPrevTokens( offset ) {
+    // TODO: use combined location of lb() and la() and move actions accordingly
+    // (for error recovery)
     const { file, line, col } = this.tokens[this.tokenIdx - offset].location;
     const { endLine, endCol } = this.lb().location;
     return {
@@ -912,7 +973,7 @@ class AstBuildingParser extends BaseParser {
 
   pushXprToken( expr ) {
     const token = this.lb();
-    (expr.args ?? expr).push( {
+    (expr.args ?? expr).push?.( {
       val: token.keyword ?? token.type,
       location: token.location,
       literal: 'token',
@@ -922,7 +983,7 @@ class AstBuildingParser extends BaseParser {
   applyOpToken( expr, nary = null ) {
     const token = this.lb();
     const op = { val: token.keyword ?? token.type, location: token.location, literal: 'token' };
-    if (nary === 'nary' && !expr?.$parens) {
+    if (nary === 'nary' && expr && !expr.$parens) {
       const { args } = expr;
       const prev = args?.[1];
       if (prev?.val === op.val && prev?.literal === 'token') {
@@ -944,7 +1005,7 @@ class AstBuildingParser extends BaseParser {
       const { args, id, location } = path[0];
       if (args
           ? path[0].$syntax === ':'
-          : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
+          : path[0].$delimited || !functionsWithoutParentheses.includes( id.toUpperCase() ))
         return this.attachLocation( ref );
 
       const funcToken = this.prevTokenWithIndex( location.tokenIndex );
@@ -1013,11 +1074,11 @@ class AstBuildingParser extends BaseParser {
   }
 
   associationInSelectItem( art ) {
-    const { value } = art;
-    const path = value?.path;
+    this.classifyImplicitName( 'ItemAssoc', art.value );
+    const path = art.value?.path;
     // we cannot compare "just one token before `:`" because there might be annos
     if (path && path.length === 1 && !art.name && !art.expand && !art.inline) {
-      const name = value.path[0];
+      const name = path[0];
       if (path.length === 1 && !name.args && !name.cardinality && !name.where) {
         art.name = name;
         delete art.value;
@@ -1130,6 +1191,9 @@ class AstBuildingParser extends BaseParser {
   //  - if `name` is an object, `name.id` is either set, or the (local) name is calculated
   //    from the IDs of all items in `name.path` (for main artifact definitions).
   addDef( art, parent, env, kind, name ) {
+    if (!art)
+      return art; // parser error
+
     if (Array.isArray(name)) {
       const last = name.length && name[name.length - 1];
       art.name = { // A.B.C -> 'C'