Ejemplo n.º 1
0
 static ReferenceType getReferenceTypeFromToken(String idToken) {
   ReferenceType cls = null;
   if (Character.isDigit(idToken.charAt(0))) {
     cls = null;
   } else if (idToken.startsWith("*.")) {
     // This notation saves typing by letting the user omit leading
     // package names. The first
     // loaded class whose name matches this limited regular
     // expression is selected.
     idToken = idToken.substring(1);
     for (ReferenceType type : Env.vm().allClasses()) {
       if (type.name().endsWith(idToken)) {
         cls = type;
         break;
       }
     }
   } else {
     // It's a class name
     List<ReferenceType> classes = Env.vm().classesByName(idToken);
     if (classes.size() > 0) {
       // TO DO: handle multiples
       cls = classes.get(0);
     }
   }
   return cls;
 }
Ejemplo n.º 2
0
  synchronized VirtualMachine open() {
    if (connector instanceof LaunchingConnector) {
      vm = launchTarget();
    } else if (connector instanceof AttachingConnector) {
      vm = attachTarget();
    } else if (connector instanceof ListeningConnector) {
      vm = listenTarget();
    } else {
      throw new InternalError(MessageOutput.format("Invalid connect type"));
    }
    vm.setDebugTraceMode(traceFlags);
    if (vm.canBeModified()) {
      setEventRequests(vm);
      resolveEventRequests();
    }
    /*
     * Now that the vm connection is open, fetch the debugee
     * classpath and set up a default sourcepath.
     * (Unless user supplied a sourcepath on the command line)
     * (Bug ID 4186582)
     */
    if (Env.getSourcePath().length() == 0) {
      if (vm instanceof PathSearchingVirtualMachine) {
        PathSearchingVirtualMachine psvm = (PathSearchingVirtualMachine) vm;
        Env.setSourcePath(psvm.classPath());
      } else {
        Env.setSourcePath(".");
      }
    }

    return vm;
  }
Ejemplo n.º 3
0
 static ThreadGroupReference group() {
   if (group == null) {
     // Current thread group defaults to the first top level
     // thread group.
     setThreadGroup((ThreadGroupReference) Env.vm().topLevelThreadGroups().get(0));
   }
   return group;
 }
Ejemplo n.º 4
0
 /** Constructor */
 CUP$GMP2OPTParser$actions(GMP2OPTParser parser) throws IOException {
   this.parser = parser;
   // temp1 = new ParseGSCF2(Settings.defaultDirStr +
   temp1 = new ParseGSCF2(Env.getApplicationDataDir() + Settings.fileSeparator + "Energy_data");
   // temp2 = new ParseGSCF2(Settings.defaultDirStr +
   temp2 = new ParseGSCF2(Env.getApplicationDataDir() + Settings.fileSeparator + "temporary2");
   // temp3 = new ParseGSCF2(Settings.defaultDirStr +
   temp3 = new ParseGSCF2(Env.getApplicationDataDir() + Settings.fileSeparator + "temporary3");
   temp1.putField("TitleText: Energy versus Iteration" + " - " + JobPanel.jobName + "\n");
   temp1.putField("XLabel: Iteration\n YLabel: Energy\n");
   temp1.putField("DataSet: Energy\n");
   temp1.putField("1, ");
   temp2.putField("TitleText: Gradient versus Iteration" + " - " + JobPanel.jobName + "\n");
   temp2.putField("XLabel: Iteration\n YLabel: Maximum Gradient\n");
   temp2.putField("DataSet: Maximum Gradient\n");
   temp3.putField("\n\n");
   temp3.putField("XLabel: Iteration\n YLabel: RMS Gradient\n");
   temp3.putField("DataSet: RMS Gradient\n");
 }
Ejemplo n.º 5
0
 private static void initThreads() {
   if (!gotInitialThreads) {
     Iterator iter = Env.vm().allThreads().iterator();
     while (iter.hasNext()) {
       ThreadReference thread = (ThreadReference) iter.next();
       threads.add(new ThreadInfo(thread));
     }
     gotInitialThreads = true;
   }
 }
Ejemplo n.º 6
0
  /**
   * 当前的报表运行环境切换到env
   *
   * @param env 需要切换去的环境
   */
  public static void switchToEnv(Env env) {
    if (env == null) {
      return;
    }

    Env oldEnv = FRContext.getCurrentEnv();
    String oldEnvPath = oldEnv == null ? null : oldEnv.getPath();

    // 看一下这个env在DesignerEnvManager里面有没有对应的,有的话就setCurrentEnvName
    DesignerEnvManager envManager = DesignerEnvManager.getEnvManager();
    java.util.Iterator<String> nameIt = envManager.getEnvNameIterator();
    while (nameIt.hasNext()) {
      String name = nameIt.next();
      if (ComparatorUtils.equals(envManager.getEnv(name), env)) {
        envManager.setCurEnvName(name);
        break;
      }
    }

    // 更新CurrentEnv于FRContext & DesignerEnvManager
    FRContext.setCurrentEnv(env);

    final Env run_env = env;

    // 刷新DesignerFrame里面的面板
    SwingUtilities.invokeLater(
        new Runnable() {

          public void run() {
            if (DesignerContext.getDesignerFrame() == null) {
              return;
            }
            DesignerContext.getDesignerFrame().refreshEnv(run_env);
            DesignerContext.getDesignerFrame().repaint(); // kunsnat: 切换环境后 刷新下 报表. 比如图表某些风格改变.
          }
        });
    // 当换了运行环境,重置服务器,让它下次预览时重启
    if (env instanceof LocalEnv && !ComparatorUtils.equals(env.getPath(), oldEnvPath)) {
      StartServer.currentEnvChanged();
    }
  }
Ejemplo n.º 7
0
  Message buildAddrMsg(int dest, Message msg, int msgSize) {
    AddressMsg addrMsg = new AddressMsg(AddressMsg.DEFAULT_MESSAGE_SIZE + msgSize);
    String moteid = Env.getenv("MOTEID");
    int source = 0xFFFF;

    if (moteid != null) {
      source = Integer.parseInt(moteid);
    }

    addrMsg.dataSet(msg.dataGet(), 0, addrMsg.offset_data(0), msgSize);

    addrMsg.set_dest(dest);
    addrMsg.set_source(source);

    return addrMsg;
  }
Ejemplo n.º 8
0
 /**
  * Constructor that specifies the source control environment.
  *
  * @param e Source control environment to use.
  */
 public P4Process(Env e) {
   super();
   if (null == rt) {
     rt = Runtime.getRuntime();
   }
   if (null == e) {
     if (null == base) {
       base = this;
       this.environ = new Env();
     } else {
       this.environ = new Env(base.getEnv());
     }
   } else {
     this.environ = e;
   }
   if (null != environ) this.threshold = environ.getServerTimeout();
 }
Ejemplo n.º 9
0
  /**
   * Create an instantiation of a generic prototype given by parameter gt
   *
   * @param gt
   * @param env
   * @return
   */
  private CompilationUnit createGenericPrototypeInstantiation(
      ExprGenericPrototypeInstantiation gt, Env env) {

    CompilationUnit genericProto = null;

    /* if ( gt.getName().equals("generic02.gb.G1<X>") ) {
    	System.out.println("generic02.gb.G1<X>");
    	gt.ifPrototypeReturnsNameWithPackageAndType(env);
    } */

    String genSourceFileName = gt.getGenericSourceFileName();

    String genSourceFileNameVaryingNumberOfParameters =
        gt.getGenericSourceFileNameWithVaryingNumberOfParameters();
    // if ( gt.getRealTypeListList().size() > 1 )
    // System.out.println("3");

    boolean isInterface = false;
    if (NameServer.isPrototypeFromInterface(genSourceFileName)) {
      // int sizePrefix = NameServer.prefixProtoInterface.length();
      isInterface = true;
      /*
      genSourceFileName = genSourceFileName.substring(sizePrefix);
      genSourceFileNameVaryingNumberOfParameters = genSourceFileNameVaryingNumberOfParameters.substring(sizePrefix);
      */
      genSourceFileName = NameServer.prototypeFileNameFromInterfaceFileName(genSourceFileName);
      genSourceFileNameVaryingNumberOfParameters =
          NameServer.prototypeFileNameFromInterfaceFileName(
              genSourceFileNameVaryingNumberOfParameters);
    }
    // something like util.Stack if gt is "util.Stack<Int>" or
    // Stack if gt is Stack<Int>
    ExprIdentStar typeIdent = gt.getTypeIdent();
    if (typeIdent.getIdentSymbolArray().size() == 1) {
      // no package preceding the generic prototype name as in "Stack<Int>"
      ProgramUnit pu =
          env.searchProgramUnitBySourceFileName(genSourceFileName, gt.getFirstSymbol(), false);
      if (pu != null) {
        genericProto = pu.getCompilationUnit();
        ProgramUnit pu2 =
            env.searchProgramUnitBySourceFileName(
                genSourceFileNameVaryingNumberOfParameters, gt.getFirstSymbol(), false);
        if (pu2 != null)
          /* found both generic prototype and generic prototype with varying number of parameters
           * Example: found both Tuple<T> and Tuple<T+>
           */
          env.error(
              gt.getFirstSymbol(),
              "Ambiguity in creating a real prototype from a generic prototype. There is both "
                  + pu.getCompilationUnit().getPackageName()
                  + "."
                  + genSourceFileName
                  + " and "
                  + pu2.getCompilationUnit().getPackageName()
                  + "."
                  + genSourceFileNameVaryingNumberOfParameters,
              true);
      }
      if (genericProto == null) {
        pu =
            env.searchProgramUnitBySourceFileName(
                genSourceFileNameVaryingNumberOfParameters, gt.getFirstSymbol(), false);
        if (pu != null) genericProto = pu.getCompilationUnit();
      }
    } else {
      // package preceding the generic prototype name as in "util.Stack<Int>"
      int i = 0;
      ArrayList<Symbol> symbolList = typeIdent.getIdentSymbolArray();
      int sizeLessOne = symbolList.size() - 1;
      String packageName = "";
      while (i < sizeLessOne) {
        packageName = packageName + symbolList.get(i).getSymbolString();
        ++i;
        if (i < sizeLessOne) packageName += ".";
      }
      CyanPackage cyanPackage = env.getProject().searchPackage(packageName);
      if (cyanPackage == null) {
        env.error(typeIdent.getFirstSymbol(), "Package '" + packageName + "' was not found", true);
        return null;
      }
      // first searches for something like "Stack(1)" in package 'util'
      for (CompilationUnit cunit : cyanPackage.getCompilationUnitList()) {
        if (genSourceFileName.equals(cunit.getFileNameWithoutExtension())) {
          genericProto = cunit;
          break;
        }
      }
      CompilationUnit genericProto2 = null;
      // searches for a generic prototype with varying number of parameters
      // something like "Stack(1+)"
      for (CompilationUnit cunit : cyanPackage.getCompilationUnitList()) {
        if (genSourceFileNameVaryingNumberOfParameters.equals(
            cunit.getFileNameWithoutExtension())) {
          genericProto2 = cunit;
          break;
        }
      }

      if (genericProto != null && genericProto2 != null) {
        env.error(
            gt.getFirstSymbol(),
            "Ambiguity in creating a real prototype from a generic prototype. There is both "
                + genericProto.getPackageName()
                + "."
                + genSourceFileName
                + " and "
                + genericProto2.getPackageName()
                + "."
                + genSourceFileNameVaryingNumberOfParameters,
            true);
      }
      if (genericProto == null) genericProto = genericProto2;
    }

    // genericProto = nameGenProtoUnitTable.get(genSourceFileName);

    if (genericProto == null) {
      env.error(
          true,
          gt.getFirstSymbol(),
          "Prototype '" + gt.getName() + "' was not found",
          gt.getName(),
          ErrorKind.prototype_was_not_found_inside_method);
      /*gt.getProgramUnit().getCompilationUnit().error(null,
      "Internal error at CompilerManager::createInterfaceObjectFunctionAndArray: cannot create " + gt.getName()); */
      return null;
    } else {
      /**
       * if there was no compilation error in "Stack(1).cyan", then create an instance of the
       * generic prototype
       */
      if (isInterface) {
        gt.removeProtoPrefix();
      }

      CompilationUnit newCompilationUnit = genericProto.createInstanceGenericPrototype(gt, env);
      CompilationUnit interCompilationUnit = null;
      /**
       * if the package for this generic prototype instantiation was not created before, create it
       * now.
       */
      CyanPackage cyanPackage = genericProto.getCyanPackage();

      cyanPackage.addCompilationUnit(newCompilationUnit);
      newCompilationUnit.setCyanPackage(cyanPackage);
      nonGenericCompilationUnitList.add(newCompilationUnit);

      if (nameSet.contains(newCompilationUnit.getFullFileNamePath())) {
        env.error(gt.getFirstSymbol(), "Internal error in CompilerManager");
        gt.ifPrototypeReturnsNameWithPackageAndType(env);
      } else nameSet.add(newCompilationUnit.getFullFileNamePath());

      program.addCompilationUnit(newCompilationUnit);

      newCompilationUnit.readSourceFile();
      HashSet<saci.CompilationInstruction> compInstSet = new HashSet<>();
      compInstSet.add(CompilationInstruction.dpa_actions);
      compInstSet.add(CompilationInstruction.pp_addCode);
      if (compilationStep.compareTo(CompilationStep.step_5) >= 0)
        compInstSet.add(CompilationInstruction.new_addCode);
      Compiler compiler =
          new Compiler(newCompilationUnit, compInstSet, compilationStep, project, null);
      compiler.parse();

      if (newCompilationUnit.hasCompilationError()) {
        // newCompilationUnit.printErrorList(printWriter);
        env.setThereWasError(true);
        throw new CompileErrorException();
      } else if (compInstSet.contains(CompilationInstruction.createPrototypesForInterfaces)
          && newCompilationUnit.getPrototypeIsNotGeneric()
          && newCompilationUnit.getPublicPrototype() instanceof InterfaceDec) {
        // if public program unit is an interface, create ProtoInterface

        interCompilationUnit = newCompilationUnit.createProtoInterface();
        if (interCompilationUnit != null) {

          interCompilationUnit.setCyanPackage(cyanPackage);
          cyanPackage.addCompilationUnit(interCompilationUnit);
          newCompilationUnit.setCyanPackage(cyanPackage);
          nonGenericCompilationUnitList.add(interCompilationUnit);

          String nameInter = interCompilationUnit.getFilename();
          if (nameInter.endsWith(NameServer.dotCyanSourceFileExtension))
            nameInter =
                nameInter.substring(
                    0, nameInter.length() - NameServer.sizeCyanSourceFileExtensionPlusOne);

          // nameRealGenProtoUnitTable.put(nameInter, interCompilationUnit);
          program.addCompilationUnit(interCompilationUnit);

          interCompilationUnit.readSourceFile();
          compiler =
              new Compiler(interCompilationUnit, compInstSet, compilationStep, project, null);
          compiler.parse();
          if (interCompilationUnit.getActionList().size() > 0)
            interCompilationUnit.doActionList(printWriter);
          interCompilationUnit.clearErrorsActions();
        }
      }
      // newCompilationUnit.clearErrorsActions();
      if (isInterface) return interCompilationUnit;
      else return newCompilationUnit;
    }
  }
Ejemplo n.º 10
0
  /**
   * Create a generic prototype from parameter gpi. The new prototype is compiled. If it is an
   * interface, the prototype Proto_IntefaceName is created too. Methods calcInterfaceTypes and
   * calcInternalTypes are called for both the prototype and its Proto_InterfaceName, if any.
   *
   * @param gpi
   * @param env
   * @return
   */
  public static ProgramUnit createGenericPrototype(ExprGenericPrototypeInstantiation gpi, Env env) {

    saci.Tuple<String, Type> t = gpi.ifPrototypeReturnsNameWithPackageAndType(env);

    // t.f1 is the name of the prototype
    if (t != null && t.f2 != null) {
      /*
       * prototype has already been created before
       */
      if (t.f2 instanceof ProgramUnit) {
        return (ProgramUnit) t.f2;
      } else {
        env.error(
            gpi.getFirstSymbol(),
            "Internal error: a type that is not a program unit is used to instantiate a generic prototype");
        return null;
      }

    } else {
      /*
       * prototype has not been created. Create it.
       */
      // if ( env.getCurrentMethod() != null && env.getCurrentMethod().getName().contains("run2") )
      //	gpi.ifPrototypeReturnsItsNameWithPackage(env);

      /*
       * first, create all prototypes that are real parameters to this generic prototype instantiation
       */
      for (ArrayList<Expr> realTypeList : gpi.getRealTypeListList()) {
        for (Expr realType : realTypeList) {
          if (realType instanceof ExprGenericPrototypeInstantiation) {
            ExprGenericPrototypeInstantiation genRealType =
                (ExprGenericPrototypeInstantiation) realType;
            genRealType.setType(createGenericPrototype(genRealType, env));
            // 		javaName = type.getJavaName();
            genRealType.setJavaName(genRealType.getType().getJavaName());
          }
        }
      }

      CompilationUnit compUnit =
          env.getProject().getCompilerManager().createGenericPrototypeInstantiation(gpi, env);

      Env newEnv = new Env(env.getProject());
      /*
      * If a generic prototype is created when method calcInterfaceTypes of Program is being executed
      * (env.getProject().getProgram().getInCalcInterfaceTypes() returns true), it is not necessary
      * to call its method calcInterfaceTypes. It will be called in the loop of
      * method Program::calcInterfaceTypes.

      * If a generic prototype is created when method calcInternalTypes of Program is being executed,
      * method calcInterfaceTypes of this generic prototype should be called because the interface
      * of this prototype is necessary in methods calcInternalTypes. Method calcInternalTypes
      * of this newly created generic prototype will be called in the loop of
      * method Program::calcInternalTypes.
      *
      * calcInternalTypes cannot be called when a generic prototype is created when
      * the compiler is calling calcInterfaceTypes. If this is allowed, some calcInternalType
      * method could try to use the interface of some prototype P whose method calcInterfaceTypes
      * have not been called.
      */
      if (!env.getProject().getProgram().getInCalcInterfaceTypes()) {
        compUnit.calcInterfaceTypes(newEnv);
        // compUnit.calcInternalTypes(newEnv);
      }
      CompilationUnit interfaceCompilationUnit = compUnit.getInterfaceCompilationUnit();
      if (interfaceCompilationUnit != null) {
        newEnv = new Env(env.getProject());
        if (!env.getProject().getProgram().getInCalcInterfaceTypes()) {
          interfaceCompilationUnit.calcInterfaceTypes(newEnv);
        }
      }
      /*
       * if the generic prototype was created from phase (4), included, onwards, then execute
       * the ati actions. A generic prototype instantiation can only change itself and
       * no other prototype can change it.
       */
      if (env.getProject().getCompilerManager().getCompilationStep().ordinal()
          > CompilationStep.step_3.ordinal()) {
        apply_ati_ActionsToGenericPrototype(newEnv, compUnit);
        if (interfaceCompilationUnit != null) {
          apply_ati_ActionsToGenericPrototype(env, interfaceCompilationUnit);
        }
      }

      return compUnit.getPublicPrototype();
    }
  }
Ejemplo n.º 11
0
 /**
  * Test / Load
  *
  * @param args
  */
 public static void main(String[] args) {
   Compiere.startup(true);
   /**
    * To add your regions, complete the code below. Please make sure that the file is converted via
    * the Java utility native2ascii - i.e. all seven bit code with /u0000 unicode stuff
    */
   int C_Country_ID = 216; // 	Japan
   MCountry country = new MCountry(Env.getCtx(), C_Country_ID, null);
   // Hokkaido
   MRegion temp = new MRegion(country, "\u5317\u6d77\u9053");
   temp.setDescription("\u5317\u6d77\u9053(Hokkaido)");
   temp.save();
   // Aomori
   temp = new MRegion(country, "\u9752\u68ee\u770c");
   temp.setDescription("\u9752\u68ee\u770c(Aomori)");
   temp.save();
   // Iwate
   temp = new MRegion(country, "\u5ca9\u624b\u770c");
   temp.setDescription("\u5ca9\u624b\u770c(Iwate)");
   temp.save();
   // Miyagi
   temp = new MRegion(country, "\u5bae\u57ce\u770c");
   temp.setDescription("\u5bae\u57ce\u770c(Miyagi)");
   temp.save();
   // Akita
   temp = new MRegion(country, "\u79cb\u7530\u770c");
   temp.setDescription("\u79cb\u7530\u770c(Akita)");
   temp.save();
   // Yamagata
   temp = new MRegion(country, "\u5c71\u5f62\u770c");
   temp.setDescription("\u5c71\u5f62\u770c(Yamagata)");
   temp.save();
   // Fukushima
   temp = new MRegion(country, "\u798f\u5cf6\u770c");
   temp.setDescription("\u798f\u5cf6\u770c(Fukushima)");
   temp.save();
   // Ibaraki
   temp = new MRegion(country, "\u8328\u57ce\u770c");
   temp.setDescription("\u8328\u57ce\u770c(Ibaraki)");
   temp.save();
   // Gunma
   temp = new MRegion(country, "\u7fa4\u99ac\u770c");
   temp.setDescription("\u7fa4\u99ac\u770c(Gunma)");
   temp.save();
   // Saitama
   temp = new MRegion(country, "\u57fc\u7389\u770c");
   temp.setDescription("\u57fc\u7389\u770c(Saitama)");
   temp.save();
   // Chiba
   temp = new MRegion(country, "\u5343\u8449\u770c");
   temp.setDescription("\u5343\u8449\u770c(Chiba)");
   temp.save();
   // Tokyo
   temp = new MRegion(country, "\u6771\u4eac\u90fd");
   temp.setDescription("\u6771\u4eac\u90fd(Tokyo)");
   temp.save();
   // Kanagawa
   temp = new MRegion(country, "\u795e\u5948\u5ddd\u770c");
   temp.setDescription("\u795e\u5948\u5ddd\u770c(Kanagawa)");
   temp.save();
   // Niigata
   temp = new MRegion(country, "\u65b0\u6f5f\u770c");
   temp.setDescription("\u65b0\u6f5f\u770c(Niigata)");
   temp.save();
   // Toyama
   temp = new MRegion(country, "\u5bcc\u5c71\u770c");
   temp.setDescription("\u5bcc\u5c71\u770c(Toyama)");
   temp.save();
   // Ishikawa
   temp = new MRegion(country, "\u77f3\u5ddd\u770c");
   temp.setDescription("\u77f3\u5ddd\u770c(Ishikawa)");
   temp.save();
   // Fukui
   temp = new MRegion(country, "\u798f\u4e95\u770c");
   temp.setDescription("\u798f\u4e95\u770c(Fukui)");
   temp.save();
   // Yamanashi
   temp = new MRegion(country, "\u5c71\u68a8\u770c");
   temp.setDescription("\u5c71\u68a8\u770c(Yamanashi)");
   temp.save();
   // Gifu
   temp = new MRegion(country, "\u5c90\u961c\u770c");
   temp.setDescription("\u5c90\u961c\u770c(Gifu)");
   temp.save();
   // Shizuoka
   temp = new MRegion(country, "\u9759\u5ca1\u770c");
   temp.setDescription("\u9759\u5ca1\u770c(Shizuoka)");
   temp.save();
   // Aichi
   temp = new MRegion(country, "\u611b\u77e5\u770c");
   temp.setDescription("\u611b\u77e5\u770c(Aichi)");
   temp.save();
   // Mie
   temp = new MRegion(country, "\u4e09\u91cd\u770c");
   temp.setDescription("\u4e09\u91cd\u770c(Mie)");
   temp.save();
   // Siga
   temp = new MRegion(country, "\u6ecb\u8cc0\u770c");
   temp.setDescription("\u6ecb\u8cc0\u770c(Siga)");
   temp.save();
   // Kyoto
   temp = new MRegion(country, "\u4eac\u90fd\u5e9c");
   temp.setDescription("\u4eac\u90fd\u5e9c(Kyoto)");
   temp.save();
   // Osaka
   temp = new MRegion(country, "\u5927\u962a\u5e9c");
   temp.setDescription("\u5927\u962a\u5e9c(Osaka)");
   temp.save();
   // Hyogo
   temp = new MRegion(country, "\u5175\u5eab\u770c");
   temp.setDescription("\u5175\u5eab\u770c(Hyogo)");
   temp.save();
   // Nara
   temp = new MRegion(country, "\u5948\u826f\u770c");
   temp.setDescription("\u5948\u826f\u770c(Nara)");
   temp.save();
   // Wakayama
   temp = new MRegion(country, "\u548c\u6b4c\u5c71\u770c");
   temp.setDescription("\u548c\u6b4c\u5c71\u770c(Wakayama)");
   temp.save();
   // Tottori
   temp = new MRegion(country, "\u9ce5\u53d6\u770c");
   temp.setDescription("\u9ce5\u53d6\u770c(Tottori)");
   temp.save();
   // Shimane
   temp = new MRegion(country, "\u5cf6\u6839\u770c");
   temp.setDescription("\u5cf6\u6839\u770c(Shimane)");
   temp.save();
   // Okayama
   temp = new MRegion(country, "\u5ca1\u5c71\u770c");
   temp.setDescription("\u5ca1\u5c71\u770c(Okayama)");
   temp.save();
   // Hiroshima
   temp = new MRegion(country, "\u5e83\u5cf6\u770c");
   temp.setDescription("\u5e83\u5cf6\u770c(Hiroshima)");
   temp.save();
   // Yamaguchi
   temp = new MRegion(country, "\u5c71\u53e3\u770c");
   temp.setDescription("\u5c71\u53e3\u770c(Yamaguchi)");
   temp.save();
   // Tokushima
   temp = new MRegion(country, "\u5fb3\u5cf6\u770c");
   temp.setDescription("\u5fb3\u5cf6\u770c(Tokushima)");
   temp.save();
   // Kagawa
   temp = new MRegion(country, "\u9999\u5ddd\u770c");
   temp.setDescription("\u9999\u5ddd\u770c(Kagawa)");
   temp.save();
   // Ehime
   temp = new MRegion(country, "\u611b\u5a9b\u770c");
   temp.setDescription("\u611b\u5a9b\u770c(Ehime)");
   temp.save();
   // Kouchi
   temp = new MRegion(country, "\u9ad8\u77e5\u770c");
   temp.setDescription("\u9ad8\u77e5\u770c(Kouchi)");
   temp.save();
   // Fukuoka
   temp = new MRegion(country, "\u798f\u5ca1\u770c");
   temp.setDescription("\u798f\u5ca1\u770c(Fukuoka)");
   temp.save();
   // Saga
   temp = new MRegion(country, "\u4f50\u8cc0\u770c");
   temp.setDescription("\u4f50\u8cc0\u770c(Saga)");
   temp.save();
   // Nagasaki
   temp = new MRegion(country, "\u9577\u5d0e\u770c");
   temp.setDescription("\u9577\u5d0e\u770c(Nagasaki)");
   temp.save();
   // Kumamoto
   temp = new MRegion(country, "\u718a\u672c\u770c");
   temp.setDescription("\u718a\u672c\u770c(Kumamoto)");
   temp.save();
   // Ohita
   temp = new MRegion(country, "\u5927\u5206\u770c");
   temp.setDescription("\u5927\u5206\u770c(Ohita)");
   temp.save();
   // Miyasaki
   temp = new MRegion(country, "\u5bae\u5d0e\u770c");
   temp.setDescription("\u5bae\u5d0e\u770c(Miyasaki)");
   temp.save();
   // Kagoshima
   temp = new MRegion(country, "\u9e7f\u5150\u5cf6\u770c");
   temp.setDescription("\u9e7f\u5150\u5cf6\u770c(Kagoshima)");
   temp.save();
   // Okinawa
   temp = new MRegion(country, "\u6c96\u7e04\u770c");
   temp.setDescription("\u6c96\u7e04\u770c(Okinawa)");
   temp.save();
 } //	main
Ejemplo n.º 12
0
 /**
  * Sets the environment to use.
  *
  * @param e Source control environment.
  */
 public void setEnv(Env e) {
   this.environ = e;
   if (null != environ) this.threshold = environ.getServerTimeout();
 }
Ejemplo n.º 13
0
  public static void main(String argv[]) throws MissingResourceException {
    redirectOutMessage();

    String cmdLine = "";
    String javaArgs = "";
    int traceFlags = VirtualMachine.TRACE_NONE;
    boolean launchImmediately = false;
    String connectSpec = null;

    MessageOutput.textResources =
        ResourceBundle.getBundle(
            "com.sun.tools.example.debug.tty.TTYResources", Locale.getDefault());

    for (int i = 0; i < argv.length; i++) {
      String token = argv[i];
      if (token.equals("-dbgtrace")) {
        if ((i == argv.length - 1) || !Character.isDigit(argv[i + 1].charAt(0))) {
          traceFlags = VirtualMachine.TRACE_ALL;
        } else {
          String flagStr = "";
          try {
            flagStr = argv[++i];
            traceFlags = Integer.decode(flagStr).intValue();
          } catch (NumberFormatException nfe) {
            usageError("dbgtrace flag value must be an integer:", flagStr);
            return;
          }
        }
      } else if (token.equals("-X")) {
        usageError("Use java minus X to see");
        return;
      } else if (
      // Standard VM options passed on
      token.equals("-v")
          || token.startsWith("-v:")
          || // -v[:...]
          token.startsWith("-verbose")
          || // -verbose[:...]
          token.startsWith("-D")
          ||
          // -classpath handled below
          // NonStandard options passed on
          token.startsWith("-X")
          ||
          // Old-style options (These should remain in place as long as
          //  the standard VM accepts them)
          token.equals("-noasyncgc")
          || token.equals("-prof")
          || token.equals("-verify")
          || token.equals("-noverify")
          || token.equals("-verifyremote")
          || token.equals("-verbosegc")
          || token.startsWith("-ms")
          || token.startsWith("-mx")
          || token.startsWith("-ss")
          || token.startsWith("-oss")) {

        javaArgs = addArgument(javaArgs, token);
      } else if (token.equals("-tclassic")) {
        usageError("Classic VM no longer supported.");
        return;
      } else if (token.equals("-tclient")) {
        // -client must be the first one
        javaArgs = "-client " + javaArgs;
      } else if (token.equals("-tserver")) {
        // -server must be the first one
        javaArgs = "-server " + javaArgs;
      } else if (token.equals("-sourcepath")) {
        if (i == (argv.length - 1)) {
          usageError("No sourcepath specified.");
          return;
        }
        Env.setSourcePath(argv[++i]);
      } else if (token.equals("-classpath")) {
        if (i == (argv.length - 1)) {
          usageError("No classpath specified.");
          return;
        }
        javaArgs = addArgument(javaArgs, token);
        javaArgs = addArgument(javaArgs, argv[++i]);
      } else if (token.equals("-attach")) {
        if (connectSpec != null) {
          usageError("cannot redefine existing connection", token);
          return;
        }
        if (i == (argv.length - 1)) {
          usageError("No attach address specified.");
          return;
        }
        String address = argv[++i];

        /*
         * -attach is shorthand for one of the reference implementation's
         * attaching connectors. Use the shared memory attach if it's
         * available; otherwise, use sockets. Build a connect
         * specification string based on this decision.
         */
        if (supportsSharedMemory()) {
          connectSpec = "com.sun.jdi.SharedMemoryAttach:name=" + address;
        } else {
          String suboptions = addressToSocketArgs(address);
          connectSpec = "com.sun.jdi.SocketAttach:" + suboptions;
        }
      } else if (token.equals("-listen") || token.equals("-listenany")) {
        if (connectSpec != null) {
          usageError("cannot redefine existing connection", token);
          return;
        }
        String address = null;
        if (token.equals("-listen")) {
          if (i == (argv.length - 1)) {
            usageError("No attach address specified.");
            return;
          }
          address = argv[++i];
        }

        /*
         * -listen[any] is shorthand for one of the reference implementation's
         * listening connectors. Use the shared memory listen if it's
         * available; otherwise, use sockets. Build a connect
         * specification string based on this decision.
         */
        if (supportsSharedMemory()) {
          connectSpec = "com.sun.jdi.SharedMemoryListen:";
          if (address != null) {
            connectSpec += ("name=" + address);
          }
        } else {
          connectSpec = "com.sun.jdi.SocketListen:";
          if (address != null) {
            connectSpec += addressToSocketArgs(address);
          }
        }
      } else if (token.equals("-launch")) {
        launchImmediately = true;
      } else if (token.equals("-listconnectors")) {
        Commands evaluator = new Commands();
        evaluator.commandConnectors(Bootstrap.virtualMachineManager());
        return;
      } else if (token.equals("-connect")) {
        /*
         * -connect allows the user to pick the connector
         * used in bringing up the target VM. This allows
         * use of connectors other than those in the reference
         * implementation.
         */
        if (connectSpec != null) {
          usageError("cannot redefine existing connection", token);
          return;
        }
        if (i == (argv.length - 1)) {
          usageError("No connect specification.");
          return;
        }
        connectSpec = argv[++i];
      } else if (token.equals("-help")) {
        usage();
      } else if (token.equals("-version")) {
        Commands evaluator = new Commands();
        evaluator.commandVersion(progname, Bootstrap.virtualMachineManager());
        System.exit(0);
      } else if (token.startsWith("-")) {
        usageError("invalid option", token);
        return;
      } else {
        // Everything from here is part of the command line
        cmdLine = addArgument("", token);
        for (i++; i < argv.length; i++) {
          cmdLine = addArgument(cmdLine, argv[i]);
        }
        break;
      }
    }

    /*
     * Unless otherwise specified, set the default connect spec.
     */

    /*
     * Here are examples of jdb command lines and how the options
     * are interpreted as arguments to the program being debugged.
     * arg1       arg2
     * ----       ----
     * jdb hello a b       a          b
     * jdb hello "a b"     a b
     * jdb hello a,b       a,b
     * jdb hello a, b      a,         b
     * jdb hello "a, b"    a, b
     * jdb -connect "com.sun.jdi.CommandLineLaunch:main=hello  a,b"   illegal
     * jdb -connect  com.sun.jdi.CommandLineLaunch:main=hello "a,b"   illegal
     * jdb -connect 'com.sun.jdi.CommandLineLaunch:main=hello "a,b"'  arg1 = a,b
     * jdb -connect 'com.sun.jdi.CommandLineLaunch:main=hello "a b"'  arg1 = a b
     * jdb -connect 'com.sun.jdi.CommandLineLaunch:main=hello  a b'   arg1 = a  arg2 = b
     * jdb -connect 'com.sun.jdi.CommandLineLaunch:main=hello "a," b' arg1 = a, arg2 = b
     */
    if (connectSpec == null) {
      connectSpec = "com.sun.jdi.CommandLineLaunch:";
    } else if (!connectSpec.endsWith(",") && !connectSpec.endsWith(":")) {
      connectSpec += ","; // (Bug ID 4285874)
    }

    cmdLine = cmdLine.trim();
    javaArgs = javaArgs.trim();

    if (cmdLine.length() > 0) {
      if (!connectSpec.startsWith("com.sun.jdi.CommandLineLaunch:")) {
        usageError("Cannot specify command line with connector:", connectSpec);
        return;
      }
      connectSpec += "main=" + cmdLine + ",";
    }

    if (javaArgs.length() > 0) {
      if (!connectSpec.startsWith("com.sun.jdi.CommandLineLaunch:")) {
        usageError("Cannot specify target vm arguments with connector:", connectSpec);
        return;
      }
      connectSpec += "options=" + javaArgs + ",";
    }

    try {
      if (!connectSpec.endsWith(",")) {
        connectSpec += ","; // (Bug ID 4285874)
      }
      Env.init(connectSpec, launchImmediately, traceFlags);
      new ThreadDumper();
    } catch (Exception e) {
      MessageOutput.printException("Internal exception:", e);
    }
  }
Ejemplo n.º 14
0
  /**
   * Execute Process Instance and Lock UI. Calls lockUI and unlockUI if parent is a ASyncProcess
   *
   * <pre>
   * 	- Get Process Information
   *      - Call Class
   * 	- Submit SQL Procedure
   * 	- Run SQL Procedure
   * </pre>
   */
  public void run() {
    log.fine("AD_PInstance_ID=" + m_pi.getAD_PInstance_ID() + ", Record_ID=" + m_pi.getRecord_ID());

    //  Lock
    // lock();
    //	try {System.out.println(">> sleeping ..");sleep(20000);System.out.println(".. sleeping <<");}
    // catch (Exception e) {}

    //	Get Process Information: Name, Procedure Name, ClassName, IsReport, IsDirectPrint
    String ProcedureName = "";
    int AD_ReportView_ID = 0;
    int AD_Workflow_ID = 0;
    boolean IsReport = false;
    boolean IsDirectPrint = false;
    //
    String sql =
        "SELECT p.Name, p.ProcedureName,p.ClassName, p.AD_Process_ID," //	1..4
            + " p.isReport,p.IsDirectPrint,p.AD_ReportView_ID,p.AD_Workflow_ID," //	5..8
            + " CASE WHEN COALESCE(p.Statistic_Count,0)=0 THEN 0 ELSE p.Statistic_Seconds/p.Statistic_Count END CASE,"
            + " p.IsServerProcess "
            + "FROM AD_Process p"
            + " INNER JOIN AD_PInstance i ON (p.AD_Process_ID=i.AD_Process_ID) "
            + "WHERE p.IsActive='Y'"
            + " AND i.AD_PInstance_ID=?";
    if (!Env.isBaseLanguage(m_wscctx, "AD_Process"))
      sql =
          "SELECT t.Name, p.ProcedureName,p.ClassName, p.AD_Process_ID," //	1..4
              + " p.isReport, p.IsDirectPrint,p.AD_ReportView_ID,p.AD_Workflow_ID," //	5..8
              + " CASE WHEN COALESCE(p.Statistic_Count,0)=0 THEN 0 ELSE p.Statistic_Seconds/p.Statistic_Count END CASE,"
              + " p.IsServerProcess "
              + "FROM AD_Process p"
              + " INNER JOIN AD_PInstance i ON (p.AD_Process_ID=i.AD_Process_ID) "
              + " INNER JOIN AD_Process_Trl t ON (p.AD_Process_ID=t.AD_Process_ID"
              + " AND t.AD_Language='"
              + Env.getAD_Language(m_wscctx)
              + "') "
              + "WHERE p.IsActive='Y'"
              + " AND i.AD_PInstance_ID=?";
    //
    try {
      PreparedStatement pstmt =
          DB.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, null);
      pstmt.setInt(1, m_pi.getAD_PInstance_ID());
      ResultSet rs = pstmt.executeQuery();
      if (rs.next()) {
        m_pi.setTitle(rs.getString(1));
        if (m_waiting != null) m_waiting.setTitle(m_pi.getTitle());
        ProcedureName = rs.getString(2);
        m_pi.setClassName(rs.getString(3));
        m_pi.setAD_Process_ID(rs.getInt(4));
        //	Report
        if ("Y".equals(rs.getString(5))) {
          IsReport = true;
          if ("Y".equals(rs.getString(6)) && !Ini.isPropertyBool(Ini.P_PRINTPREVIEW))
            IsDirectPrint = true;
        }
        AD_ReportView_ID = rs.getInt(7);
        AD_Workflow_ID = rs.getInt(8);
        //
        int estimate = rs.getInt(9);
        if (estimate != 0) {
          m_pi.setEstSeconds(estimate + 1); //  admin overhead
          if (m_waiting != null) m_waiting.setTimerEstimate(m_pi.getEstSeconds());
        }
        m_IsServerProcess = "Y".equals(rs.getString(10));
      } else log.log(Level.SEVERE, "No AD_PInstance_ID=" + m_pi.getAD_PInstance_ID());
      rs.close();
      pstmt.close();
    } catch (SQLException e) {
      m_pi.setSummary(
          Msg.getMsg(m_wscctx, "ProcessNoProcedure") + " " + e.getLocalizedMessage(), true);
      // unlock();
      log.log(Level.SEVERE, "run", e);
      return;
    }

    //  No PL/SQL Procedure
    if (ProcedureName == null) ProcedureName = "";

    /** ******************************************************************** Workflow */
    if (AD_Workflow_ID > 0) {
      startWorkflow(AD_Workflow_ID);
      // unlock();
      return;
    }

    /** ******************************************************************** Start Optional Class */
    if (m_pi.getClassName() != null) {
      //	Run Class
      if (!startProcess()) {
        // unlock();
        return;
      }

      //  No Optional SQL procedure ... done
      if (!IsReport && ProcedureName.length() == 0) {
        // unlock ();
        return;
      }
      //  No Optional Report ... done
      if (IsReport && AD_ReportView_ID == 0) {
        // unlock ();
        return;
      }
    }

    //  If not a report, we need a prodedure name
    if (!IsReport && ProcedureName.length() == 0) {
      m_pi.setSummary(Msg.getMsg(m_wscctx, "ProcessNoProcedure"), true);
      // unlock();
      return;
    }

    /** ******************************************************************** Report submission */
    if (IsReport) {
      //	Optional Pre-Report Process
      if (ProcedureName.length() > 0) {
        if (!startDBProcess(ProcedureName)) {
          // unlock();
          return;
        }
      } //	Pre-Report

      //	Start Report	-----------------------------------------------
      boolean ok = ReportCtl.start(m_pi, IsDirectPrint);
      m_pi.setSummary("Report", !ok);
      // unlock ();
    }
    /** ******************************************************************** Process submission */
    else {
      if (!startDBProcess(ProcedureName)) {
        // unlock();
        return;
      }
      //	Success - getResult
      ProcessInfoUtil.setSummaryFromDB(m_pi);
      // unlock();
    } //	*** Process submission ***
    //	log.fine(Log.l3_Util, "ProcessCtl.run - done");
  } //  run