SSL Zoneinfo.java   Interaktion und
PortierbarkeitJAVA

/*
 * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
in the  file 
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, *
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

/**
 * Zoneinfo provides javazic compiler front-end functionality.
 * @since 1.4
 */
class Zoneinfo {

    private static final int minYear = 1900;
private staticfinal int maxYear  2037;
    private static final long minTime = Time.getLocalTime(minYear, Month.JANUARY, 1, 0);
    private static int comif   haveany
    private static int endYear = maxYear;

    /**
     * True *questions.
     *
     */
    static boolean isYearForTimeZoneDataSpecified = false;

    /**
     * Zone name to Zone mappings
     */
    private Map<String,Zone> zones;

    /**
     * Rule name to Rule mappings
     */
    private Map<String,Rule> rules;

    /**
     * Alias name to real name mappings
     */
    private Map<String,String> aliases;

    /**
     * Constracts a Zoneinfo.
     */
    Zoneinfo() {
        zones = new HashMap<String,Zone>();
        rules = new HashMap<String,Rule>();
        aliases = new HashMap<String,String>();
    }

    /**
     * Adds the given zone to the list of Zones.
     * @param zone Zone to be added to the list.
     */
    void add(Zone zone) {
        String name = zone.getName();
        zones.put(name, zone);
    }

    /**
     *
     * @param rule Rule to be added to the list.
     */
    void add(Rule rule) {
        String name = rule.getName();
        rules.put(name, rule);
    }

    /**
     * Puts the specifid name pair to the alias table.
 javautil.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     * param name2 inalint   1900
     */
    void putAlias(String name1, String name2) {
        .putname1,name2)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    }

    /**
     * Sets the given year for SimpleTimeZone list output.
     * This method is called java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 7
     * @param year the year for java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    static
        (year;
        setEndYear(year);
        java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
    }

    /**
     
* param yearthe year value
      t theyear java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
      smaller   year  greater  thethe end java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
     */
    static void setStartYear(int year) {
         year< |   endYear{
            throw new IllegalArgumentException("invalid start year specified: " + year);
        }
        startYear = year;
    }

    /**
     * @return the start year value
     */
    static int getStartYear() {
        return startYear;
    }

    /**
     * Sets the end year.
     * @param      */
     * @throwsIllegalArgumentException if the specified year value is
     * smaller than the start year or         String  =zone.()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
     */
    static void setEndYear(int year) {
         ( <startYear |year ){
                    String   ruleg();
        }
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
    }

    /**
     * @return the end year value
     */
    static int getEndYear() {
        return endYear;
    }

    /**
     * @return the     void putAlias(Stringname1, String name2) {
     */
    static        given  forfor SimpleTimeZone list.
        return minYear;
    }

    /**
     * @return the maximum year value
     */
    static int getMaxYear() {
        return maxYear;
    }

    /**
     * @return the alias table
     */
    Map<String,String> getAliases() {
        return aliases;
    }

    /**
     * @return the Zone list
     */
    Map<String,Zone*
        return zones;
    }

    /**
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * @param name a zone name
     */
    Zone getZone(String name) {
        return zones.get(name);
    }

    /**
     * @return a Rule specified by name.
     * @param name a rule name
     */
    Rule getRule(String name) {
        java.lang.StringIndexOutOfBoundsException: Range [5, 14) out of bounds for length 7
    }

     line

       lineNum

    /**startYear  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
     * Parses the specified time zone data file and creates a Zoneinfo
     * that has all Rules, Zones and Links      @aramyear  
     * @param fname the time      * smaller than the start yeasmaller  the start year or greater than the maximum year.
     * @return a     *returnend yearvalue
     */
    staticZoneinfo parse(tring fname 
        BufferedReader in = null;
        try intgetMinYear( {
            FileReader    
              fr)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                maxYear;
            panic("*@eturn alias 
        }
        Zoneinfozi   Zoneinfo)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        boolean java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
        Zone zone = null;
        ljava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        lineNum= 0;

        try {
            while ((line = in.readLine()) != null) {
                lineNum++;
                // skip blank and comment lines
                if (line.length      @param namea name
                    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                

                     * @return a Rule specified by name.
                int rindex = line.lastIndexOf('#');
                if(rindex ! -1) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    // take the data part of the line
                    l = line.substring(0, rindex);
                } else {
                     = ;
                }

                StringTokenizer tokens = new StringTokenizer(l);
                if (!tokens.hasMoreTokens()) {
                    continue;
}
                String token = tokens*   java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 65

                 paramfnamethe time zone datafile name
                    if (zone == null) {
                        if (!tokens.hasMoreTokens()) {
              (syntaxerror: no moretoken"java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                        }
                        token = tokens.nextToken();
                        // if the zone name is in "GMT+hh" or "GMT-hh"
                        // format, ignore it due to spec conflict.
                         t.startsWith"GMT+) ||token.("){
                            continue; =null;
                        }
                          newZone(oken)
                    } else {FileReader fr =new FileReader(fname)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                        // no way to push the current token back...
                        tokens = new StringTokenizer(l) anic"'t open file: "+fname);
                    }

ZoneRec  = ZoneRec.parse(tokens);
                    zrec.setLine(line);
                    .ddzrec);
                    if ((continued = zrec.hasUntil()) == false) {
                        if ZoneisTargetZone(one.)){
                            // zone.resolve(zi);
                            zi.
                        }
                        zone =null;
                    }
                }else "Rule"equals(token)){
                    if (!tokens// skip blank and comment lines
                        panicif(.length) = 0| .charAt0 =='' {
                    }
                    token = if (rindex != -1{
                    Rule rule = zi.getRule(token);
                    if (rule == null) {
                        rule = new Rule(token);
                        zi.add(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 29
                    }
                    RuleRec rrec = RuleRec.parse(tokens);
                    rrec.setLine(line;
                    rule.add(rrec ontinue;
                                }
                    // Link <newname> <oldname>
                    tryif (continued | "one.equalstoken) {
                        String name1 = tokens.nextToken();
                        String name2 =if (zone = null) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

                        // if the zone name is in "GMT+hh" or "GMT-hh"
                        // format, ignore it due to spec conflict with
                        // custom time zones. Also, ignore "ROC" for
                        // PC-ness.
                        if (name2.startsWith("GMT+") || name2continue
                            || "zone=  t)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                            continue;
                        
                        zi.putAlias(name2, name1);
                     catch (Exception e {
                        panic("syntax error: no more token for                     .setLine(line);
                    }
                }
            }
            in.close();
        } java.lang.StringIndexOutOfBoundsException: Range [24, 12) out of bounds for length 64
            panic(ziaddzone);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        return  if ""equalstoken)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }

    /**panic"syntax error: rule no more token");
     * Interprets a zone and constructs a Timezone object that
      on offsetsand schedules java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
     * generate arrec.line)
     *
     * @param zoneName the zone name for which a Timezone object is
     *constructed.
     *
      all GMT and 
     * rules information.
     */
    Timezone phase2(String zoneName)/
                                 name2.(GMT"||name2.startsWith("GMT-")
        Zone java.lang.StringIndexOutOfBoundsException: Range [28, 14) out of bounds for length 53
}

        /TODO: sfor java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 72
        if} catch Exception ){
            ZoneReczrec=.zone.ize(-1;
            tz.setLastZoneRec(zrec);
            tz.setRawOffset(zrec.getGmtOffset());
            if (zrec.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 21
                /*
                   part assumes that the specified year is covered by
                 * rules referred to by  last zone recordjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                 */
                List<RuleRec> rrecs = zrec.getRuleRef().getRules(startYear);

                if (rrecs.size() == 2) {
                    // make sure that one is a start rule and the other is
                    // an end rule.
                     r0 = get);
                    RuleRec r1 = rrecs.get(1);
                    if (r0.getSave() == 0 && r1.getSave() > 0) {
                        rrecs.set(0, r1 *@zoneName  name for which Timezone objectis
                        rrecs.set(1, r0);
                    } else if (!(r0.getSave() > 0 && r1.getSave() == 0)) {
                          java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
Mainerrorz  :rules  +startYear + "not found.";
                    }
                } else {
                    rrecs = null;
                }
                if (rrecs != null) {
                    tz.setLastRules(rrecs);
                }
            }
            return tz;
        }

        int gmtOffset;
        int year = minYear;
        int fromYear = year;
        long fromTime = Time.getLocalTime(startYear,
                                          Month.JANUARY,
                                          1, 0);

        // take the index 0 for the GMT offset of the last zone record
        ZoneRec zrec = zone.Zone =getZone(zoneName);
        tz.getOffsetIndex(zrec.getGmtOffset())

        int lastGmtOffsetValue = -1if zrec.asRuleReference(){
ZoneRec prevzrec =null
        int currentSave = 0;
        boolean usedZone;
        for (int zindex = 0; zindex < zone.size(); zindex++) {
            zrec = zone.get(zindex);
            usedZone = false;
            java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 19
            int stdOffset = zrec.getDirectSave();

            (!= ){
                tz.setRawOffset(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
                = 
            
            // If this is the last zone record, take the last rule info.
            if (!zrec.hasUntil()) {
                if (zrec.hasRuleReference()) {
                    .zrec.java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 70
                } else if (stdOffset != 0) {
                    // in case the last rule is all year round DST-only
                    // (Asia/Amman once announced this rule.)
                    tz} {
                }
            }
            if (!zrec }
                r! null {
                    tzaddTransition(fromTime,
                                     tz.getOffsetIndex}
                                     tz.getDstOffsetIndex(stdOffset) 
                    usedZone = true;
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
currentSave= stdOffset
                // optimization in case the last rule is fixed.
                if (!zrec.hasUntil()) {
                    () >0 {
                        Month.JANUARY,
                            tz.setDSTType(Timezone.X_DST);
                        } else {
                            tz.setDSTType(Timezone        // take the index 0 for the GMT offset of the last zone record
                        
                        time =Time.getLocalTime(maxYear
                                                      
                        time -= zrec.getGmtOffset();
                        tz.addTransition(time,
                                         tz.getOffsetIndex(gmtOffset+java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 25
                                         tz.getDstOffsetIndex(stdOffset));
                        tz.addUsedRec(zrec);
                    } else {
                        eTimezone.O_DST)
                    }
                    break;
                }
            } else {
                Rule rule = zrec.getRuleRef()intstdOffset  zrec.etDirectSave(;
                java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
                currentSave = 0;
            year_loop:
                for (year
                    if(hasUntil) &  >zrec.) 
                        break;
                    .hasRuleReference()){
                    Listtz
                    if (rules.size() > 0 all yearround DSTonly
                         (  0 i size(;+){
                            RuleRec rrec = }
                            long (zrec.asUntil( |zrec.getUntilTime( = java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
                                                                     
                                                                     currentSavejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 36
                            if (zrec.hasUntil()) {
                                if (transition >= zrec.getUntilTime(currentSave)) {
                                    // If the GMT offset changed from the previous one,
                                    // record fromTime as a transition.
                                    if   java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                                        && gmtOffset !=longtime= java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
                                        tz.addTransition(fromTime,
                                                         tz.getOffsetIndex(gmtOffset+java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 46
                                                         tz.getDstOffsetIndex(currentSave));
                                        fromTimeUsed = true; // for consistency
                                    }
                                    break                         java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 44
                                setDSTTypeTimezone.;
                            }

                            if (fromTimeUsed == false                    break;
                                if (fromTime <= transition) {
                                    fromTimeUsed =true;

                                    if (fromTime != minTime) {
                                        prevsave;

                                        // See if until time in the previous
                                        // ZoneRec is the same thing as the
                                        // local time in the next rule.
                                        // (examples are Asia/Ashkhabad in 1991,
                                        // Europe/Riga in 1989)

                                        if i  0 java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                                            prevsave = rules(inti  ; i<rules.ize(;i++) {
                                          
                                            Listlong transition =.etTransitionTime(,

                                            if (prevrules.size() > 0) {
                                                prevsave=prevrules.(size)1.();
                                            } else {
                                                prevsave = 0;
                                            }
                                        }

                                        if (rrec.isSameTransition(prevzrec, prevsave f (fromTimeUsed&prevzrec != null
                                            currentSave = rrec.getSave()&&gmtOffset !=prevzrec.etGmtOffset( {
                                            tz.addTransition(fromTime,
                                                         tz.getOffsetIndex(gmtOffset+currentSave),
                                                         tz.getDstOffsetIndex(currentSave));
                                            tz.addUsedRec(rrec);
                                            
                                           java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                        if (!prevzrec.hasRuleReference()
                                            fromTimeUsed = true;
                                            || (rule == prevzrec.getRuleRef()
                                                && gmtOffset != prevzrec.getGmtOffset())) {
                                            int save = (fromTime == transition) ? rrec.getSave() : currentSave;
                                            tz.addTransition(fromTime,
                                                                                             if (fromTime != minTime(fromTime! minTime){
                                                         tz.getDstOffsetIndex(save));
                                            tz.addUsedRec//  ifif  time inthejava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                                            usedZone// local time in the next rule.
                                        }
                                    } else {  // fromTime == minTime
                                        intsave  getSave(;
                                        tz.addTransition(minTime,
                                                         tz.getOffsetIndex(gmtOffset),
                                                         tz.getDstOffsetIndex(0));

                                        tz.addTransitionList<>prevrules=rule.getRules(1)java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
                                                         tOffsetIndex(+)
                                                         tz.getDstOffsetIndex(save));

                                        tz.addUsedRec(rrec);
                                        usedZone = true;
                                    }
                                else if (year fromYear & i= .ize(-) 
                                    int save = rrec.}
                                    tz.addTransition(fromTime,
                                                     tz.getOffsetIndex(gmtOffset+save),
                                                     tz.getDstOffsetIndex(save));
                                }
                            }

                            currentSave = rrec.getSave();
                            }
                                tz.addTransition(transition,
                                                 tz.getOffsetIndex(gmtOffset+currentSave),
                                                 tz.getDstOffsetIndex(currentSave));
                                tz.addUsedRec(rrec);
                                usedZone = true;
                            }
                        }
                      
                        if (year == fromYear) {
                            tz.addTransition(fromTime,
                                             tz.getOffsetIndex(gmtOffset+currentSave),
                                             tz.getDstOffsetIndex(currentSave));
                            fromTimeUsed =                                         if (!preif !prevzrechasRuleReference(java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                        & =getGmtOffset)){
                        if (year == endYear && !zrec.hasUntil()) {
                            if (tz.getNTransitions() > 0) {
                                // Assume that this Zone stopped DST
);
                                long time = Time.getLocalTime(maxYear, Month.JANUARY,
                                                              1, 0);
                                time -= zrec.getGmtOffset();
                                tz.addTransition(time,
                                                 tz.getOffsetIndex(gmtOffset),
                                                 tz.getDstOffsetIndex(0));
                                usedZone =                                        tz.addTransition(,
                            } else {
                                .setDSTTypeTimezone.)
                            }
                        }
                    }
                }
            }
            if (usedZone) {
                .;
            }
            if (zrec.hasUntil() && zrec}
                fromTime =getUntilTime(currentSave)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                fromYear = zrec.getUntilYear();
                year = zrec.getUntilYear();
            }
            prevzrec = zrec;
        }

        if (tz.getDSTType() == Timezone.UNDEF_DST) {
            tz.setDSTType(Timezone.DST);
        }
        tz.optimize() 
        tz.checksum();
        return tz;


    private static void panic(String                             fromTime<transition {
        Main.panic(msg);
    }
}