Changeset 630a82a


Ignore:
Timestamp:
Apr 8, 2016, 5:22:29 PM (6 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
3da470c
Parents:
3d9b5da
Message:

C99 compound literals now work, comment rational code, clean up hoisting AddVisit?

Location:
src
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    r3d9b5da r630a82a  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar 13 12:34:38 2016
    13 // Update Count     : 272
     12// Last Modified On : Fri Apr  8 15:43:05 2016
     13// Update Count     : 296
    1414//
    1515
     
    2222
    2323#include "ParseNode.h"
     24#include "TypeData.h"
    2425#include "SynTree/Constant.h"
    2526#include "SynTree/Expression.h"
     27#include "SynTree/Declaration.h"
    2628#include "Common/UnimplementedError.h"
    2729#include "parseutility.h"
     
    872874}
    873875
     876
     877CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
     878CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
     879
     880CompoundLiteralNode::~CompoundLiteralNode() {
     881        delete kids;
     882        delete type;
     883}
     884
     885CompoundLiteralNode *CompoundLiteralNode::clone() const {
     886        return new CompoundLiteralNode( *this );
     887}
     888
     889void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
     890        os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
     891
     892        os << string( indent + 2, ' ' ) << "type:" << endl;
     893        if ( type != 0 )
     894                type->print( os, indent + 4 );
     895
     896        os << string( indent + 2, ' ' ) << "initialization:" << endl;
     897        if ( kids != 0 )
     898                kids->printList( os, indent + 4 );
     899}
     900
     901void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
     902        os << "( ";
     903        if ( type ) type->print( os );
     904        os << ", ";
     905        if ( kids ) kids->printOneLine( os );
     906        os << ") ";
     907}
     908
     909Expression *CompoundLiteralNode::build() const {
     910        Declaration * newDecl = type->build();                          // compound literal type
     911        if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
     912                return new CompoundLiteralExpr( newDeclWithType->get_type(), kids->build() );
     913        // these types do not have associated type information
     914        } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
     915                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), kids->build() );
     916        } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
     917                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), kids->build() );
     918        } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
     919                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), kids->build() );
     920        } else {
     921                assert( false );
     922        } // if
     923}
     924
     925
    874926ExpressionNode *flattenCommas( ExpressionNode *list ) {
    875927        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
  • src/Parser/ParseNode.h

    r3d9b5da r630a82a  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:26:35 2016
    13 // Update Count     : 190
     12// Last Modified On : Fri Apr  8 16:27:20 2016
     13// Update Count     : 205
    1414//
    1515
     
    538538};
    539539
     540class CompoundLiteralNode : public ExpressionNode {
     541  public:
     542        CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
     543        CompoundLiteralNode( const CompoundLiteralNode &type );
     544        ~CompoundLiteralNode();
     545
     546        virtual CompoundLiteralNode *clone() const;
     547
     548        DeclarationNode *get_type() const { return type; }
     549        CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
     550
     551        InitializerNode *get_initializer() const { return kids; }
     552        CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
     553
     554        void print( std::ostream &, int indent = 0 ) const;
     555        void printOneLine( std::ostream &, int indent = 0 ) const;
     556
     557        virtual Expression *build() const;
     558  private:
     559        DeclarationNode *type;
     560        InitializerNode *kids;
     561};
     562
    540563template< typename SynTreeType, typename NodeType >
    541564void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
  • src/Parser/parser.yy

    r3d9b5da r630a82a  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Mar 24 16:16:16 2016
    13 // Update Count     : 1498
     12// Last Modified On : Fri Apr  8 16:21:55 2016
     13// Update Count     : 1508
    1414//
    1515
     
    372372                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
    373373        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    374                 { $$ = 0; }
     374                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
    375375        | postfix_expression '{' argument_expression_list '}' // CFA
    376376                {
  • src/SymTab/AddVisit.h

    r3d9b5da r630a82a  
    99// Author           : Richard C. Bilson
    1010// Created On       : Sun May 17 16:14:32 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Tue Jul 14 12:26:17 2015
    13 // Update Count     : 4
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Apr  7 14:42:21 2016
     13// Update Count     : 5
    1414//
    1515
     
    2727
    2828        template< typename Visitor >
    29         inline void addVisitStatement( Statement *stmt, Visitor &visitor ) {
    30                 maybeAccept( stmt, visitor );
    31 ///   if ( ! declsToAdd.empty() ) {
    32 ///     CompoundStmt *compound = new CompoundStmt( noLabels );
    33 ///     compound->get_kids().push_back( stmt );
    34 ///     addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() );
    35 ///   }
    36         }
    37 
    38         template< typename Visitor >
    3929        inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) {
    4030                addVisitStatementList( compoundStmt->get_kids(), visitor );
    41         }
    42 
    43         template< typename Visitor >
    44         inline void addVisit(IfStmt *ifStmt, Visitor &visitor) {
    45                 addVisitStatement( ifStmt->get_thenPart(), visitor );
    46                 addVisitStatement( ifStmt->get_elsePart(), visitor );
    47                 maybeAccept( ifStmt->get_condition(), visitor );
    48         }
    49 
    50         template< typename Visitor >
    51         inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) {
    52                 addVisitStatement( whileStmt->get_body(), visitor );
    53                 maybeAccept( whileStmt->get_condition(), visitor );
    54         }
    55 
    56         template< typename Visitor >
    57         inline void addVisit(ForStmt *forStmt, Visitor &visitor) {
    58                 addVisitStatement( forStmt->get_body(), visitor );
    59                 acceptAll( forStmt->get_initialization(), visitor );
    60                 maybeAccept( forStmt->get_condition(), visitor );
    61                 maybeAccept( forStmt->get_increment(), visitor );
    6231        }
    6332
     
    7443        }
    7544
    76         template< typename Visitor >
    77         inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
    78                 addVisitStatementList( caseStmt->get_statements(), visitor );
    79                 maybeAccept( caseStmt->get_condition(), visitor );
    80         }
    81 
    82         template< typename Visitor >
    83         inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) {
    84                 addVisitStatement( cathStmt->get_body(), visitor );
    85                 maybeAccept( cathStmt->get_decl(), visitor );
    86         }
     45        // template< typename Visitor >
     46        // inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
     47        //      addVisitStatementList( caseStmt->get_statements(), visitor );
     48        //      maybeAccept( caseStmt->get_condition(), visitor );
     49        // }
    8750} // namespace SymTab
    8851
  • src/SymTab/Validate.cc

    r3d9b5da r630a82a  
    1010// Created On       : Sun May 17 21:50:04 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:31:39 2016
    13 // Update Count     : 226
     12// Last Modified On : Thu Apr  7 16:45:30 2016
     13// Update Count     : 243
    1414//
    1515
     
    4040#include <list>
    4141#include <iterator>
     42#include "Common/utility.h"
     43#include "Common/UniqueName.h"
    4244#include "Validate.h"
    4345#include "SynTree/Visitor.h"
    4446#include "SynTree/Mutator.h"
    4547#include "SynTree/Type.h"
     48#include "SynTree/Expression.h"
    4649#include "SynTree/Statement.h"
    4750#include "SynTree/TypeSubstitution.h"
     
    4952#include "FixFunction.h"
    5053// #include "ImplementationType.h"
    51 #include "Common/utility.h"
    52 #include "Common/UniqueName.h"
     54#include "GenPoly/DeclMutator.h"
    5355#include "AddVisit.h"
    5456#include "MakeLibCfa.h"
     
    7072
    7173                virtual void visit( CompoundStmt *compoundStmt );
    72                 virtual void visit( IfStmt *ifStmt );
    73                 virtual void visit( WhileStmt *whileStmt );
    74                 virtual void visit( ForStmt *forStmt );
    7574                virtual void visit( SwitchStmt *switchStmt );
    7675                virtual void visit( ChooseStmt *chooseStmt );
    77                 virtual void visit( CaseStmt *caseStmt );
    78                 virtual void visit( CatchStmt *catchStmt );
     76                // virtual void visit( CaseStmt *caseStmt );
    7977          private:
    8078                HoistStruct();
     
    144142
    145143                virtual void visit( CompoundStmt *compoundStmt );
    146                 virtual void visit( IfStmt *ifStmt );
    147                 virtual void visit( WhileStmt *whileStmt );
    148                 virtual void visit( ForStmt *forStmt );
    149144                virtual void visit( SwitchStmt *switchStmt );
    150145                virtual void visit( ChooseStmt *chooseStmt );
    151                 virtual void visit( CaseStmt *caseStmt );
    152                 virtual void visit( CatchStmt *catchStmt );
     146                // virtual void visit( CaseStmt *caseStmt );
    153147
    154148                AutogenerateRoutines() : functionNesting( 0 ) {}
     
    166160                /// and return something if the return type is non-void.
    167161                static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
    168 
    169162          private:
    170163                virtual void visit( FunctionDecl * functionDecl );
     
    202195        };
    203196
     197        class CompoundLiteral : public GenPoly::DeclMutator {
     198                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
     199
     200                virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
     201                virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
     202        };
     203
    204204        void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
    205205                Pass1 pass1;
    206206                Pass2 pass2( doDebug, 0 );
    207207                Pass3 pass3( 0 );
     208                CompoundLiteral compoundliteral;
     209
    208210                EliminateTypedef::eliminateTypedef( translationUnit );
    209211                HoistStruct::hoistStruct( translationUnit );
     
    211213                acceptAll( translationUnit, pass2 );
    212214                ReturnChecker::checkFunctionReturns( translationUnit );
     215                mutateAll( translationUnit, compoundliteral );
    213216                AutogenerateRoutines::autogenerateRoutines( translationUnit );
    214217                acceptAll( translationUnit, pass3 );
     
    292295        }
    293296
    294         void HoistStruct::visit( IfStmt *ifStmt ) {
    295                 addVisit( ifStmt, *this );
    296         }
    297 
    298         void HoistStruct::visit( WhileStmt *whileStmt ) {
    299                 addVisit( whileStmt, *this );
    300         }
    301 
    302         void HoistStruct::visit( ForStmt *forStmt ) {
    303                 addVisit( forStmt, *this );
    304         }
    305 
    306297        void HoistStruct::visit( SwitchStmt *switchStmt ) {
    307298                addVisit( switchStmt, *this );
     
    312303        }
    313304
    314         void HoistStruct::visit( CaseStmt *caseStmt ) {
    315                 addVisit( caseStmt, *this );
    316         }
    317 
    318         void HoistStruct::visit( CatchStmt *cathStmt ) {
    319                 addVisit( cathStmt, *this );
    320         }
     305        // void HoistStruct::visit( CaseStmt *caseStmt ) {
     306        //      addVisit( caseStmt, *this );
     307        // }
    321308
    322309        void Pass1::visit( EnumDecl *enumDecl ) {
     
    874861        }
    875862
    876         void AutogenerateRoutines::visit( IfStmt *ifStmt ) {
    877                 visitStatement( ifStmt );
    878         }
    879 
    880         void AutogenerateRoutines::visit( WhileStmt *whileStmt ) {
    881                 visitStatement( whileStmt );
    882         }
    883 
    884         void AutogenerateRoutines::visit( ForStmt *forStmt ) {
    885                 visitStatement( forStmt );
    886         }
    887 
    888863        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
    889864                visitStatement( switchStmt );
     
    894869        }
    895870
    896         void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
    897                 visitStatement( caseStmt );
    898         }
    899 
    900         void AutogenerateRoutines::visit( CatchStmt *cathStmt ) {
    901                 visitStatement( cathStmt );
    902         }
     871        // void AutogenerateRoutines::visit( CaseStmt *caseStmt ) {
     872        //      visitStatement( caseStmt );
     873        // }
    903874
    904875        void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
     
    10801051        }
    10811052
     1053        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
     1054                storageclass = objectDecl->get_storageClass();
     1055                DeclarationWithType * temp = Mutator::mutate( objectDecl );
     1056                storageclass = DeclarationNode::NoStorageClass;
     1057                return temp;
     1058        }
     1059
     1060        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
     1061                // transform [storage_class] ... (struct S){ 3, ... };
     1062                // into [storage_class] struct S temp =  { 3, ... };
     1063                static UniqueName indexName( "_compLit" );
     1064
     1065                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageclass, LinkageSpec::C, 0, compLitExpr->get_type(), compLitExpr->get_initializer() );
     1066                compLitExpr->set_type( 0 );
     1067                compLitExpr->set_initializer( 0 );
     1068                delete compLitExpr;
     1069                DeclarationWithType * newtempvar = mutate( tempvar );
     1070                addDeclaration( newtempvar );                                   // add modified temporary to current block
     1071                return new VariableExpr( newtempvar );
     1072        }
    10821073} // namespace SymTab
    10831074
  • src/SynTree/Expression.cc

    r3d9b5da r630a82a  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Dec 09 14:10:29 2015
    13 // Update Count     : 34
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Apr  8 17:16:23 2016
     13// Update Count     : 40
    1414//
    1515
     
    2222
    2323#include "Type.h"
     24#include "Initializer.h"
    2425#include "Expression.h"
    2526#include "Declaration.h"
     
    443444
    444445
     446CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
     447        add_result( type->clone() );
     448}
     449
     450CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
     451
     452CompoundLiteralExpr::~CompoundLiteralExpr() {
     453        delete initializer;
     454        delete type;
     455}
     456
     457void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
     458        os << "Compound Literal Expression: " << std::endl;
     459        if ( type ) type->print( os, indent + 2 );
     460        if ( initializer ) initializer->print( os, indent + 2 );
     461}
     462
    445463
    446464std::ostream & operator<<( std::ostream & out, Expression * expr ) {
  • src/SynTree/Expression.h

    r3d9b5da r630a82a  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Rob Schluntz
    12 // Last Modified On : Wed Dec 09 14:10:21 2015
    13 // Update Count     : 19
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Apr  8 17:18:06 2016
     13// Update Count     : 21
    1414//
    1515
     
    557557};
    558558
     559/// CompoundLiteralExpr represents a C99 'compound literal'
     560class CompoundLiteralExpr : public Expression {
     561  public:
     562        CompoundLiteralExpr( Type * type, Initializer * initializer );
     563        CompoundLiteralExpr( const CompoundLiteralExpr &other );
     564        ~CompoundLiteralExpr();
     565
     566        Type * get_type() const { return type; }
     567        void set_type( Type * t ) { type = t; }
     568
     569        Initializer * get_initializer() const { return initializer; }
     570        void set_initializer( Initializer * i ) { initializer = i; }
     571
     572        virtual CompoundLiteralExpr *clone() const { return new CompoundLiteralExpr( *this ); }
     573        virtual void accept( Visitor &v ) { v.visit( this ); }
     574        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     575        virtual void print( std::ostream &os, int indent = 0 ) const;
     576  private:
     577        Type * type;
     578        Initializer * initializer;
     579};
     580
    559581std::ostream & operator<<( std::ostream & out, Expression * expr );
    560582
  • src/SynTree/Mutator.cc

    r3d9b5da r630a82a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:28:20 2016
    13 // Update Count     : 12
     12// Last Modified On : Fri Apr  1 18:05:16 2016
     13// Update Count     : 16
    1414//
    1515
     
    336336}
    337337
     338Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
     339        mutateAll( compLitExpr->get_results(), *this );
     340        compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
     341        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
     342        return compLitExpr;
     343}
     344
    338345Type *Mutator::mutate( VoidType *voidType ) {
    339346        mutateAll( voidType->get_forall(), *this );
  • src/SynTree/Mutator.h

    r3d9b5da r630a82a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:33:11 2016
    13 // Update Count     : 9
     12// Last Modified On : Fri Apr  1 17:26:56 2016
     13// Update Count     : 10
    1414//
    1515#include <cassert>
     
    7676        virtual Expression* mutate( AsmExpr *asmExpr );
    7777        virtual Expression* mutate( UntypedValofExpr *valofExpr );
     78        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
    7879
    7980        virtual Type* mutate( VoidType *basicType );
  • src/SynTree/SynTree.h

    r3d9b5da r630a82a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:29:00 2016
    13 // Update Count     : 4
     12// Last Modified On : Fri Apr  1 16:47:44 2016
     13// Update Count     : 5
    1414//
    1515
     
    8181class AsmExpr;
    8282class UntypedValofExpr;
     83class CompoundLiteralExpr;
    8384
    8485class Type;
  • src/SynTree/Visitor.cc

    r3d9b5da r630a82a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:29:23 2016
    13 // Update Count     : 16
     12// Last Modified On : Fri Apr  1 18:05:13 2016
     13// Update Count     : 18
    1414//
    1515
     
    284284}
    285285
     286void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
     287        acceptAll( compLitExpr->get_results(), *this );
     288        maybeAccept( compLitExpr->get_type(), *this );
     289        maybeAccept( compLitExpr->get_initializer(), *this );
     290}
     291
    286292void Visitor::visit( VoidType *voidType ) {
    287293        acceptAll( voidType->get_forall(), *this );
  • src/SynTree/Visitor.h

    r3d9b5da r630a82a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar  2 17:33:35 2016
    13 // Update Count     : 6
     12// Last Modified On : Fri Apr  1 17:26:55 2016
     13// Update Count     : 7
    1414//
    1515
     
    7676        virtual void visit( AsmExpr *asmExpr );
    7777        virtual void visit( UntypedValofExpr *valofExpr );
     78        virtual void visit( CompoundLiteralExpr *compLitExpr );
    7879
    7980        virtual void visit( VoidType *basicType );
  • src/examples/rational.c

    r3d9b5da r630a82a  
    66// file "LICENCE" distributed with Cforall.
    77//
    8 // rational.c --
     8// rational.c -- test rational number package
    99//
    1010// Author           : Peter A. Buhr
    1111// Created On       : Mon Mar 28 08:43:12 2016
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Apr  7 17:25:44 2016
    14 // Update Count     : 20
     13// Last Modified On : Fri Apr  8 11:27:48 2016
     14// Update Count     : 21
    1515//
    1616
  • src/libcfa/rational

    r3d9b5da r630a82a  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // rational --
     7// rational -- Rational numbers are numbers written as a ratio, i.e., as a fraction, where the numerator (top number)
     8//     and the denominator (bottom number) are whole numbers. When creating and computing with rational numbers, results
     9//     are constantly reduced to keep the numerator and denominator as small as possible.
    810//
    911// Author           : Peter A. Buhr
    1012// Created On       : Wed Apr  6 17:56:25 2016
    1113// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Apr  7 17:23:36 2016
    13 // Update Count     : 9
     14// Last Modified On : Fri Apr  8 11:38:27 2016
     15// Update Count     : 15
    1416//
    1517
    1618#include "iostream"
    1719
     20// implementation
    1821struct Rational {
    1922        long int numerator, denominator;                                        // invariant: denominator > 0
    2023}; // Rational
    2124
     25// constants
    2226extern struct Rational 0;
    2327extern struct Rational 1;
    2428
    25 long int gcd( long int a, long int b );
    26 long int simplify( long int *n, long int *d );
    27 Rational rational();                                                                    // constructor
    28 Rational rational( long int n );                                                // constructor
    29 Rational rational( long int n, long int d );                    // constructor
     29// constructors
     30Rational rational();
     31Rational rational( long int n );
     32Rational rational( long int n, long int d );
     33
     34// getter/setter for numerator/denominator
    3035long int numerator( Rational r );
    3136long int numerator( Rational r, long int n );
     37long int denominator( Rational r );
    3238long int denominator( Rational r, long int d );
     39
     40// comparison
    3341int ?==?( Rational l, Rational r );
    3442int ?!=?( Rational l, Rational r );
     
    3745int ?>?( Rational l, Rational r );
    3846int ?>=?( Rational l, Rational r );
     47
     48// arithmetic
    3949Rational -?( Rational r );
    4050Rational ?+?( Rational l, Rational r );
     
    4252Rational ?*?( Rational l, Rational r );
    4353Rational ?/?( Rational l, Rational r );
     54
     55// conversion
    4456double widen( Rational r );
    4557Rational narrow( double f, long int md );
     58
     59// I/O
    4660forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, Rational * );
    4761forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, Rational );
  • src/libcfa/rational.c

    r3d9b5da r630a82a  
    1111// Created On       : Wed Apr  6 17:54:28 2016
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Apr  7 17:28:03 2016
    14 // Update Count     : 12
     13// Last Modified On : Fri Apr  8 15:39:17 2016
     14// Update Count     : 17
    1515//
    1616
     
    2323} // extern
    2424
     25
     26// constants
     27
    2528struct Rational 0 = {0, 1};
    2629struct Rational 1 = {1, 1};
    2730
    28 // Calculate the greatest common denominator of two numbers, the first of which may be negative.  It is used to reduce
    29 // rationals.
    30 
    31 long int gcd( long int a, long int b ) {
     31
     32// helper
     33
     34// Calculate greatest common denominator of two numbers, the first of which may be negative. Used to reduce rationals.
     35static long int gcd( long int a, long int b ) {
    3236    for ( ;; ) {                                                                                // Euclid's algorithm
    3337                long int r = a % b;
     
    3943} // gcd
    4044
    41 long int simplify( long int *n, long int *d ) {
     45static long int simplify( long int *n, long int *d ) {
    4246    if ( *d == 0 ) {
    4347                serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl;
     
    4852} // Rationalnumber::simplify
    4953
    50 Rational rational() {                                                                   // constructor
    51 //    r = (Rational){ 0, 1 };
    52         Rational t = { 0, 1 };
    53         return t;
     54
     55// constructors
     56
     57Rational rational() {
     58    return (Rational){ 0, 1 };
     59//      Rational t = { 0, 1 };
     60//      return t;
    5461} // rational
    5562
    56 Rational rational( long int n ) {                                               // constructor
    57 //    r = (Rational){ n, 1 };
    58         Rational t = { n, 1 };
    59         return t;
     63Rational rational( long int n ) {
     64    return (Rational){ n, 1 };
     65//      Rational t = { n, 1 };
     66//      return t;
    6067} // rational
    6168
    62 Rational rational( long int n, long int d ) {                   // constructor
     69Rational rational( long int n, long int d ) {
    6370    long int t = simplify( &n, &d );                                    // simplify
    6471//    r = (Rational){ n / t, d / t };
     
    6673        return t;
    6774} // rational
     75
     76
     77// getter/setter for numerator/denominator
    6878
    6979long int numerator( Rational r ) {
     
    7989} // numerator
    8090
     91long int denominator( Rational r ) {
     92    return r.denominator;
     93} // denominator
     94
    8195long int denominator( Rational r, long int d ) {
    8296    long int prev = r.denominator;
     
    87101} // denominator
    88102
     103
     104// comparison
     105
    89106int ?==?( Rational l, Rational r ) {
    90107    return l.numerator * r.denominator == l.denominator * r.numerator;
     
    110127    return ! ( l < r );
    111128} // ?>=?
     129
     130
     131// arithmetic
    112132
    113133Rational -?( Rational r ) {
     
    149169    return t;
    150170} // ?/?
     171
     172
     173// conversion
    151174
    152175double widen( Rational r ) {
     
    188211} // narrow
    189212
     213
     214// I/O
     215
    190216forall( dtype istype | istream( istype ) )
    191217istype * ?|?( istype *is, Rational *r ) {
Note: See TracChangeset for help on using the changeset viewer.