//
//  RSEXP.m
//  Rgui
//
//  Created by Simon Urbanek on Wed Dec 10 2003.
//  Copyright (c) 2003 __MyCompanyName__. All rights reserved.
//

#import "RSEXP.h"


@implementation RSEXP

- (RSEXP*) initWithSEXP: (SEXP) ct
{
    xp=ct;
    attr=nil;
    if (ATTRIB(ct) && TYPEOF(ATTRIB(ct))!=NILSXP && ATTRIB(ct)!=ct)
        attr=[[RSEXP alloc] initWithSEXP: ATTRIB(ct)];
    [self logMe];
    return self;
}

- (RSEXP*) initWithString: (NSString*) str
{
    PROTECT(xp=allocVector(STRSXP, 1));
    SET_VECTOR_ELT(xp, 0, mkChar([str cString]));
    UNPROTECT(1);
    attr=nil;
    [self logMe];
    return self;
}

- (RSEXP*) initWithDoubleArray: (double*) arr length: (int) len
{
    if (len<0) len=0;
    PROTECT(xp=allocVector(REALSXP, len));
    if (len>0)
        memcpy(REAL(xp),arr,sizeof(double)*len);
    UNPROTECT(1);
    attr=nil;
    [self logMe];
    return self;    
}

- (RSEXP*) initWithIntArray: (int*) arr length: (int) len
{
    if (len<0) len=0;
    PROTECT(xp=allocVector(INTSXP, len));
    if (len>0)
        memcpy(INTEGER(xp),arr,sizeof(int)*len);
    UNPROTECT(1);
    attr=nil;
    [self logMe];
    return self;    
}

- (int) type
{
    return TYPEOF(xp);
}

- (NSString*) typeName
{
    switch(TYPEOF(xp)) {
        case NILSXP: return @"NULL";
        case SYMSXP: return @"symbol";
        case LISTSXP: return @"list";
        case CLOSXP: return @"closure";
        case ENVSXP: return @"environment";
        case PROMSXP: return @"promise";
        case LANGSXP: return @"lang.construct";
        case SPECIALSXP: return @"special";
        case BUILTINSXP: return @"built-in";
        case CHARSXP: return @"scalar-str";
        case LGLSXP: return @"logical";
        case INTSXP: return @"integer";
        case REALSXP: return @"real";
        case CPLXSXP: return @"complex";
        case STRSXP: return @"string";
        case DOTSXP: return @"...";
        case ANYSXP: return @"any";
        case VECSXP: return @"array";
        case EXPRSXP: return @"expressions";
        case BCODESXP: return @"byte-code";
        case EXTPTRSXP: return @"ext.ptr";
        case WEAKREFSXP: return @"weak-reference";
    }
    
    return @"<unknown>";
}

- (void) logMe
{
    NSLog(@"RSEXP, %@[%d]",[self typeName],[self length]);
}

- (int) length
{
    switch (TYPEOF(xp)) {
        case VECSXP:
        case STRSXP:
        case INTSXP:
        case REALSXP:
        case CPLXSXP:
        case LGLSXP:
        case EXPRSXP:
            return LENGTH(xp);
    }
    return 1;
}

- (RSEXP*) attribute
{
    return attr;
}

- (SEXP) directSEXP
{
    return xp;
}

- (RSEXP*) elementAt: (int) index
{
    if (index<0 || index>=LENGTH(xp)) return nil; //XX
    return [[RSEXP alloc] initWithSEXP: VECTOR_ELT(xp, index)];
}

- (double*) doubleArray
{
    return (TYPEOF(xp)==REALSXP)?REAL(xp):NULL;
}

- (int*) intArray
{
    return (TYPEOF(xp)==INTSXP)?INTEGER(xp):NULL;
}

- (NSString*) string
{
    return (TYPEOF(xp)==STRSXP && LENGTH(xp)>0)?[NSString stringWithCString: (char*) STRING_ELT(xp, 0)]:nil;
}

- (NSArray*) array
{
    if (TYPEOF(xp)==STRSXP) {
        int i=0, l=LENGTH(xp);
        id *cont=malloc(sizeof(id)*l);
        while (i<l) {
            cont[i]=[[NSString alloc] initWithCString: (char*) STRING_ELT(xp, i)];
            i++;
        }
        return [NSArray arrayWithObjects: cont count:l];
    }
    if (TYPEOF(xp)==VECSXP) {
        int i=0, l=LENGTH(xp);
        id *cont=malloc(sizeof(id)*l);
        while (i<l) {
            cont[i]=[[RSEXP alloc] initWithSEXP: VECTOR_ELT(xp, i)];
            i++;
        }
        return [NSArray arrayWithObjects: cont count:l];
    }
    return nil;
}

- (id) value
{
    switch (TYPEOF(xp)) {
        case NILSXP: return nil;
/*
        case STRSXP:
            if (LENGTH(xp)==1) {
                */
            }
    return nil;
}

@end