Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/GenPoly/Box.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -756,5 +756,5 @@ Type * newType = arg->get_result()->clone(); if ( env ) env->apply( newType ); - std::auto_ptr manager( newType ); + std::unique_ptr manager( newType ); if ( isPolyType( newType ) ) { // if the argument's type is polymorphic, we don't need to box again! @@ -774,5 +774,5 @@ newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); - UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); + UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax? assign->get_args().push_back( new VariableExpr( newObj ) ); assign->get_args().push_back( arg ); Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/InitTweak/InitTweak.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -418,4 +418,6 @@ assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." ); return getCallArg( tuple->get_exprs().front(), pos ); + } else if ( ImplicitCopyCtorExpr * copyCtor = dynamic_cast< ImplicitCopyCtorExpr * >( callExpr ) ) { + return getCallArg( copyCtor->callExpr, pos ); } else { assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() ); @@ -450,6 +452,8 @@ } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) { return handleDerefName( appExpr ); + } else if ( ConstructorExpr * ctorExpr = dynamic_cast< ConstructorExpr * >( func ) ) { + return funcName( getCallArg( ctorExpr->get_callExpr(), 0 ) ); } else { - assertf( false, "Unexpected expression type being called as a function in call expression" ); + assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() ); } } Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/Parser/parser.yy (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 23 21:08:08 2017 -// Update Count : 2704 +// Last Modified On : Sat Aug 26 17:50:19 2017 +// Update Count : 2712 // @@ -120,5 +120,5 @@ %token RESTRICT // C99 %token ATOMIC // C11 -%token FORALL MUTEX VIRTUAL // CFA +%token FORALL MUTEX VIRTUAL // CFA %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 @@ -188,22 +188,21 @@ %type asm_volatile_opt %type handler_predicate_opt -%type when_clause_opt timeout // statements -%type labeled_statement compound_statement expression_statement selection_statement -%type iteration_statement jump_statement -%type with_statement exception_statement asm_statement -%type waitfor_statement -%type fall_through_opt fall_through -%type statement statement_list -%type block_item_list block_item -%type with_clause_opt +%type statement labeled_statement compound_statement +%type statement_decl statement_decl_list statement_list_nodecl +%type selection_statement +%type switch_clause_list_opt switch_clause_list choose_clause_list_opt choose_clause_list %type case_value %type case_clause case_value_list case_label case_label_list -%type switch_clause_list_opt switch_clause_list choose_clause_list_opt choose_clause_list -%type handler_clause finally_clause +%type fall_through fall_through_opt +%type iteration_statement jump_statement +%type expression_statement asm_statement +%type with_statement with_clause_opt +%type exception_statement handler_clause finally_clause %type handler_key +%type when_clause when_clause_opt waitfor timeout +%type waitfor_statement %type waitfor_clause -%type waitfor // declarations @@ -777,16 +776,16 @@ push push local_label_declaration_opt // GCC, local labels - block_item_list // C99, intermix declarations and statements + statement_decl_list // C99, intermix declarations and statements pop '}' { $$ = new StatementNode( build_compound( $5 ) ); } ; -block_item_list: // C99 - block_item - | block_item_list push block_item +statement_decl_list: // C99 + statement_decl + | statement_decl_list push statement_decl { if ( $1 != 0 ) { $1->set_last( $3 ); $$ = $1; } } ; -block_item: +statement_decl: declaration // CFA, new & old style declarations { $$ = new StatementNode( $1 ); } @@ -806,7 +805,7 @@ ; -statement_list: +statement_list_nodecl: statement - | statement_list statement + | statement_list_nodecl statement { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } } ; @@ -818,5 +817,5 @@ selection_statement: - IF '(' push if_control_expression ')' statement %prec THEN + IF '(' push if_control_expression ')' statement %prec THEN // explicitly deal with the shift/reduce conflict on if/else { $$ = new StatementNode( build_if( $4, $6, nullptr ) ); } @@ -893,7 +892,7 @@ switch_clause_list: // CFA - case_label_list statement_list + case_label_list statement_list_nodecl { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); } - | switch_clause_list case_label_list statement_list + | switch_clause_list case_label_list statement_list_nodecl { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); } ; @@ -908,9 +907,9 @@ case_label_list fall_through { $$ = $1->append_last_case( $2 ); } - | case_label_list statement_list fall_through_opt + | case_label_list statement_list_nodecl fall_through_opt { $$ = $1->append_last_case( new StatementNode( build_compound( (StatementNode *)$2->set_last( $3 ) ) ) ); } | choose_clause_list case_label_list fall_through { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( $3 ))); } - | choose_clause_list case_label_list statement_list fall_through_opt + | choose_clause_list case_label_list statement_list_nodecl fall_through_opt { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( (StatementNode *)$3->set_last( $4 ) ) ) ) ) ); } ; @@ -981,9 +980,13 @@ ; +when_clause: + WHEN '(' comma_expression ')' + { $$ = $3; } + ; + when_clause_opt: // empty { $$ = nullptr; } - | WHEN '(' comma_expression ')' - { $$ = $3; } + | when_clause ; @@ -1008,18 +1011,19 @@ waitfor_clause: - when_clause_opt waitfor statement %prec THEN + when_clause_opt waitfor statement %prec THEN { $$ = build_waitfor( $2, $3, $1 ); } | when_clause_opt waitfor statement WOR waitfor_clause { $$ = build_waitfor( $2, $3, $1, $5 ); } - | when_clause_opt timeout statement %prec THEN + | when_clause_opt timeout statement %prec THEN { $$ = build_waitfor_timeout( $2, $3, $1 ); } | when_clause_opt ELSE statement { $$ = build_waitfor_timeout( nullptr, $3, $1 ); } - | when_clause_opt timeout statement WOR when_clause_opt ELSE statement + // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless) + | when_clause_opt timeout statement WOR when_clause ELSE statement { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); } ; waitfor_statement: - when_clause_opt waitfor statement %prec THEN + when_clause_opt waitfor statement %prec THEN { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); } | when_clause_opt waitfor statement WOR waitfor_clause Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/ResolvExpr/AlternativeFinder.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -698,9 +698,4 @@ void AlternativeFinder::visit( UntypedExpr *untypedExpr ) { - bool doneInit = false; - AlternativeFinder funcOpFinder( indexer, env ); - - AlternativeFinder funcFinder( indexer, env ); - { std::string fname = InitTweak::getFunctionName( untypedExpr ); @@ -715,5 +710,9 @@ } + AlternativeFinder funcFinder( indexer, env ); funcFinder.findWithAdjustment( untypedExpr->get_function() ); + // if there are no function alternatives, then proceeding is a waste of time. + if ( funcFinder.alternatives.empty() ) return; + std::list< AlternativeFinder > argAlternatives; findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) ); @@ -725,4 +724,17 @@ // if not tuple assignment, assignment is taken care of as a normal function call Tuples::handleTupleAssignment( *this, untypedExpr, possibilities ); + + // find function operators + AlternativeFinder funcOpFinder( indexer, env ); + NameExpr *opExpr = new NameExpr( "?()" ); + try { + funcOpFinder.findWithAdjustment( opExpr ); + } catch( SemanticError &e ) { + // it's ok if there aren't any defined function ops + } + PRINT( + std::cerr << "known function ops:" << std::endl; + printAlts( funcOpFinder.alternatives, std::cerr, 8 ); + ) AltList candidates; @@ -754,35 +766,21 @@ } // if } // if - } else { - // seek a function operator that's compatible - if ( ! doneInit ) { - doneInit = true; - NameExpr *opExpr = new NameExpr( "?()" ); - try { - funcOpFinder.findWithAdjustment( opExpr ); - } catch( SemanticError &e ) { - // it's ok if there aren't any defined function ops - } - PRINT( - std::cerr << "known function ops:" << std::endl; - printAlts( funcOpFinder.alternatives, std::cerr, 8 ); - ) - } - - for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) { - // check if the type is pointer to function - if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) { - if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) { - referenceToRvalueConversion( funcOp->expr ); - for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { - AltList currentAlt; - currentAlt.push_back( *func ); - currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() ); - makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) ); - } // for - } // if + } + + // try each function operator ?() with the current function alternative and each of the argument combinations + for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) { + // check if the type is pointer to function + if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) { + if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) { + referenceToRvalueConversion( funcOp->expr ); + for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) { + AltList currentAlt; + currentAlt.push_back( *func ); + currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() ); + makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) ); + } // for } // if - } // for - } // if + } // if + } // for } catch ( SemanticError &e ) { errors.append( e ); Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/ResolvExpr/CastCost.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -58,5 +58,7 @@ return Cost::safe; } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { - return convertToReferenceCost( src, refType, indexer, env ); + return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) { + return ptrsCastable( t1, t2, env, indexer ); + }); } else { CastCost converter( dest, indexer, env ); Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/ResolvExpr/ConversionCost.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -40,5 +40,4 @@ #define PRINT(x) #endif - Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) { if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) { @@ -78,5 +77,7 @@ } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) { PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; ) - return convertToReferenceCost( src, refType, indexer, env ); + return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){ + return ptrsAssignable( t1, t2, env ); + }); } else { ConversionCost converter( dest, indexer, env ); @@ -90,14 +91,14 @@ } - Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { + Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) { PRINT( std::cerr << "convert to reference cost..." << std::endl; ) if ( diff > 0 ) { // TODO: document this - Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env ); + Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func ); cost.incReference(); return cost; } else if ( diff < -1 ) { // TODO: document this - Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env ); + Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func ); cost.incReference(); return cost; @@ -110,5 +111,5 @@ return Cost::safe; } else { // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right? - int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env ); + int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer ); PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; ) if ( assignResult < 0 ) { @@ -157,7 +158,7 @@ } - Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) { + Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) { int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth(); - return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env ); + return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env, func ); } Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/ResolvExpr/ConversionCost.h (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -16,4 +16,6 @@ #pragma once +#include // for function + #include "Cost.h" // for Cost #include "SynTree/Visitor.h" // for Visitor @@ -21,9 +23,9 @@ namespace SymTab { -class Indexer; + class Indexer; } // namespace SymTab namespace ResolvExpr { -class TypeEnvironment; + class TypeEnvironment; class ConversionCost : public Visitor { @@ -55,5 +57,6 @@ }; - Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ); + typedef std::function PtrsFunction; + Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ); } // namespace ResolvExpr Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/SymTab/Indexer.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -345,5 +345,5 @@ leaveScope(); - debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl ); + debugPrint( "Adding trait " << aggregateDecl->get_name() << std::endl ); addTrait( aggregateDecl ); } Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/SymTab/Validate.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -467,4 +467,6 @@ return; } + + // handle other traits TraitDecl *traitDecl = indexer->lookupTrait( traitInst->get_name() ); if ( ! traitDecl ) { Index: src/SynTree/Expression.cc =================================================================== --- src/SynTree/Expression.cc (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/SynTree/Expression.cc (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -645,4 +645,8 @@ } } + // ensure that StmtExpr has a result type + if ( ! result ) { + set_result( new VoidType( Type::Qualifiers() ) ); + } } StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) { Index: c/initialization.txt =================================================================== --- src/initialization.txt (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ (revision ) @@ -1,71 +1,0 @@ -From the refrat (5.5) we have our specification: - - \section{Initialization} An expression that is used as an - \nonterm{initializer} is treated as being cast to the type of the - object being initialized. An expression used in an - \nonterm{initializer-list} is treated as being cast to the type of - the aggregate member that it initializes. In either case the cast - must have a single unambiguous - interpretation\index{interpretations}. - -Steps: - -- add a member function "void Resolver::visit( SynTree::DeclStmt -*declStmt )"; for each DeclStmt: - -- do what you need to do to establish correspondences between -expressions in the initializer and pieces of the object to be -initialized - -- for each initializer expression, construct a cast expression that -casts the value of the expression to the type of the corresponding -sub-object - -- invoke the resolver recursively on each cast expression; it's an invariant -of the resolver that attempting to resolve a cast expression results either -in a single resolved expression (corresponding to the unambiguous interpretation -referred to above) or a thrown SemanticError. - -- construct a new initializer from the resolved expressions - -You'll undoubtedly have to play with the CodeGen stuff a bit; I -hacked it to spit out unresolved initializers for file-scope -declarations so that real programs would compile. You'll want to make -sure that resolved initializers for all declarations are being -generated. - - ------- - -More recent email: (I am quoted; Richard is the responder) -> As far as I'm aware, the only way that I could currently get the correct -> results from the unification engine is by feeding it an expression that -> looks like "?=?( ((struct Y)x.y).a, 10 )", then picking out the pieces that -> I need (namely the correct choice for a). Does this seem like a reasonable -> approach to solve this problem? - -No, unfortunately. Initialization isn't being rewritten as assignment, -so you shouldn't allow the particular selection of assignment -operators that happen to be in scope (and which may include -user-defined operators) to guide the type resolution. - -I don't think there is any way to rewrite an initializer as a single -expression and have the resolver just do the right thing. I see the -algorithm as: - -For each alternative interpretation of the designator: - Construct an expression that casts the initializer to the type of - the designator - Construct an AlternativeFinder and use it to find the lowest cost - interpretation of the expression - Add this interpretation to a list of possibilities -Go through the list of possibilities and pick the lowest cost - -As with many things in the resolver, it's conceptually simple but the -implementation may be a bit of a pain. It fits in with functions like -findSingleExpression, findIntegralExpression in Resolver.cc, although -it will be significantly more complicated than any of the existing -ones. - - - Index: src/tests/.expect/ifcond.txt =================================================================== --- src/tests/.expect/ifcond.txt (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) +++ src/tests/.expect/ifcond.txt (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -0,0 +1,3 @@ +x != 0 correct +x != 0 && y == 0 incorrect +x == y correct Index: src/tests/ifcond.c =================================================================== --- src/tests/ifcond.c (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) +++ src/tests/ifcond.c (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -0,0 +1,46 @@ +// -*- Mode: C -*- +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ifcond.c -- +// +// Author : Peter A. Buhr +// Created On : Sat Aug 26 10:13:11 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sat Aug 26 11:13:00 2017 +// Update Count : 11 +// + +#include + +int f( int r ) { return r; } + +int main( void ) { + int x = 4, y = 3; + + if ( int x = 1 ) { + sout | "x != 0 correct" | endl; + } else { + sout | "x == 0 incorrect" | endl; + } // if + + if ( int x = 4, y = 0 ) { // FIXME && distribution + sout | "x != 0 && y != 0 correct" | endl; + } else { + sout | "x != 0 && y == 0 incorrect" | endl; + } // if + + if ( int x = 5, y = f( x ); x == y ) { + sout | "x == y correct" | endl; + } else { + sout | "x != y incorrect" | endl; + } // if +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa ifcond.c" // +// End: // Index: src/tests/multiDimension.c =================================================================== --- src/tests/multiDimension.c (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/tests/multiDimension.c (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -59,4 +59,7 @@ } +// ensure constructed const arrays continue to compile +const int global[1] = { -2 }; + int main() { X abc[4][4] = { Index: src/tests/switch.c =================================================================== --- src/tests/switch.c (revision 2065609d54faba689bd6249eb4c159415fb8bf29) +++ src/tests/switch.c (revision 26238c181d3602cb7a91e2509316bdb5f5fa32eb) @@ -10,11 +10,11 @@ // Created On : Tue Jul 12 06:50:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 4 11:44:29 2016 -// Update Count : 31 +// Last Modified On : Sat Aug 26 10:14:21 2017 +// Update Count : 33 // int f( int i ) { return i; } -int main() { +int main( void ) { int i = 0; switch ( i ) case 3 : i = 1; @@ -100,5 +100,5 @@ j = 5; } // choose -} +} // main // Local Variables: //