src/jdk/nashorn/internal/parser/JSONParser.java

Print this page




 332 
 333         // Capture LBRACKET token.
 334         final long arrayToken = token;
 335         // LBRACKET tested in caller.
 336         next();
 337 
 338         LiteralNode<Expression[]> result = null;
 339         // Prepare to accummulating elements.
 340         final List<Expression> elements = new ArrayList<>();
 341 
 342 loop:
 343         while (true) {
 344             switch (type) {
 345             case RBRACKET:
 346                 next();
 347                 result = LiteralNode.newInstance(arrayToken, finish, elements);
 348                 break loop;
 349 
 350             case COMMARIGHT:
 351                 next();




 352                 break;
 353 
 354             default:
 355                 // Add expression element.
 356                 elements.add(jsonLiteral());
 357                 // Comma between array elements is mandatory in JSON.
 358                 if (type != COMMARIGHT && type != RBRACKET) {
 359                    throw error(AbstractParser.message("expected", ", or ]", type.getNameOrType()));
 360                 }
 361                 break;
 362             }
 363         }
 364 
 365         return result;
 366     }
 367 
 368     /**
 369      * Parse an object literal from the token stream
 370      * @return the object literal as a Node
 371      */
 372     private ObjectNode objectLiteral() {
 373         // Capture LBRACE token.
 374         final long objectToken = token;
 375         // LBRACE tested in caller.
 376         next();
 377 
 378         // Prepare to accumulate elements.
 379         final List<PropertyNode> elements = new ArrayList<>();
 380 
 381         // Create a block for the object literal.
 382 loop:
 383         while (true) {
 384             switch (type) {
 385             case RBRACE:
 386                 next();
 387                 break loop;
 388 
 389             case COMMARIGHT:
 390                 next();




 391                 break;
 392 
 393             default:
 394                 // Get and add the next property.
 395                 final PropertyNode property = propertyAssignment();
 396                 elements.add(property);
 397 
 398                 // Comma between property assigments is mandatory in JSON.
 399                 if (type != RBRACE && type != COMMARIGHT) {
 400                     throw error(AbstractParser.message("expected", ", or }", type.getNameOrType()));
 401                 }
 402                 break;
 403             }
 404         }
 405 
 406         // Construct new object literal.
 407         return new ObjectNode(objectToken, finish, elements);
 408     }
 409 
 410     /**




 332 
 333         // Capture LBRACKET token.
 334         final long arrayToken = token;
 335         // LBRACKET tested in caller.
 336         next();
 337 
 338         LiteralNode<Expression[]> result = null;
 339         // Prepare to accummulating elements.
 340         final List<Expression> elements = new ArrayList<>();
 341 
 342 loop:
 343         while (true) {
 344             switch (type) {
 345             case RBRACKET:
 346                 next();
 347                 result = LiteralNode.newInstance(arrayToken, finish, elements);
 348                 break loop;
 349 
 350             case COMMARIGHT:
 351                 next();
 352                 // check for trailing comma - not allowed in JSON
 353                 if (type == RBRACKET) {
 354                     throw error(AbstractParser.message("trailing.comma.in.json", type.getNameOrType()));
 355                 }
 356                 break;
 357 
 358             default:
 359                 // Add expression element.
 360                 elements.add(jsonLiteral());
 361                 // Comma between array elements is mandatory in JSON.
 362                 if (type != COMMARIGHT && type != RBRACKET) {
 363                    throw error(AbstractParser.message("expected", ", or ]", type.getNameOrType()));
 364                 }
 365                 break;
 366             }
 367         }
 368 
 369         return result;
 370     }
 371 
 372     /**
 373      * Parse an object literal from the token stream
 374      * @return the object literal as a Node
 375      */
 376     private ObjectNode objectLiteral() {
 377         // Capture LBRACE token.
 378         final long objectToken = token;
 379         // LBRACE tested in caller.
 380         next();
 381 
 382         // Prepare to accumulate elements.
 383         final List<PropertyNode> elements = new ArrayList<>();
 384 
 385         // Create a block for the object literal.
 386 loop:
 387         while (true) {
 388             switch (type) {
 389             case RBRACE:
 390                 next();
 391                 break loop;
 392 
 393             case COMMARIGHT:
 394                 next();
 395                 // check for trailing comma - not allowed in JSON
 396                 if (type == RBRACE) {
 397                     throw error(AbstractParser.message("trailing.comma.in.json", type.getNameOrType()));
 398                 }
 399                 break;
 400 
 401             default:
 402                 // Get and add the next property.
 403                 final PropertyNode property = propertyAssignment();
 404                 elements.add(property);
 405 
 406                 // Comma between property assigments is mandatory in JSON.
 407                 if (type != RBRACE && type != COMMARIGHT) {
 408                     throw error(AbstractParser.message("expected", ", or }", type.getNameOrType()));
 409                 }
 410                 break;
 411             }
 412         }
 413 
 414         // Construct new object literal.
 415         return new ObjectNode(objectToken, finish, elements);
 416     }
 417 
 418     /**